@aztec/foundation 0.7.2 → 0.7.3

package/dest/sleep/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * InterruptableSleep is a utility class that allows you to create an interruptible sleep function.
+ * The sleep function can be interrupted at any time by calling the `interrupt` method, which can
+ * also specify whether the sleep should throw an error or just return. This is useful when you need
+ * to terminate long-running processes or perform cleanup tasks in response to external events.
+ *
+ * @example
+ * const sleeper = new InterruptableSleep();
+ *
+ * async function longRunningTask() \{
+ *   try \{
+ *     await sleeper.sleep(3000);
+ *     console.log('Task completed after 3 seconds');
+ *   \} catch (e) \{
+ *     console.log('Task was interrupted');
+ *   \}
+ * \}
+ *
+ * setTimeout(() =\> sleeper.interrupt(true), 1500); // Interrupt the sleep after 1.5 seconds
+ */
+export declare class InterruptableSleep {
+    private interruptResolve;
+    private interruptPromise;
+    private timeouts;
+    /**
+     * Sleep for a specified amount of time in milliseconds.
+     * The sleep function will pause the execution of the current async function
+     * for the given time period, allowing other tasks to run before resuming.
+     *
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A Promise that resolves after the specified time has passed.
+     */
+    sleep(ms: number): Promise<void>;
+    /**
+     * Interrupts the current sleep operation and optionally throws an error if specified.
+     * By default, when interrupted, the sleep operation will resolve without throwing.
+     * If 'sleepShouldThrow' is set to true, the sleep operation will throw an InterruptError instead.
+     *
+     * @param sleepShouldThrow - A boolean value indicating whether the sleep operation should throw an error when interrupted. Default is false.
+     */
+    interrupt(sleepShouldThrow?: boolean): void;
+}
+/**
+ * Puts the current execution context to sleep for a specified duration.
+ * This simulates a blocking sleep operation by using an asynchronous function and a Promise that resolves after the given duration.
+ * The sleep function can be interrupted by the 'interrupt' method of the InterruptableSleep class.
+ *
+ * @param ms - The duration in milliseconds for which the sleep operation should last.
+ * @returns A Promise that resolves after the specified duration, allowing the use of 'await' to pause execution.
+ */
+export declare function sleep(ms: number): Promise<unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dest/sleep/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sleep/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAAsE;IAC9F,OAAO,CAAC,QAAQ,CAAwB;IAExC;;;;;;;OAOG;IACU,KAAK,CAAC,EAAE,EAAE,MAAM;IAY7B;;;;;;OAMG;IACI,SAAS,CAAC,gBAAgB,UAAQ;CAI1C;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B"}

package/dest/sleep/index.js

@@ -0,0 +1,70 @@
+import { InterruptError } from '../errors/index.js';
+/**
+ * InterruptableSleep is a utility class that allows you to create an interruptible sleep function.
+ * The sleep function can be interrupted at any time by calling the `interrupt` method, which can
+ * also specify whether the sleep should throw an error or just return. This is useful when you need
+ * to terminate long-running processes or perform cleanup tasks in response to external events.
+ *
+ * @example
+ * const sleeper = new InterruptableSleep();
+ *
+ * async function longRunningTask() \{
+ *   try \{
+ *     await sleeper.sleep(3000);
+ *     console.log('Task completed after 3 seconds');
+ *   \} catch (e) \{
+ *     console.log('Task was interrupted');
+ *   \}
+ * \}
+ *
+ * setTimeout(() =\> sleeper.interrupt(true), 1500); // Interrupt the sleep after 1.5 seconds
+ */
+export class InterruptableSleep {
+    constructor() {
+        this.interruptResolve = () => { };
+        this.interruptPromise = new Promise(resolve => (this.interruptResolve = resolve));
+        this.timeouts = [];
+    }
+    /**
+     * Sleep for a specified amount of time in milliseconds.
+     * The sleep function will pause the execution of the current async function
+     * for the given time period, allowing other tasks to run before resuming.
+     *
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A Promise that resolves after the specified time has passed.
+     */
+    async sleep(ms) {
+        let timeout;
+        const promise = new Promise(resolve => (timeout = setTimeout(() => resolve(false), ms)));
+        this.timeouts.push(timeout);
+        const shouldThrow = await Promise.race([promise, this.interruptPromise]);
+        clearTimeout(timeout);
+        this.timeouts.splice(this.timeouts.indexOf(timeout), 1);
+        if (shouldThrow) {
+            throw new InterruptError('Interrupted.');
+        }
+    }
+    /**
+     * Interrupts the current sleep operation and optionally throws an error if specified.
+     * By default, when interrupted, the sleep operation will resolve without throwing.
+     * If 'sleepShouldThrow' is set to true, the sleep operation will throw an InterruptError instead.
+     *
+     * @param sleepShouldThrow - A boolean value indicating whether the sleep operation should throw an error when interrupted. Default is false.
+     */
+    interrupt(sleepShouldThrow = false) {
+        this.interruptResolve(sleepShouldThrow);
+        this.interruptPromise = new Promise(resolve => (this.interruptResolve = resolve));
+    }
+}
+/**
+ * Puts the current execution context to sleep for a specified duration.
+ * This simulates a blocking sleep operation by using an asynchronous function and a Promise that resolves after the given duration.
+ * The sleep function can be interrupted by the 'interrupt' method of the InterruptableSleep class.
+ *
+ * @param ms - The duration in milliseconds for which the sleep operation should last.
+ * @returns A Promise that resolves after the specified duration, allowing the use of 'await' to pause execution.
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2xlZXAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHO0FBQ0gsTUFBTSxPQUFPLGtCQUFrQjtJQUEvQjtRQUNVLHFCQUFnQixHQUFtQyxHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUM7UUFDNUQscUJBQWdCLEdBQUcsSUFBSSxPQUFPLENBQVUsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDO1FBQ3RGLGFBQVEsR0FBcUIsRUFBRSxDQUFDO0lBaUMxQyxDQUFDO0lBL0JDOzs7Ozs7O09BT0c7SUFDSSxLQUFLLENBQUMsS0FBSyxDQUFDLEVBQVU7UUFDM0IsSUFBSSxPQUF3QixDQUFDO1FBQzdCLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFVLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDbEcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDNUIsTUFBTSxXQUFXLEdBQUcsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7UUFDekUsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3hELElBQUksV0FBVyxFQUFFO1lBQ2YsTUFBTSxJQUFJLGNBQWMsQ0FBQyxjQUFjLENBQUMsQ0FBQztTQUMxQztJQUNILENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxTQUFTLENBQUMsZ0JBQWdCLEdBQUcsS0FBSztRQUN2QyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ3BGLENBQUM7Q0FDRjtBQUVEOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsS0FBSyxDQUFDLEVBQVU7SUFDOUIsT0FBTyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUN6RCxDQUFDIn0=

package/dest/timer/index.d.ts

@@ -0,0 +1,3 @@
+export { TimeoutTask } from './timeout.js';
+export { Timer } from './timer.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/timer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/timer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dest/timer/index.js

@@ -0,0 +1,3 @@
+export { TimeoutTask } from './timeout.js';
+export { Timer } from './timer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGltZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMzQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sWUFBWSxDQUFDIn0=

package/dest/timer/timeout.d.ts

@@ -0,0 +1,41 @@
+/**
+ * TimeoutTask class creates an instance for managing and executing a given asynchronous function with a specified timeout duration.
+ * The task will be automatically interrupted if it exceeds the given timeout duration, and will throw a custom error message.
+ * Additional information such as execution time can be retrieved using getTime method after the task has been executed.
+ *
+ * @typeparam T - The return type of the asynchronous function to be executed.
+ */
+export declare class TimeoutTask<T> {
+    private fn;
+    private timeout;
+    private interruptPromise;
+    private interrupt;
+    private totalTime;
+    constructor(fn: () => Promise<T>, timeout?: number, fnName?: string);
+    /**
+     * Executes the given function with a specified timeout.
+     * If the function takes longer than the timeout, it will be interrupted and an error will be thrown.
+     * The total execution time of the function will be stored in the totalTime property.
+     *
+     * @returns The result of the executed function if completed within the timeout.
+     * @throws An error with a message indicating the function was interrupted due to exceeding the specified timeout.
+     */
+    exec(): Promise<T>;
+    /**
+     * Returns the interrupt promise associated with the TimeoutTask instance.
+     * The interrupt promise is used internally to reject the task when a timeout occurs.
+     * This method can be helpful when debugging or tracking the state of the task.
+     *
+     * @returns The interrupt promise associated with the task.
+     */
+    getInterruptPromise(): Promise<any>;
+    /**
+     * Get the total time spent on the most recent execution of the wrapped function.
+     * This method provides the duration from the start to the end of the function execution, whether it completed or timed out.
+     *
+     * @returns The total time in milliseconds spent on the most recent function execution.
+     */
+    getTime(): number;
+}
+export declare const executeTimeout: <T>(fn: () => Promise<T>, timeout?: number, fnName?: string) => Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dest/timer/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/timer/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,WAAW,CAAC,CAAC;IAKZ,OAAO,CAAC,EAAE;IAAoB,OAAO,CAAC,OAAO;IAJzD,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,SAAS,CAAK;gBAEF,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAU,OAAO,SAAI,EAAE,MAAM,SAAK;IAM1E;;;;;;;OAOG;IACU,IAAI;IAYjB;;;;;;OAMG;IACI,mBAAmB;IAI1B;;;;;OAKG;IACI,OAAO;CAGf;AAED,eAAO,MAAM,cAAc,4EAG1B,CAAC"}

package/dest/timer/timeout.js

@@ -0,0 +1,62 @@
+/**
+ * TimeoutTask class creates an instance for managing and executing a given asynchronous function with a specified timeout duration.
+ * The task will be automatically interrupted if it exceeds the given timeout duration, and will throw a custom error message.
+ * Additional information such as execution time can be retrieved using getTime method after the task has been executed.
+ *
+ * @typeparam T - The return type of the asynchronous function to be executed.
+ */
+export class TimeoutTask {
+    constructor(fn, timeout = 0, fnName = '') {
+        this.fn = fn;
+        this.timeout = timeout;
+        this.interrupt = () => { };
+        this.totalTime = 0;
+        this.interruptPromise = new Promise((_, reject) => {
+            this.interrupt = () => reject(new Error(`Timeout${fnName ? ` running ${fnName}` : ''} after ${timeout}ms.`));
+        });
+    }
+    /**
+     * Executes the given function with a specified timeout.
+     * If the function takes longer than the timeout, it will be interrupted and an error will be thrown.
+     * The total execution time of the function will be stored in the totalTime property.
+     *
+     * @returns The result of the executed function if completed within the timeout.
+     * @throws An error with a message indicating the function was interrupted due to exceeding the specified timeout.
+     */
+    async exec() {
+        const interruptTimeout = !this.timeout ? 0 : setTimeout(this.interrupt, this.timeout);
+        try {
+            const start = Date.now();
+            const result = await Promise.race([this.fn(), this.interruptPromise]);
+            this.totalTime = Date.now() - start;
+            return result;
+        }
+        finally {
+            clearTimeout(interruptTimeout);
+        }
+    }
+    /**
+     * Returns the interrupt promise associated with the TimeoutTask instance.
+     * The interrupt promise is used internally to reject the task when a timeout occurs.
+     * This method can be helpful when debugging or tracking the state of the task.
+     *
+     * @returns The interrupt promise associated with the task.
+     */
+    getInterruptPromise() {
+        return this.interruptPromise;
+    }
+    /**
+     * Get the total time spent on the most recent execution of the wrapped function.
+     * This method provides the duration from the start to the end of the function execution, whether it completed or timed out.
+     *
+     * @returns The total time in milliseconds spent on the most recent function execution.
+     */
+    getTime() {
+        return this.totalTime;
+    }
+}
+export const executeTimeout = async (fn, timeout = 0, fnName = '') => {
+    const task = new TimeoutTask(fn, timeout, fnName);
+    return await task.exec();
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZW91dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90aW1lci90aW1lb3V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUNILE1BQU0sT0FBTyxXQUFXO0lBS3RCLFlBQW9CLEVBQW9CLEVBQVUsVUFBVSxDQUFDLEVBQUUsTUFBTSxHQUFHLEVBQUU7UUFBdEQsT0FBRSxHQUFGLEVBQUUsQ0FBa0I7UUFBVSxZQUFPLEdBQVAsT0FBTyxDQUFJO1FBSHJELGNBQVMsR0FBRyxHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUM7UUFDckIsY0FBUyxHQUFHLENBQUMsQ0FBQztRQUdwQixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsSUFBSSxPQUFPLENBQUksQ0FBQyxDQUFDLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDbkQsSUFBSSxDQUFDLFNBQVMsR0FBRyxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsVUFBVSxNQUFNLENBQUMsQ0FBQyxDQUFDLFlBQVksTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsVUFBVSxPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDL0csQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RGLElBQUk7WUFDRixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDekIsTUFBTSxNQUFNLEdBQUcsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7WUFDekUsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsS0FBSyxDQUFDO1lBQ3BDLE9BQU8sTUFBTSxDQUFDO1NBQ2Y7Z0JBQVM7WUFDUixZQUFZLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztTQUNoQztJQUNILENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxtQkFBbUI7UUFDeEIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUM7SUFDL0IsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUN4QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsS0FBSyxFQUFLLEVBQW9CLEVBQUUsT0FBTyxHQUFHLENBQUMsRUFBRSxNQUFNLEdBQUcsRUFBRSxFQUFFLEVBQUU7SUFDeEYsTUFBTSxJQUFJLEdBQUcsSUFBSSxXQUFXLENBQUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNsRCxPQUFPLE1BQU0sSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0FBQzNCLENBQUMsQ0FBQyJ9

package/dest/timer/timer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export declare class Timer {
+    private start;
+    constructor();
+    /**
+     * Returns the elapsed time in milliseconds since the Timer instance was created.
+     * Provides a simple and convenient way to measure the time duration between two events
+     * or monitor performance of specific code sections.
+     *
+     * @returns The elapsed time in milliseconds.
+     */
+    ms(): number;
+    /**
+     * Returns the time elapsed since the Timer instance was created, in seconds.
+     * The value is calculated by subtracting the initial start time from the current time
+     * and dividing the result by 1000 to convert milliseconds to seconds.
+     *
+     * @returns The elapsed time in seconds.
+     */
+    s(): number;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dest/timer/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/timer/timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAS;;IAMtB;;;;;;OAMG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,CAAC;CAGT"}

package/dest/timer/timer.js

@@ -0,0 +1,38 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export class Timer {
+    constructor() {
+        this.start = new Date().getTime();
+    }
+    /**
+     * Returns the elapsed time in milliseconds since the Timer instance was created.
+     * Provides a simple and convenient way to measure the time duration between two events
+     * or monitor performance of specific code sections.
+     *
+     * @returns The elapsed time in milliseconds.
+     */
+    ms() {
+        return new Date().getTime() - this.start;
+    }
+    /**
+     * Returns the time elapsed since the Timer instance was created, in seconds.
+     * The value is calculated by subtracting the initial start time from the current time
+     * and dividing the result by 1000 to convert milliseconds to seconds.
+     *
+     * @returns The elapsed time in seconds.
+     */
+    s() {
+        return (new Date().getTime() - this.start) / 1000;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGltZXIvdGltZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLE9BQU8sS0FBSztJQUdoQjtRQUNFLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksRUFBRTtRQUNQLE9BQU8sSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQzNDLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxDQUFDO1FBQ04sT0FBTyxDQUFDLElBQUksSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLElBQUksQ0FBQztJQUNwRCxDQUFDO0NBQ0YifQ==

package/dest/transport/browser/index.d.ts

@@ -0,0 +1,5 @@
+export * from './worker_connector.js';
+export * from './worker_listener.js';
+export * from './shared_worker_connector.js';
+export * from './shared_worker_listener.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/transport/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/dest/transport/browser/index.js

@@ -0,0 +1,5 @@
+export * from './worker_connector.js';
+export * from './worker_listener.js';
+export * from './shared_worker_connector.js';
+export * from './shared_worker_listener.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2Jyb3dzZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw2QkFBNkIsQ0FBQyJ9

package/dest/transport/browser/message_port_socket.d.ts

@@ -0,0 +1,37 @@
+import { Socket } from '../interface/socket.js';
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export declare class MessagePortSocket implements Socket {
+    private port;
+    constructor(port: MessagePort);
+    /**
+     * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
+     * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
+     * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
+     * making them inaccessible on the sending side. This can improve performance for large data transfers.
+     *
+     * @param msg - The message to be sent through the MessagePort.
+     * @param transfer - An optional array of Transferable objects to transfer ownership.
+     * @returns A Promise that resolves when the message has been sent.
+     */
+    send(msg: any, transfer?: Transferable[]): Promise<void>;
+    /**
+     * Register a callback function to handle incoming messages from the MessagePort.
+     * The provided callback will be invoked with the message data whenever a new message arrives.
+     * Note that only one callback can be registered at a time. Subsequent calls to this method
+     * will overwrite the previously registered callback.
+     *
+     * @param cb - The callback function to handle incoming messages.
+     */
+    registerHandler(cb: (msg: any) => any): void;
+    /**
+     * Close the MessagePort, unregister the message handler, and send an undefined message.
+     * The 'close' function is useful for gracefully shutting down a connection between two
+     * endpoints by sending an undefined message as an indication of disconnection before
+     * closing the port. After calling this method, the MessagePortSocket instance should not
+     * be used again.
+     */
+    close(): void;
+}
+//# sourceMappingURL=message_port_socket.d.ts.map

package/dest/transport/browser/message_port_socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_port_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/message_port_socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;GAEG;AACH,qBAAa,iBAAkB,YAAW,MAAM;IAClC,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAErC;;;;;;;;;OASG;IACH,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAI5C;;;;;;OAMG;IACH,KAAK;CAKN"}

package/dest/transport/browser/message_port_socket.js

@@ -0,0 +1,46 @@
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export class MessagePortSocket {
+    constructor(port) {
+        this.port = port;
+    }
+    /**
+     * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
+     * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
+     * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
+     * making them inaccessible on the sending side. This can improve performance for large data transfers.
+     *
+     * @param msg - The message to be sent through the MessagePort.
+     * @param transfer - An optional array of Transferable objects to transfer ownership.
+     * @returns A Promise that resolves when the message has been sent.
+     */
+    send(msg, transfer = []) {
+        this.port.postMessage(msg, transfer);
+        return Promise.resolve();
+    }
+    /**
+     * Register a callback function to handle incoming messages from the MessagePort.
+     * The provided callback will be invoked with the message data whenever a new message arrives.
+     * Note that only one callback can be registered at a time. Subsequent calls to this method
+     * will overwrite the previously registered callback.
+     *
+     * @param cb - The callback function to handle incoming messages.
+     */
+    registerHandler(cb) {
+        this.port.onmessage = event => cb(event.data);
+    }
+    /**
+     * Close the MessagePort, unregister the message handler, and send an undefined message.
+     * The 'close' function is useful for gracefully shutting down a connection between two
+     * endpoints by sending an undefined message as an indication of disconnection before
+     * closing the port. After calling this method, the MessagePortSocket instance should not
+     * be used again.
+     */
+    close() {
+        void this.send(undefined);
+        this.port.onmessage = null;
+        this.port.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV9wb3J0X3NvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvYnJvd3Nlci9tZXNzYWdlX3BvcnRfc29ja2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixZQUFvQixJQUFpQjtRQUFqQixTQUFJLEdBQUosSUFBSSxDQUFhO0lBQUcsQ0FBQztJQUV6Qzs7Ozs7Ozs7O09BU0c7SUFDSCxJQUFJLENBQUMsR0FBUSxFQUFFLFdBQTJCLEVBQUU7UUFDMUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3JDLE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsZUFBZSxDQUFDLEVBQXFCO1FBQ25DLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxHQUFHLEtBQUssQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsS0FBSztRQUNILEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUMxQixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDM0IsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNwQixDQUFDO0NBQ0YifQ==

package/dest/transport/browser/shared_worker_connector.d.ts

@@ -0,0 +1,19 @@
+import { Connector } from '../interface/connector.js';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
+ * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
+ * multiple scripts to communicate with the worker using the same connection.
+ */
+export declare class SharedWorkerConnector implements Connector {
+    private worker;
+    constructor(worker: SharedWorker);
+    /**
+     * Creates a new MessagePortSocket instance using the SharedWorker's port.
+     * This method allows for easy creation of sockets to communicate with the SharedWorker.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket(): Promise<MessagePortSocket>;
+}
+//# sourceMappingURL=shared_worker_connector.d.ts.map

package/dest/transport/browser/shared_worker_connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,SAAS;IACzC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAExC;;;;;OAKG;IACH,YAAY;CAGb"}

package/dest/transport/browser/shared_worker_connector.js

@@ -0,0 +1,21 @@
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
+ * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
+ * multiple scripts to communicate with the worker using the same connection.
+ */
+export class SharedWorkerConnector {
+    constructor(worker) {
+        this.worker = worker;
+    }
+    /**
+     * Creates a new MessagePortSocket instance using the SharedWorker's port.
+     * This method allows for easy creation of sockets to communicate with the SharedWorker.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket() {
+        return Promise.resolve(new MessagePortSocket(this.worker.port));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkX3dvcmtlcl9jb25uZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2Jyb3dzZXIvc2hhcmVkX3dvcmtlcl9jb25uZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFN0Q7Ozs7R0FJRztBQUNILE1BQU0sT0FBTyxxQkFBcUI7SUFDaEMsWUFBb0IsTUFBb0I7UUFBcEIsV0FBTSxHQUFOLE1BQU0sQ0FBYztJQUFHLENBQUM7SUFFNUM7Ozs7O09BS0c7SUFDSCxZQUFZO1FBQ1YsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksaUJBQWlCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7Q0FDRiJ9

package/dest/transport/browser/shared_worker_listener.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { Listener } from '../interface/listener.js';
+/**
+ * Represents the global scope of a Shared Worker.
+ * Provides functionality to handle incoming connections and manage communication with other scripts
+ * running in a shared context, enabling concurrent access and efficient resource sharing among those scripts.
+ */
+declare interface SharedWorkerGlobalScope {
+    /**
+     * Event handler for new connections to the Shared Worker.
+     */
+    onconnect: (...args: any) => any;
+}
+/**
+ * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
+ * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
+ * created in response to these incoming connections. This class is meant to be used in the context of managing
+ * MessagePort connections within the SharedWorkerGlobalScope.
+ */
+export declare class SharedWorkerListener extends EventEmitter implements Listener {
+    private worker;
+    constructor(worker: SharedWorkerGlobalScope);
+    /**
+     * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
+     * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
+     * whenever a new connection is established with the shared worker.
+     */
+    open(): void;
+    /**
+     * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
+     * This stops the listener from emitting new sockets on incoming connections.
+     */
+    close(): void;
+    private handleMessageEvent;
+}
+export {};
+//# sourceMappingURL=shared_worker_listener.d.ts.map

package/dest/transport/browser/shared_worker_listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD;;;;GAIG;AACH,OAAO,WAAW,uBAAuB;IACvC;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;CAClC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,YAAa,YAAW,QAAQ;IAC5D,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,uBAAuB;IAInD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/shared_worker_listener.js

@@ -0,0 +1,37 @@
+import EventEmitter from 'events';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
+ * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
+ * created in response to these incoming connections. This class is meant to be used in the context of managing
+ * MessagePort connections within the SharedWorkerGlobalScope.
+ */
+export class SharedWorkerListener extends EventEmitter {
+    constructor(worker) {
+        super();
+        this.worker = worker;
+        this.handleMessageEvent = (event) => {
+            const [port] = event.ports;
+            if (!port) {
+                return;
+            }
+            this.emit('new_socket', new MessagePortSocket(port));
+        };
+    }
+    /**
+     * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
+     * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
+     * whenever a new connection is established with the shared worker.
+     */
+    open() {
+        this.worker.onconnect = this.handleMessageEvent;
+    }
+    /**
+     * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
+     * This stops the listener from emitting new sockets on incoming connections.
+     */
+    close() {
+        this.worker.onconnect = () => { };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkX3dvcmtlcl9saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvYnJvd3Nlci9zaGFyZWRfd29ya2VyX2xpc3RlbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLFFBQVEsQ0FBQztBQUdsQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQWM3RDs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxZQUFZO0lBQ3BELFlBQW9CLE1BQStCO1FBQ2pELEtBQUssRUFBRSxDQUFDO1FBRFUsV0FBTSxHQUFOLE1BQU0sQ0FBeUI7UUFxQjNDLHVCQUFrQixHQUFHLENBQUMsS0FBbUIsRUFBRSxFQUFFO1lBQ25ELE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDO1lBQzNCLElBQUksQ0FBQyxJQUFJLEVBQUU7Z0JBQ1QsT0FBTzthQUNSO1lBQ0QsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsSUFBSSxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ3ZELENBQUMsQ0FBQztJQXpCRixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILElBQUk7UUFDRixJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUM7SUFDbEQsQ0FBQztJQUVEOzs7T0FHRztJQUNILEtBQUs7UUFDSCxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUM7SUFDbkMsQ0FBQztDQVNGIn0=

package/dest/transport/browser/worker_connector.d.ts

@@ -0,0 +1,26 @@
+import { Connector } from '../interface/connector.js';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * WorkerConnector is a class implementing the Connector interface for creating communication sockets
+ * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
+ * using MessageChannels, enabling seamless communication between the main thread and worker threads.
+ *
+ * @example
+ * const worker = new Worker('./myWorker.js');
+ * const connector = new WorkerConnector(worker);
+ * const socket = await connector.createSocket();
+ * socket.send('Hello, worker!');
+ */
+export declare class WorkerConnector implements Connector {
+    private worker;
+    constructor(worker: Worker);
+    /**
+     * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
+     * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
+     * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket(): Promise<MessagePortSocket>;
+}
+//# sourceMappingURL=worker_connector.d.ts.map

package/dest/transport/browser/worker_connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,YAAW,SAAS;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;OAMG;IACH,YAAY;CAKb"}

package/dest/transport/browser/worker_connector.js

@@ -0,0 +1,30 @@
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * WorkerConnector is a class implementing the Connector interface for creating communication sockets
+ * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
+ * using MessageChannels, enabling seamless communication between the main thread and worker threads.
+ *
+ * @example
+ * const worker = new Worker('./myWorker.js');
+ * const connector = new WorkerConnector(worker);
+ * const socket = await connector.createSocket();
+ * socket.send('Hello, worker!');
+ */
+export class WorkerConnector {
+    constructor(worker) {
+        this.worker = worker;
+    }
+    /**
+     * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
+     * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
+     * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket() {
+        const channel = new MessageChannel();
+        this.worker.postMessage('', [channel.port2]);
+        return Promise.resolve(new MessagePortSocket(channel.port1));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyX2Nvbm5lY3Rvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvYnJvd3Nlci93b3JrZXJfY29ubmVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTdEOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUMxQixZQUFvQixNQUFjO1FBQWQsV0FBTSxHQUFOLE1BQU0sQ0FBUTtJQUFHLENBQUM7SUFFdEM7Ozs7OztPQU1HO0lBQ0gsWUFBWTtRQUNWLE1BQU0sT0FBTyxHQUFHLElBQUksY0FBYyxFQUFFLENBQUM7UUFDckMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDN0MsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksaUJBQWlCLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDL0QsQ0FBQztDQUNGIn0=