@m2k-5f/pgtx 2.6.0 → 2.6.2

package/dist/error.d.ts

@@ -15,7 +15,12 @@ export declare class PostgresError extends Error {
     get isTimeout(): boolean;
     get isConnectionFailure(): boolean;
 }
+export declare const ErrNonceMismatch: PostgresError;
+export declare const ErrPasswordRequired: PostgresError;
+export declare const ErrSocketFailedDuringAuth: PostgresError;
 export declare const ErrQueryTimeout: PostgresError;
+export declare const ErrPoolClosed: PostgresError;
+export declare const ErrTransactionClosed: PostgresError;
 export declare const ErrConnectionClosed: PostgresError;
 export declare const ErrConnectionReconnecting: PostgresError;
 //# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;IAEhB,OAAO,EAAE,MAAM;IACxB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;IACb,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,MAAM;gBART,OAAO,EAAE,MAAM,EACxB,IAAI,GAAE,MAAqB,EAC3B,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,MAAW,EACrB,KAAK,GAAE,MAAW,EAClB,IAAI,GAAE,MAAW,EACjB,QAAQ,GAAE,MAAW,EACrB,QAAQ,GAAE,MAAW,EACrB,UAAU,GAAE,MAAW;IAQlC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAID,IAAI,UAAU,IAAI,OAAO,CAExB;IAID,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAGD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGD,IAAI,mBAAmB,IAAI,OAAO,CAEjC;CACJ;AAED,eAAO,MAAM,eAAe,eAA8C,CAAA;AAE1E,eAAO,MAAM,mBAAmB,eAA8E,CAAA;AAC9G,eAAO,MAAM,yBAAyB,eAA2F,CAAA"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;IAEhB,OAAO,EAAE,MAAM;IACxB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;IACb,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,MAAM;gBART,OAAO,EAAE,MAAM,EACxB,IAAI,GAAE,MAAqB,EAC3B,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,MAAW,EACrB,KAAK,GAAE,MAAW,EAClB,IAAI,GAAE,MAAW,EACjB,QAAQ,GAAE,MAAW,EACrB,QAAQ,GAAE,MAAW,EACrB,UAAU,GAAE,MAAW;IAQlC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAID,IAAI,UAAU,IAAI,OAAO,CAExB;IAID,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAGD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGD,IAAI,mBAAmB,IAAI,OAAO,CAEjC;CACJ;AAED,eAAO,MAAM,gBAAgB,eAAmF,CAAA;AAChH,eAAO,MAAM,mBAAmB,eAAqE,CAAA;AACrG,eAAO,MAAM,yBAAyB,eAAiD,CAAA;AAEvF,eAAO,MAAM,eAAe,eAA8C,CAAA;AAE1E,eAAO,MAAM,aAAa,eAAkE,CAAA;AAE5F,eAAO,MAAM,oBAAoB,eAA6E,CAAA;AAE9G,eAAO,MAAM,mBAAmB,eAA8E,CAAA;AAC9G,eAAO,MAAM,yBAAyB,eAA2F,CAAA"}

package/dist/error.js

@@ -31,6 +31,11 @@ export class PostgresError extends Error {
         return this.code.startsWith('08') || this.code.startsWith('57') && this.code !== '57014';
     }
 }
+export const ErrNonceMismatch = new PostgresError("Protocol violation: server nonce doesn't match client nonce");
+export const ErrPasswordRequired = new PostgresError('The authorization method requires a password.');
+export const ErrSocketFailedDuringAuth = new PostgresError("Socket failed during auth");
 export const ErrQueryTimeout = new PostgresError('Query timeout', '57014');
+export const ErrPoolClosed = new PostgresError("Pool is closed", 'pool_closed', '', "ERROR");
+export const ErrTransactionClosed = new PostgresError("Transaction closed", "transaction_closed", '', "ERROR");
 export const ErrConnectionClosed = new PostgresError("Connection is closed", 'connection_closed', "", "ERROR");
 export const ErrConnectionReconnecting = new PostgresError("Connection are reconnecting", "connection_reconnecting", "", "ERROR");

package/dist/index.d.ts

@@ -120,4 +120,5 @@ export { Connection as Connection };
 export { Transaction as Transaction };
 export { PgtxPool as Pool };
 export * from "./clauses";
+export * from './error';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EACH,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,mBAAmB,EAEnB,WAAW,EACX,aAAa,EACb,cAAc,EACjB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAE,UAAU,IAAI,UAAU,EAAE,CAAA;AAEnC,OAAO,EAAE,WAAW,IAAI,WAAW,EAAE,CAAA;AAErC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA;AAG3B,cAAc,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EACH,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,mBAAmB,EAEnB,WAAW,EACX,aAAa,EACb,cAAc,EACjB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAE,UAAU,IAAI,UAAU,EAAE,CAAA;AAEnC,OAAO,EAAE,WAAW,IAAI,WAAW,EAAE,CAAA;AAErC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA;AAG3B,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA"}

package/dist/index.js

@@ -120,3 +120,4 @@ export { Connection as Connection };
 export { Transaction as Transaction };
 export { PgtxPool as Pool };
 export * from "./clauses";
+export * from './error';

package/dist/pool.d.ts

@@ -1,238 +1,81 @@
-import { Connection, ConnectionParams } from "./connection";
+import { Connection } from "./connection";
 import { Transaction } from "./transaction";
 import { Future } from "fluent-future";
 import { PostgresError } from "./error";
-type PoolParams = ConnectionParams & {
-    max?: number;
-};
+import { PoolPartialConfig, Row } from "./types";
 /**
- * The main entry point for Pgtx.
- * Manages a connection pool and provides high-level API for queries and transactions.
+ * Connection pool and the main entry point for Pgtx.
  *
  * @example
- * ```ts
- * const pool = new Pool({
- *   host: 'localhost',
- *   user: 'postgres',
- *   password: 'postgres',
- *   database: 'test',
- *   max: 10
- * })
- *
- * // Simple query
+ * const pool = new Pool({ host: 'localhost', user: 'postgres', password: 'postgres', database: 'test', max: 10 })
  * const users = await pool.query`SELECT * FROM users WHERE id = ${1}`
- *
- * // Transaction
- * const result = await pool.begin(async tx => {
- *   await tx.query`INSERT INTO users ...`
- *   return 'success'
- * })
- *
- * // Manual acquire/release
- * const conn = await pool.acquire()
- * try {
- *   await conn.query`SELECT 1`
- * } finally {
- *   pool.release(conn)
- * }
- *
- * // Clean up
- *  pool.close()
- * ```
+ * await pool.begin(async tx => tx.query`INSERT INTO users ...`)
+ * await pool.close()
  */
 export declare class Pool {
     private _available;
-    private _config;
-    private _max;
+    private config;
     private _total;
     private _waiting;
-    private _isClosed;
-    private _checkClosed;
-    constructor(params: PoolParams);
+    private _isOpened;
+    constructor(config: PoolPartialConfig);
     /**
-     * Acquires a dedicated connection from the pool.
-     *
-     * **Note:** You must call `pool.release(conn)` manually when finished.
-     * For most cases, prefer using `pool.query()` or `pool.begin()` which handle this automatically.
-     *
-     * @returns A connection from the pool or a new one if available.
-     *
-     * @example
-     * ```ts
-     * const conn = await pool.acquire()
-     * try {
-     *   await conn.query`SELECT 1`
-     * } finally {
-     *   pool.release(conn)
-     * }
-     * ```
+     * Acquires a dedicated connection. Call `pool.release(conn)` when done —
+     * prefer `pool.query()`/`pool.begin()` where possible, they release automatically.
      */
     acquire(): Future<Connection, PostgresError>;
     /**
-     * Provides a safe execution context for performing low-level operations
-     * directly on a single, dedicated `Connection` instance.
-     *
-     * Automatically borrows a free socket from the pool, forwards it to the provided callback function,
-     * and guarantees that the connection is released back to the pool once the execution completes,
-     * even if errors or unexpected exceptions are thrown. Prevents connection descriptor leaks.
-     *
-     * @template T The return type of the provided callback function.
-     * @param {(conn: Connection) => Promise<T>} fn A callback function that operates on the allocated Connection.
-     * @returns {Future<T, PostgresError>} A `Future` that resolves with the return value of the callback.
+     * Runs `fn` with a borrowed connection and releases it afterward, even on error.
      *
      * @example
-     * // Executing low-level engine commands on a single, pinned connection
-     * const status = await pool.withAcquire(async (conn) => {
-     *     return await conn.query`SELECT pg_is_in_recovery()`;
-     * });
+     * const status = await pool.withAcquire(conn => conn.query`SELECT pg_is_in_recovery()`)
      */
     withAcquire<T>(fn: (conn: Connection) => Promise<T>): Future<T, unknown>;
-    /**
-     * Releases the connection back to the pool.
-     *
-     * If there are pending `acquire()` calls, the connection is passed directly to the next waiter.
-     * Otherwise, it's added to the available connections queue.
-     *
-     * @param conn - The connection to release.
-     *
-     * @example
-     * ```ts
-     * const conn = await pool.acquire()
-     * try {
-     *   await conn.query`SELECT 1`
-     * } finally {
-     *   pool.release(conn)
-     * }
-     * ```
-     */
+    /** Returns `conn` to the pool, or hands it directly to the next waiting `acquire()`. */
     release(conn: Connection): void;
     /**
-     * Starts a managed transaction.
-     *
-     * Automatically acquires a connection and handles `BEGIN`, `COMMIT`, and `ROLLBACK`.
-     * If the callback throws an error, the transaction is rolled back.
-     *
-     * @param txCallback - Async function that receives a `Transaction` instance.
-     * @returns The value returned from the callback.
+     * Runs `txCallback` inside a transaction on a borrowed connection, releasing it afterward.
      *
      * @example
-     * ```ts
-     * const result = await pool.begin(async tx => {
-     *   await tx.query`INSERT INTO accounts (id, balance) VALUES (1, 100)`
+     * await pool.begin(async tx => {
      *   await tx.query`UPDATE accounts SET balance = balance - 10 WHERE id = 1`
-     *   return { success: true }
      * })
-     * ```
      */
     begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Future<T, unknown>;
     /**
-     * Executes a one-off query using pipeline.
-     *
-     * Automatically acquires and releases a connection from the pool.
-     * For optimal performance, multiple queries can be pipelined through the same connection.
-     *
-     * @param templates - Tagged template string with SQL.
-     * @param args - Query parameters.
-     * @returns Array of rows with proper typing.
-     *
-     * @example
-     * ```ts
-     * // Simple query
-     * const users = await pool.query`SELECT * FROM users`
-     *
-     * // With parameters
-     * const user = await pool.query`SELECT * FROM users WHERE id = ${1}`
-     *
-     * // With typed result
-     * type User = { id: number, name: string }
-     * const users = await pool.query<User>`SELECT * FROM users`
-     * ```
-     */
-    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Future<T[], PostgresError>;
-    /**
-     * Executes an SQL query in streaming mode.
-     *
-     * Data is streamed directly from the PostgreSQL binary network buffer into the Web Streams API
-     * (`ReadableStream`), bypassing any intermediate array allocation or row accumulation in the JS heap.
-     * This pattern provides a true Zero-Memory Footprint and is ideal for exporting massive tables
-     * or piping database payloads directly into HTTP responses (e.g., via `Bun.serve` or fetch `Response`).
-     *
-     * @template T The expected shape of a single row interface.
-     * @param {TemplateStringsArray} templates The SQL string parts from the tagged template literal.
-     * @param {...any} args The parameterized query arguments.
-     * @returns {ReadableStream<T>} Synchronously returns a native Web ReadableStream instance.
-     *
-     * @example
-     * // Streaming a giant table directly to an HTTP response (Bun.serve)
-     * const userStream = pool.stream<User>`SELECT id, name FROM users`;
-     * return new Response(userStream, { headers: { 'Content-Type': 'application/json' } });
+     * Runs a one-off query on a borrowed connection.
      *
      * @example
-     * // Asynchronously iterating over rows as they arrive from the wire socket
-     * const stream = pool.stream<User>`SELECT * FROM orders WHERE status = ${'processed'}`;
-     * for await (const row of stream) {
-     *     console.log(row.id, row.amount); // Row object is eligible for GC immediately after iteration
-     * }
+     * const users = await pool.query<User>`SELECT * FROM users WHERE id = ${1}`
      */
-    stream<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): ReadableStream<T>;
+    query<T extends Row>(templates: TemplateStringsArray, ...args: any[]): Future<T[], PostgresError>;
+    /** Like {@link query}, but for statements that don't return rows. */
+    execute(templates: TemplateStringsArray, ...params: any[]): Future<void, PostgresError>;
     /**
-     * Sends an asynchronous notification to a channel via `pg_notify`.
-     *
-     * @param channelName - The channel identifier
-     * @param payload - Optional string data (max 8000 bytes)
+     * Streams query results as a `ReadableStream`, without buffering rows in memory.
      *
      * @example
-     * ```ts
-     * await pool.notify('events', 'hello')
-     * ```
+     * for await (const row of pool.stream<User>`SELECT * FROM orders`) { ... }
      */
-    notify(channelName: string, payload?: string): Future<[], PostgresError>;
+    stream<T extends Row>(templates: TemplateStringsArray, ...args: any[]): ReadableStream<T>;
+    /** Sends a `pg_notify` message on `channelName` (payload ≤ 8000 bytes). */
+    notify(channelName: string, payload?: string): Future<void, PostgresError>;
     /**
-     * Asynchronously subscribes to pub/sub events on a specific PostgreSQL channel (LISTEN).
-     *
-     * This method automatically claims a dedicated connection from the pool, registers the callback
-     * to handle incoming asynchronous database notices (`NotificationResponse` packets), and returns
-     * a lazy unsubscribe function wrapped in a `Future`.
-     *
-     * Invoking the returned unsubscribe function will automatically issue the `UNLISTEN` command
-     * to the database backend, clean up the memory callback, and safely release the connection back to the pool.
-     *
-     * @param {string} channel The name of the PostgreSQL notification channel.
-     * @param {(payload: string) => void} callback The event handler invoked when a NOTIFY message arrives.
-     * @returns {Future<() => Promise<void>, PostgresError>} A `Future` resolving to an async unsubscribe function.
+     * Subscribes `callback` to `channel` on a dedicated connection.
+     * Returns an unsubscribe function that issues `UNLISTEN` and releases the connection.
      *
      * @example
-     * // Subscribing to database events directly from the Pool
-     * const unlisten = await pool.listen('order_created', (payload) => {
-     *     const order = JSON.parse(payload);
-     *     console.log(`New order received: ${order.id}`);
-     * });
-     *
-     * // When the subscription is no longer needed (e.g., during teardown or server stop):
-     * await unlisten(); // The socket cleanly issues UNLISTEN and returns to the pool of free connections.
-     */
-    listen(channel: string, callback: (payload: string) => void): Future<() => Promise<void>, PostgresError>;
-    /**
-     * Number of available (idle) connections in the pool.
+     * const unlisten = await pool.listen('order_created', payload => console.log(payload))
+     * await unlisten()
      */
+    listen(channel: string, callback: (payload: string) => void): Future<() => Future<void, PostgresError>, PostgresError>;
+    /** Number of idle connections. */
     get size(): number;
-    /**
-     * Total number of connections currently managed by the pool
-     * (available + in use).
-     */
+    /** Total connections managed (idle + in use). */
     get total(): number;
     /**
-     * Shuts down the pool and closes all active connections.
-     *
-     * All pending `acquire()` calls will be rejected with an error.
-     * The pool cannot be used after calling `close()`.
-     *
-     * @example
-     * ```ts
-     *  pool.close()
-     * ```
+     * Closes idle connections and rejects pending `acquire()` calls. Not usable afterward.
      */
-    close(): void;
+    close(): Future<void, PostgresError>;
 }
-export {};
 //# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,YAAY;gBAIR,MAAM,EAAE,UAAU;IAO9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IA2BP;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAY7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAWR"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAC;AAClD,OAAO,EAAiB,aAAa,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAc,iBAAiB,EAAE,GAAG,EAAU,MAAM,SAAS,CAAC;AAGrE;;;;;;;;GAQG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAO;gBAEZ,MAAM,EAAE,iBAAiB;IAOrC;;;OAGG;IACH,OAAO;IA2BP;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD,wFAAwF;IACxF,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAU7D;;;;;OAKG;IACH,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpE,qEAAqE;IACrE,OAAO,CAAC,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAuBzD;;;;;OAKG;IACH,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzF,2EAA2E;IAC3E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAQhD;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D,kCAAkC;IAClC,IAAI,IAAI,WAEP;IAGD,iDAAiD;IACjD,IAAI,KAAK,WAER;IAGD;;OAEG;IACH,KAAK;CAiBR"}