velocious 1.0.510 → 1.0.511

package/build/database/advisory-lock-runner.js

@@ -0,0 +1,192 @@
+// @ts-check
+
+import timeout from "awaitery/build/timeout.js"
+
+/**
+ * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
+ */
+class AdvisoryLockTimeoutError extends Error {
+  /**
+   * Runs constructor.
+   * @param {string} message - Error message.
+   * @param {{name: string}} args - The advisory lock name that timed out.
+   */
+  constructor(message, {name}) {
+    super(message)
+    this.name = "AdvisoryLockTimeoutError"
+    this.lockName = name
+  }
+}
+
+/**
+ * Thrown when `withAdvisoryLockOrFail` finds the lock already held.
+ */
+class AdvisoryLockBusyError extends Error {
+  /**
+   * Runs constructor.
+   * @param {string} message - Error message.
+   * @param {{name: string}} args - The advisory lock name that was already held.
+   */
+  constructor(message, {name}) {
+    super(message)
+    this.name = "AdvisoryLockBusyError"
+    this.lockName = name
+  }
+}
+
+/**
+ * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.
+ */
+class AdvisoryLockHoldTimeoutError extends Error {
+  /**
+   * Runs constructor.
+   * @param {string} message - Error message.
+   * @param {{name: string}} args - The advisory lock name whose hold timed out.
+   */
+  constructor(message, {name}) {
+    super(message)
+    this.name = "AdvisoryLockHoldTimeoutError"
+    this.lockName = name
+  }
+}
+
+/**
+ * Runs advisory locks on the caller connection by default, using a dedicated
+ * lock connection only when a positive hold timeout needs separate ownership.
+ */
+export default class AdvisoryLockRunner {
+  /**
+   * Creates an advisory-lock runner for one model database identifier.
+   * @param {{configuration: import("../configuration.js").default, connectionProvider: () => import("./drivers/base.js").default, databaseIdentifier: string}} args - Runner dependencies.
+   */
+  constructor({configuration, connectionProvider, databaseIdentifier}) {
+    this.configuration = configuration
+    this.connectionProvider = connectionProvider
+    this.databaseIdentifier = databaseIdentifier
+  }
+
+  /**
+   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+   * @template T
+   * @param {string} name - Lock name.
+   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withAdvisoryLock(name, callback, args = {}) {
+    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+      const acquired = await connection.acquireAdvisoryLock(name, args)
+
+      if (!acquired) {
+        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})
+      }
+
+      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})
+    })
+  }
+
+  /**
+   * Runs a callback only if the advisory lock can be acquired immediately.
+   * @template T
+   * @param {string} name - Lock name.
+   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withAdvisoryLockOrFail(name, callback, args = {}) {
+    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+      const acquired = await connection.tryAcquireAdvisoryLock(name)
+
+      if (!acquired) {
+        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})
+      }
+
+      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})
+    })
+  }
+
+  /**
+   * Runs the lock holder callback and releases the lock from its owning connection.
+   * @template T
+   * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {
+    try {
+      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)
+    } finally {
+      await connection.releaseAdvisoryLock(name)
+    }
+  }
+
+  /**
+   * Runs lock work on the caller connection unless a positive hold timeout needs
+   * its own lock connection.
+   * @template T
+   * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.
+   * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withLockConnection(holdTimeoutMs, callback) {
+    if (holdTimeoutMs && holdTimeoutMs > 0) {
+      return await this.withDedicatedConnection(callback)
+    }
+
+    return await callback(this.connectionProvider())
+  }
+
+  /**
+   * Spawns a hold-timeout lock connection and closes it after lock work completes when
+   * the spawned driver owns the underlying physical connection.
+   * @template T
+   * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withDedicatedConnection(callback) {
+    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()
+
+    try {
+      return await callback(connection)
+    } finally {
+      if (!connection.getArgs().getConnection) {
+        await connection.close()
+      }
+    }
+  }
+
+  /**
+   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
+   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
+   * use a dedicated advisory-lock connection so the lock can still be released.
+   * @template T
+   * @param {string} name - Lock name (for the error message).
+   * @param {() => Promise<T>} callback - Callback holding the lock.
+   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {
+    if (!holdTimeoutMs || holdTimeoutMs <= 0) {
+      return await callback()
+    }
+
+    let callbackSettled = false
+
+    try {
+      return await timeout({timeout: holdTimeoutMs}, async () => {
+        try {
+          return await callback()
+        } finally {
+          callbackSettled = true
+        }
+      })
+    } catch (error) {
+      if (!callbackSettled) {
+        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})
+      }
+
+      throw error
+    }
+  }
+}
+
+export {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}

package/build/database/drivers/mysql/index.js

@@ -31,6 +31,9 @@ import Update from "./sql/update.js"
 const MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS = 60 * 60 * 24 * 365
 
 export default class VelociousDatabaseDriversMysql extends Base{
+  /** @type {import("mysql").Pool | undefined} */
+  pool = undefined
+
   /** @type {string | null} */
   _desiredSessionTimeZone = "+00:00"
 

package/build/database/record/index.js

@@ -24,7 +24,7 @@
 
 /** @typedef {import("../../configuration-types.js").TenantDatabaseProviderType} TenantDatabaseProviderType */
 
-import timeout from "awaitery/build/timeout.js"
+import AdvisoryLockRunner, {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError} from "../advisory-lock-runner.js"
 import BelongsToInstanceRelationship from "./instance-relationships/belongs-to.js"
 import BelongsToRelationship from "./relationships/belongs-to.js"
 import Configuration from "../../configuration.js"
@@ -164,60 +164,6 @@ function buildRelatedRecordWithInverse(parent, relationshipName, attributes, all
   return record
 }
 
-/**
- * Thrown by `Record.withAdvisoryLock` when the caller supplied a
- * `timeoutMs` and the lock was not granted before it elapsed.
- */
-class AdvisoryLockTimeoutError extends Error {
-  /**
-   * Runs constructor.
-   * @param {string} message - Error message.
-   * @param {{name: string}} args - The advisory lock name that timed out.
-   */
-  constructor(message, {name}) {
-    super(message)
-    this.name = "AdvisoryLockTimeoutError"
-    this.lockName = name
-  }
-}
-
-/**
- * Thrown by `Record.withAdvisoryLockOrFail` when the lock is already held
- * by another session at the moment of the call.
- */
-class AdvisoryLockBusyError extends Error {
-  /**
-   * Runs constructor.
-   * @param {string} message - Error message.
-   * @param {{name: string}} args - The advisory lock name that was already held.
-   */
-  constructor(message, {name}) {
-    super(message)
-    this.name = "AdvisoryLockBusyError"
-    this.lockName = name
-  }
-}
-
-/**
- * Thrown by `Record.withAdvisoryLock` / `withAdvisoryLockOrFail` when the
- * caller supplied a `holdTimeoutMs` and the callback ran longer than it. The
- * lock is released before this is thrown, so a hung holder can't block other
- * sessions indefinitely. Note: the callback itself is not cancelled — pass an
- * AbortSignal to the work if it needs to stop.
- */
-class AdvisoryLockHoldTimeoutError extends Error {
-  /**
-   * Runs constructor.
-   * @param {string} message - Error message.
-   * @param {{name: string}} args - The advisory lock name whose hold timed out.
-   */
-  constructor(message, {name}) {
-    super(message)
-    this.name = "AdvisoryLockHoldTimeoutError"
-    this.lockName = name
-  }
-}
-
 class TenantDatabaseScopeError extends Error {
   /**
    * Runs constructor.
@@ -2675,10 +2621,13 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * Runs the callback while holding a named advisory lock on the current
-   * connection. Advisory locks are cooperative and connection-scoped: they
-   * serialize callers that opt into the same `name`, without touching row
-   * or table locks, so unrelated traffic is free to proceed.
+   * Runs the callback while holding a named advisory lock. Calls without
+   * a positive `holdTimeoutMs` use the caller connection; calls with a positive
+   * `holdTimeoutMs` use a dedicated lock connection so timeout cleanup can
+   * release the lock even when callback database work is stuck. Advisory locks
+   * are cooperative and session-scoped: they serialize callers that opt into
+   * the same `name`, without touching row or table locks, so unrelated traffic
+   * is free to proceed.
    *
    * The lock is acquired before the callback runs and released in a
    * `finally` block afterwards, so the callback's return value is
@@ -2694,18 +2643,13 @@ class VelociousDatabaseRecord {
   static async withAdvisoryLock(name, callback, args = {}) {
     await this.ensureInitialized()
 
-    const connection = this.connection()
-    const acquired = await connection.acquireAdvisoryLock(name, args)
-
-    if (!acquired) {
-      throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})
-    }
+    const runner = new AdvisoryLockRunner({
+      configuration: this._getConfiguration(),
+      connectionProvider: () => this.connection(),
+      databaseIdentifier: this.getDatabaseIdentifier()
+    })
 
-    try {
-      return await this.runWithAdvisoryLockHoldTimeout(name, callback, args.holdTimeoutMs)
-    } finally {
-      await connection.releaseAdvisoryLock(name)
-    }
+    return await runner.withAdvisoryLock(name, callback, args)
   }
 
   /**
@@ -2725,31 +2669,19 @@ class VelociousDatabaseRecord {
   static async withAdvisoryLockOrFail(name, callback, args = {}) {
     await this.ensureInitialized()
 
-    const connection = this.connection()
-    const acquired = await connection.tryAcquireAdvisoryLock(name)
-
-    if (!acquired) {
-      throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})
-    }
+    const runner = new AdvisoryLockRunner({
+      configuration: this._getConfiguration(),
+      connectionProvider: () => this.connection(),
+      databaseIdentifier: this.getDatabaseIdentifier()
+    })
 
-    try {
-      return await this.runWithAdvisoryLockHoldTimeout(name, callback, args.holdTimeoutMs)
-    } finally {
-      await connection.releaseAdvisoryLock(name)
-    }
+    return await runner.withAdvisoryLockOrFail(name, callback, args)
   }
 
   /**
    * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
-   * not settled within `holdTimeoutMs`. The caller's `finally` then releases
-   * the lock, so a hung holder can't block other sessions forever. The
-   * callback is not cancelled — this is a safety net, not cancellation.
-   *
-   * Uses `awaitery`'s shared `timeout` helper for the hard timeout, then
-   * translates its timeout into the typed `AdvisoryLockHoldTimeoutError` so
-   * callers can catch it like the other advisory-lock errors. A `callbackSettled`
-   * flag distinguishes the timeout from a rejection thrown by the callback
-   * itself, which is rethrown unchanged.
+   * not settled within `holdTimeoutMs`. The callback is not cancelled — this is
+   * a safety net, not cancellation.
    * @template T
    * @param {string} name - Lock name (for the error message).
    * @param {() => Promise<T>} callback - Callback holding the lock.
@@ -2757,27 +2689,7 @@ class VelociousDatabaseRecord {
    * @returns {Promise<T>}
    */
   static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {
-    if (!holdTimeoutMs || holdTimeoutMs <= 0) {
-      return await callback()
-    }
-
-    let callbackSettled = false
-
-    try {
-      return await timeout({timeout: holdTimeoutMs}, async () => {
-        try {
-          return await callback()
-        } finally {
-          callbackSettled = true
-        }
-      })
-    } catch (error) {
-      if (!callbackSettled) {
-        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})
-      }
-
-      throw error
-    }
+    return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)
   }
 
   /**

package/build/src/configuration-types.d.ts

@@ -775,7 +775,7 @@ export type DatabaseConfigurationType = {
     /**
      * - Database type identifier.
      */
-    type?: "sqlite" | "pgsql" | "mysql" | "mssql" | undefined;
+    type?: "sqlite" | "mysql" | "pgsql" | "mssql" | undefined;
     /**
      * - Database to switch to after connecting.
      */

package/build/src/configuration.d.ts

@@ -383,7 +383,7 @@ export default class VelociousConfiguration {
      * @returns {typeof import("./database/pool/base.js").default} - The database pool type.
      */
     getDatabasePoolType(identifier?: string): typeof import("./database/pool/base.js").default;
-    getDatabaseType(identifier?: string): "sqlite" | "pgsql" | "mysql" | "mssql";
+    getDatabaseType(identifier?: string): "sqlite" | "mysql" | "pgsql" | "mssql";
     /**
      * Runs get directory.
      * @returns {string} - The directory.

package/build/src/database/advisory-lock-runner.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Runs advisory locks on the caller connection by default, using a dedicated
+ * lock connection only when a positive hold timeout needs separate ownership.
+ */
+export default class AdvisoryLockRunner {
+    /**
+     * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
+     * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
+     * use a dedicated advisory-lock connection so the lock can still be released.
+     * @template T
+     * @param {string} name - Lock name (for the error message).
+     * @param {() => Promise<T>} callback - Callback holding the lock.
+     * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    static runWithAdvisoryLockHoldTimeout<T>(name: string, callback: () => Promise<T>, holdTimeoutMs?: number | null): Promise<T>;
+    /**
+     * Creates an advisory-lock runner for one model database identifier.
+     * @param {{configuration: import("../configuration.js").default, connectionProvider: () => import("./drivers/base.js").default, databaseIdentifier: string}} args - Runner dependencies.
+     */
+    constructor({ configuration, connectionProvider, databaseIdentifier }: {
+        configuration: import("../configuration.js").default;
+        connectionProvider: () => import("./drivers/base.js").default;
+        databaseIdentifier: string;
+    });
+    configuration: import("../configuration.js").default;
+    connectionProvider: () => import("./drivers/base.js").default;
+    databaseIdentifier: string;
+    /**
+     * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withAdvisoryLock<T>(name: string, callback: () => Promise<T>, args?: {
+        timeoutMs?: number | null;
+        holdTimeoutMs?: number | null;
+    }): Promise<T>;
+    /**
+     * Runs a callback only if the advisory lock can be acquired immediately.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withAdvisoryLockOrFail<T>(name: string, callback: () => Promise<T>, args?: {
+        holdTimeoutMs?: number | null;
+    }): Promise<T>;
+    /**
+     * Runs the lock holder callback and releases the lock from its owning connection.
+     * @template T
+     * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    runLockedCallback<T>({ callback, connection, holdTimeoutMs, name }: {
+        callback: () => Promise<T>;
+        connection: import("./drivers/base.js").default;
+        holdTimeoutMs?: number | null;
+        name: string;
+    }): Promise<T>;
+    /**
+     * Runs lock work on the caller connection unless a positive hold timeout needs
+     * its own lock connection.
+     * @template T
+     * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withLockConnection<T>(holdTimeoutMs: number | null | undefined, callback: (connection: import("./drivers/base.js").default) => Promise<T>): Promise<T>;
+    /**
+     * Spawns a hold-timeout lock connection and closes it after lock work completes when
+     * the spawned driver owns the underlying physical connection.
+     * @template T
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withDedicatedConnection<T>(callback: (connection: import("./drivers/base.js").default) => Promise<T>): Promise<T>;
+}
+/**
+ * Thrown when `withAdvisoryLockOrFail` finds the lock already held.
+ */
+export class AdvisoryLockBusyError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that was already held.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+/**
+ * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.
+ */
+export class AdvisoryLockHoldTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name whose hold timed out.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+/**
+ * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
+ */
+export class AdvisoryLockTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that timed out.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+//# sourceMappingURL=advisory-lock-runner.d.ts.map

package/build/src/database/advisory-lock-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"AAoDA;;;GAGG;AACH;IAoGE;;;;;;;;;OASG;IACH,sCANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,kBAChB,MAAM,GAAG,IAAI,GACX,OAAO,CAAC,CAAC,CAAC,CAwBtB;IAnID;;;OAGG;IACH,uEAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAC,EAM3J;IAHC,qDAAkC;IAClC,0BAJ0F,OAAO,mBAAmB,EAAE,OAAO,CAIjF;IAC5C,2BAA4C;IAG9C;;;;;;;OAOG;IACH,iBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GACxD,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;;;OAOG;IACH,uBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;OAKG;IACH,kBAJa,CAAC,iDACH;QAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACxH,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;;OAOG;IACH,mBALa,CAAC,iBACH,MAAM,GAAG,IAAI,GAAG,SAAS,YACzB,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;OAMG;IACH,wBAJa,CAAC,YACH,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAYtB;CAmCF;AAzKD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AAED;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AA9CD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB"}