@aztec/foundation 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/promise/running-promise.js

@@ -5,9 +5,16 @@ import { promiseWithResolvers } from './utils.js';
  * RunningPromise is a utility class that helps manage the execution of an asynchronous function
  * at a specified polling interval. It allows starting, stopping, and checking the status of the
  * internally managed promise. The class also supports interrupting the polling process when stopped.
- */
-export class RunningPromise {
-    constructor(fn, logger = createLogger('running-promise'), pollingIntervalMS = 10000, ignoredErrors = []) {
+ */ export class RunningPromise {
+    fn;
+    logger;
+    pollingIntervalMS;
+    ignoredErrors;
+    running;
+    runningPromise;
+    interruptibleSleep;
+    requested;
+    constructor(fn, logger = createLogger('running-promise'), pollingIntervalMS = 10000, ignoredErrors = []){
         this.fn = fn;
         this.logger = logger;
         this.pollingIntervalMS = pollingIntervalMS;
@@ -18,22 +25,20 @@ export class RunningPromise {
         this.requested = undefined;
     }
     /**
-     * Starts the running promise.
-     */
-    start() {
+   * Starts the running promise.
+   */ start() {
         if (this.running) {
             this.logger.warn(`Attempted to start running promise that was already started`);
             return;
         }
         this.running = true;
-        const poll = async () => {
-            while (this.running) {
+        const poll = async ()=>{
+            while(this.running){
                 const hasRequested = this.requested !== undefined;
                 try {
                     await this.fn();
-                }
-                catch (err) {
-                    if (err instanceof Error && !this.ignoredErrors.some(ErrorType => err instanceof ErrorType)) {
+                } catch (err) {
+                    if (err instanceof Error && !this.ignoredErrors.some((ErrorType)=>err instanceof ErrorType)) {
                         this.logger.error('Error in running promise', err);
                     }
                 }
@@ -51,10 +56,9 @@ export class RunningPromise {
         this.runningPromise = poll();
     }
     /**
-     * Stops the running promise, resolves any pending interruptible sleep,
-     * and waits for the currently executing function to complete.
-     */
-    async stop() {
+   * Stops the running promise, resolves any pending interruptible sleep,
+   * and waits for the currently executing function to complete.
+   */ async stop() {
         if (!this.running) {
             this.logger.warn(`Running promise was not started`);
             return;
@@ -64,17 +68,15 @@ export class RunningPromise {
         await this.runningPromise;
     }
     /**
-     * Checks if the running promise is currently active.
-     * @returns True if the promise is running.
-     */
-    isRunning() {
+   * Checks if the running promise is currently active.
+   * @returns True if the promise is running.
+   */ isRunning() {
         return this.running;
     }
     /**
-     * Triggers an immediate run of the function, bypassing the polling interval.
-     * If the function is currently running, it will be allowed to continue and then called again immediately.
-     */
-    async trigger() {
+   * Triggers an immediate run of the function, bypassing the polling interval.
+   * If the function is currently running, it will be allowed to continue and then called again immediately.
+   */ async trigger() {
         if (!this.running) {
             return this.fn();
         }
@@ -87,11 +89,9 @@ export class RunningPromise {
         await requested.promise;
     }
     /**
-     * Updates the polling interval. The new interval will take effect after the next poll.
-     * @param pollingIntervalMS The polling interval in milliseconds.
-     */
-    setPollingIntervalMS(pollingIntervalMS) {
+   * Updates the polling interval. The new interval will take effect after the next poll.
+   * @param pollingIntervalMS The polling interval in milliseconds.
+   */ setPollingIntervalMS(pollingIntervalMS) {
         this.pollingIntervalMS = pollingIntervalMS;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/promise/utils.js

@@ -2,21 +2,19 @@
  * A polyfill for the Promise.withResolvers proposed API.
  * @see https://github.com/tc39/proposal-promise-with-resolvers
  * @returns A promise with resolvers.
- */
-export function promiseWithResolvers() {
+ */ export function promiseWithResolvers() {
     // use ! operator to avoid TS error
     let resolve;
     let reject;
     // the ES spec guarantees that the promise executor is called synchronously
     // so the resolve and reject functions will be defined
-    const promise = new Promise((res, rej) => {
+    const promise = new Promise((res, rej)=>{
         resolve = res;
         reject = rej;
     });
     return {
         promise,
         resolve,
-        reject,
+        reject
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvbWlzZS91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQjtJQUNsQyxtQ0FBbUM7SUFDbkMsSUFBSSxPQUE0QixDQUFDO0lBQ2pDLElBQUksTUFBK0IsQ0FBQztJQUVwQywyRUFBMkU7SUFDM0Usc0RBQXNEO0lBQ3RELE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxFQUFFO1FBQzFDLE9BQU8sR0FBRyxHQUFHLENBQUM7UUFDZCxNQUFNLEdBQUcsR0FBRyxDQUFDO0lBQ2YsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPO1FBQ0wsT0FBTztRQUNQLE9BQU87UUFDUCxNQUFNO0tBQ1AsQ0FBQztBQUNKLENBQUMifQ==

package/dest/queue/base_memory_queue.js

@@ -1,39 +1,39 @@
 import { TimeoutError } from '../error/index.js';
 import { createLogger } from '../log/index.js';
 export class BaseMemoryQueue {
-    constructor(log = createLogger('foundation:memory_fifo')) {
+    log;
+    waiting;
+    flushing;
+    constructor(log = createLogger('foundation:memory_fifo')){
         this.log = log;
         this.waiting = [];
         this.flushing = false;
     }
     /**
-     * Returns the current number of items in the queue.
-     * The length represents the size of the queue at the time of invocation and may change as new items are added or consumed.
-     *
-     * @returns The number of items in the queue.
-     */
-    length() {
+   * Returns the current number of items in the queue.
+   * The length represents the size of the queue at the time of invocation and may change as new items are added or consumed.
+   *
+   * @returns The number of items in the queue.
+   */ length() {
         return this.items.length;
     }
     /**
-     * Returns next item within the queue, or undefined if the queue is empty. Does not block.
-     * @returns The next item in the queue.
-     */
-    getImmediate() {
+   * Returns next item within the queue, or undefined if the queue is empty. Does not block.
+   * @returns The next item in the queue.
+   */ getImmediate() {
         return this.items.get();
     }
     /**
-     * Returns next item within the queue, or blocks until an item has been put into the queue.
-     *
-     * If given a timeout, the promise will reject if no item is received after `timeoutSec` seconds.
-     * If the timeout is undefined (default), this call will block until an item is available or the queue is closed.
-     * If the timeout is 0 and there are no items available then the queue will immediately reject with a TimeoutError.
-     *
-     * If the queue is flushing, `null` is returned.
-     * @param timeoutSec - The timeout in seconds.
-     * @returns A result promise.
-     */
-    get(timeoutSec) {
+   * Returns next item within the queue, or blocks until an item has been put into the queue.
+   *
+   * If given a timeout, the promise will reject if no item is received after `timeoutSec` seconds.
+   * If the timeout is undefined (default), this call will block until an item is available or the queue is closed.
+   * If the timeout is 0 and there are no items available then the queue will immediately reject with a TimeoutError.
+   *
+   * If the queue is flushing, `null` is returned.
+   * @param timeoutSec - The timeout in seconds.
+   * @returns A result promise.
+   */ get(timeoutSec) {
         if (this.items.length) {
             return Promise.resolve(this.items.get());
         }
@@ -45,11 +45,11 @@ export class BaseMemoryQueue {
         if (timeoutSec === 0) {
             return Promise.reject(new TimeoutError('Timeout getting item from queue.'));
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject)=>{
             this.waiting.push(resolve);
             if (timeoutSec) {
-                setTimeout(() => {
-                    const index = this.waiting.findIndex(r => r === resolve);
+                setTimeout(()=>{
+                    const index = this.waiting.findIndex((r)=>r === resolve);
                     if (index > -1) {
                         this.waiting.splice(index, 1);
                         const err = new TimeoutError('Timeout getting item from queue.');
@@ -60,65 +60,57 @@ export class BaseMemoryQueue {
         });
     }
     /**
-     * Put an item onto back of the queue.
-     * @param item - The item to enqueue.
-     * @returns A boolean indicating whether the item was successfully added to the queue.
-     */
-    put(item) {
+   * Put an item onto back of the queue.
+   * @param item - The item to enqueue.
+   * @returns A boolean indicating whether the item was successfully added to the queue.
+   */ put(item) {
         if (this.flushing) {
             this.log.warn('Discarding item because queue is flushing');
             return false;
-        }
-        else if (this.waiting.length) {
+        } else if (this.waiting.length) {
             this.waiting.shift()(item);
             return true;
-        }
-        else {
+        } else {
             this.items.put(item);
             return true;
         }
     }
     /**
-     * Once ended, no further items are added to queue. Consumers will consume remaining items within the queue.
-     * The queue is not reusable after calling `end()`.
-     * Any consumers waiting for an item receive null.
-     */
-    end() {
+   * Once ended, no further items are added to queue. Consumers will consume remaining items within the queue.
+   * The queue is not reusable after calling `end()`.
+   * Any consumers waiting for an item receive null.
+   */ end() {
         this.flushing = true;
-        this.waiting.forEach(resolve => resolve(null));
+        this.waiting.forEach((resolve)=>resolve(null));
     }
     /**
-     * Once cancelled, all items are discarded from the queue, and no further items are added to the queue.
-     * The queue is not reusable after calling `cancel()`.
-     * Any consumers waiting for an item receive null.
-     */
-    cancel() {
+   * Once cancelled, all items are discarded from the queue, and no further items are added to the queue.
+   * The queue is not reusable after calling `cancel()`.
+   * Any consumers waiting for an item receive null.
+   */ cancel() {
         this.flushing = true;
         this.items.clear();
-        this.waiting.forEach(resolve => resolve(null));
+        this.waiting.forEach((resolve)=>resolve(null));
     }
     /**
-     * Process items from the queue using a provided handler function.
-     * The function iterates over items in the queue, invoking the handler for each item until the queue is empty and flushing.
-     * If the handler throws an error, it will be caught and logged as 'Queue handler exception:', but the iteration will continue.
-     * The process function returns a promise that resolves when there are no more items in the queue and the queue is flushing.
-     *
-     * @param handler - A function that takes an item of type T and returns a Promise<void> after processing the item.
-     * @returns A Promise<void> that resolves when the queue is finished processing.
-     */
-    async process(handler) {
+   * Process items from the queue using a provided handler function.
+   * The function iterates over items in the queue, invoking the handler for each item until the queue is empty and flushing.
+   * If the handler throws an error, it will be caught and logged as 'Queue handler exception:', but the iteration will continue.
+   * The process function returns a promise that resolves when there are no more items in the queue and the queue is flushing.
+   *
+   * @param handler - A function that takes an item of type T and returns a Promise<void> after processing the item.
+   * @returns A Promise<void> that resolves when the queue is finished processing.
+   */ async process(handler) {
         try {
-            while (true) {
+            while(true){
                 const item = await this.get();
                 if (item === null) {
                     break;
                 }
                 await handler(item);
             }
-        }
-        catch (err) {
+        } catch (err) {
             this.log.error('Queue handler exception', err);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/queue/bounded_serial_queue.js

@@ -4,91 +4,81 @@ import { SerialQueue } from './serial_queue.js';
 /**
  * Leverages the unbounded SerialQueue and Semaphore to create a SerialQueue that will block when putting an item
  * if the queue size = maxQueueSize.
- */
-export class BoundedSerialQueue {
-    constructor(maxQueueSize, log = createLogger('foundation:bounded_serial_queue')) {
+ */ export class BoundedSerialQueue {
+    log;
+    queue;
+    semaphore;
+    constructor(maxQueueSize, log = createLogger('foundation:bounded_serial_queue')){
         this.log = log;
         this.queue = new SerialQueue();
         this.semaphore = new Semaphore(maxQueueSize);
     }
     /**
-     * Initializes the underlying SerialQueue instance, allowing items to be processed from the queue.
-     * The start method should be called before using the BoundedSerialQueue to ensure proper functionality.
-     */
-    start() {
+   * Initializes the underlying SerialQueue instance, allowing items to be processed from the queue.
+   * The start method should be called before using the BoundedSerialQueue to ensure proper functionality.
+   */ start() {
         this.queue.start();
     }
     /**
-     * Returns the current number of items in the queue.
-     * This is useful for monitoring the size of BoundedSerialQueue and understanding its utilization.
-     *
-     * @returns The length of the queue as an integer value.
-     */
-    length() {
+   * Returns the current number of items in the queue.
+   * This is useful for monitoring the size of BoundedSerialQueue and understanding its utilization.
+   *
+   * @returns The length of the queue as an integer value.
+   */ length() {
         return this.queue.length();
     }
     /**
-     * Cancels the current operation in the SerialQueue, if any, and clears the queue.
-     * Any pending tasks in the queue will not be executed, and the queue will be emptied.
-     * This method is useful for cleaning up resources and stopping ongoing processes when they are no longer needed.
-     * @returns A promise, resolved once cancelled.
-     */
-    cancel() {
+   * Cancels the current operation in the SerialQueue, if any, and clears the queue.
+   * Any pending tasks in the queue will not be executed, and the queue will be emptied.
+   * This method is useful for cleaning up resources and stopping ongoing processes when they are no longer needed.
+   * @returns A promise, resolved once cancelled.
+   */ cancel() {
         return this.queue.cancel();
     }
     /**
-     * Ends the queue processing gracefully, preventing new items from being added.
-     * The currently executing item, if any, will complete and remaining queued items
-     * will be processed in order. Once all items have been processed, the queue becomes
-     * permanently unusable.
-     *
-     * @returns A promise that resolves when all items in the queue have been processed.
-     */
-    end() {
+   * Ends the queue processing gracefully, preventing new items from being added.
+   * The currently executing item, if any, will complete and remaining queued items
+   * will be processed in order. Once all items have been processed, the queue becomes
+   * permanently unusable.
+   *
+   * @returns A promise that resolves when all items in the queue have been processed.
+   */ end() {
         return this.queue.end();
     }
     /**
-     * The caller will block until fn is successfully enqueued.
-     * The fn itself is execute asynchronously and its result discarded.
-     * TODO(AD) do we need this if we have exec()?
-     * @param fn - The function to call once unblocked.
-     */
-    async put(fn) {
+   * The caller will block until fn is successfully enqueued.
+   * The fn itself is execute asynchronously and its result discarded.
+   * TODO(AD) do we need this if we have exec()?
+   * @param fn - The function to call once unblocked.
+   */ async put(fn) {
         await this.semaphore.acquire();
-        this.queue
-            .put(async () => {
+        this.queue.put(async ()=>{
             try {
                 await fn();
-            }
-            finally {
+            } finally{
                 this.semaphore.release();
             }
-        })
-            .catch(err => {
+        }).catch((err)=>{
             this.log.error('BoundedSerialQueue handler exception:', err);
         });
     }
     /**
-     * The caller will block until fn is successfully executed, and it's result returned.
-     * @param fn - The function.
-     * @returns A promise that resolves with the result once executed.
-     */
-    async exec(fn) {
+   * The caller will block until fn is successfully executed, and it's result returned.
+   * @param fn - The function.
+   * @returns A promise that resolves with the result once executed.
+   */ async exec(fn) {
         await this.semaphore.acquire();
-        return this.queue.put(async () => {
+        return this.queue.put(async ()=>{
             try {
                 return await fn();
-            }
-            finally {
+            } finally{
                 this.semaphore.release();
             }
         });
     }
     /**
-     * Awaiting this ensures the queue is empty before resuming.
-     */
-    async syncPoint() {
+   * Awaiting this ensures the queue is empty before resuming.
+   */ async syncPoint() {
         await this.queue.syncPoint();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/queue/fifo_memory_queue.js

@@ -3,20 +3,17 @@ import { BaseMemoryQueue } from './base_memory_queue.js';
  * A simple fifo queue. It can grow unbounded. It can have multiple producers and consumers.
  * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
  * the item being pushed is simply discarded.
- */
-export class FifoMemoryQueue extends BaseMemoryQueue {
-    constructor(log) {
+ */ export class FifoMemoryQueue extends BaseMemoryQueue {
+    container = new FifoQueue();
+    constructor(log){
         super(log);
-        this.container = new FifoQueue();
     }
     get items() {
         return this.container;
     }
 }
 class FifoQueue {
-    constructor() {
-        this.items = [];
-    }
+    items = [];
     put(item) {
         this.items.push(item);
     }
@@ -30,4 +27,3 @@ class FifoQueue {
         this.items = [];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlmb19tZW1vcnlfcXVldWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvZmlmb19tZW1vcnlfcXVldWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXpEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sZUFBbUIsU0FBUSxlQUFrQjtJQUd4RCxZQUFZLEdBQVk7UUFDdEIsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBSEwsY0FBUyxHQUFHLElBQUksU0FBUyxFQUFLLENBQUM7SUFJdkMsQ0FBQztJQUVELElBQXVCLEtBQUs7UUFDMUIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7Q0FDRjtBQUVELE1BQU0sU0FBUztJQUFmO1FBQ1UsVUFBSyxHQUFRLEVBQUUsQ0FBQztJQWlCMUIsQ0FBQztJQWZRLEdBQUcsQ0FBQyxJQUFPO1FBQ2hCLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFTSxHQUFHO1FBQ1IsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCxJQUFXLE1BQU07UUFDZixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO0lBQzNCLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUM7SUFDbEIsQ0FBQztDQUNGIn0=

package/dest/queue/index.js

@@ -3,4 +3,3 @@ export * from './priority_memory_queue.js';
 export * from './serial_queue.js';
 export * from './bounded_serial_queue.js';
 export * from './semaphore.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGdCQUFnQixDQUFDIn0=

package/dest/queue/priority_memory_queue.js

@@ -4,9 +4,9 @@ import { PriorityQueue } from './priority_queue.js';
  * A priority queue. It can grow unbounded. It can have multiple producers and consumers.
  * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
  * the item being pushed is simply discarded.
- */
-export class PriorityMemoryQueue extends BaseMemoryQueue {
-    constructor(comparator) {
+ */ export class PriorityMemoryQueue extends BaseMemoryQueue {
+    container;
+    constructor(comparator){
         super();
         this.container = new PriorityQueue(comparator);
     }
@@ -14,4 +14,3 @@ export class PriorityMemoryQueue extends BaseMemoryQueue {
         return this.container;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHlfbWVtb3J5X3F1ZXVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXVlL3ByaW9yaXR5X21lbW9yeV9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXBEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sbUJBQXVCLFNBQVEsZUFBa0I7SUFHNUQsWUFBWSxVQUFrQztRQUM1QyxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxhQUFhLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVELElBQXVCLEtBQUs7UUFDMUIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7Q0FDRiJ9

package/dest/queue/priority_queue.js

@@ -1,14 +1,15 @@
 /**
  * Priority queue implementation based on a custom comparator.
- */
-export class PriorityQueue {
-    constructor(comparator) {
+ */ export class PriorityQueue {
+    comparator;
+    items;
+    constructor(comparator){
         this.comparator = comparator;
         this.items = [];
     }
     put(item) {
         let i = 0;
-        while (i < this.items.length && this.comparator(item, this.items[i]) >= 0) {
+        while(i < this.items.length && this.comparator(item, this.items[i]) >= 0){
             i++;
         }
         this.items.splice(i, 0, item);
@@ -26,4 +27,3 @@ export class PriorityQueue {
         return this.items.length;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHlfcXVldWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvcHJpb3JpdHlfcXVldWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sYUFBYTtJQUd4QixZQUFvQixVQUFrQztRQUFsQyxlQUFVLEdBQVYsVUFBVSxDQUF3QjtRQUNwRCxJQUFJLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUNsQixDQUFDO0lBRU0sR0FBRyxDQUFDLElBQU87UUFDaEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ1YsT0FBTyxDQUFDLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQzFFLENBQUMsRUFBRSxDQUFDO1FBQ04sQ0FBQztRQUNELElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVNLEdBQUc7UUFDUixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDNUIsQ0FBQztJQUVNLElBQUk7UUFDVCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkIsQ0FBQztJQUVNLEtBQUs7UUFDVixJQUFJLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUNsQixDQUFDO0lBRUQsSUFBVyxNQUFNO1FBQ2YsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQztJQUMzQixDQUFDO0NBQ0YifQ==

package/dest/queue/semaphore.js

@@ -1,30 +1,26 @@
 import { FifoMemoryQueue } from './fifo_memory_queue.js';
 /**
  * Allows the acquiring of up to `size` tokens before calls to acquire block, waiting for a call to release().
- */
-export class Semaphore {
-    constructor(size) {
-        this.queue = new FifoMemoryQueue();
-        new Array(size).fill(true).map(() => this.queue.put(true));
+ */ export class Semaphore {
+    queue = new FifoMemoryQueue();
+    constructor(size){
+        new Array(size).fill(true).map(()=>this.queue.put(true));
     }
     /**
-     * Acquires a token from the Semaphore, allowing access to a limited resource.
-     * If no tokens are available, the call will block and wait until a token is released.
-     * Use in conjunction with the release() method to manage access to resources with limited capacity.
-     *
-     * @returns A Promise that resolves when a token is acquired.
-     */
-    async acquire() {
+   * Acquires a token from the Semaphore, allowing access to a limited resource.
+   * If no tokens are available, the call will block and wait until a token is released.
+   * Use in conjunction with the release() method to manage access to resources with limited capacity.
+   *
+   * @returns A Promise that resolves when a token is acquired.
+   */ async acquire() {
         await this.queue.get();
     }
     /**
-     * Releases a token back into the semaphore, allowing another acquire call to proceed.
-     * If there are any pending calls to acquire(), one of them will be unblocked and allowed to proceed.
-     * This method should only be called by the holder of the acquired token to ensure proper functionality
-     * and avoid unexpected behavior.
-     */
-    release() {
+   * Releases a token back into the semaphore, allowing another acquire call to proceed.
+   * If there are any pending calls to acquire(), one of them will be unblocked and allowed to proceed.
+   * This method should only be called by the holder of the acquired token to ensure proper functionality
+   * and avoid unexpected behavior.
+   */ release() {
         this.queue.put(true);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VtYXBob3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXVlL3NlbWFwaG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUdwQixZQUFZLElBQVk7UUFGUCxVQUFLLEdBQUcsSUFBSSxlQUFlLEVBQVcsQ0FBQztRQUd0RCxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxPQUFPO1FBQ1osSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdkIsQ0FBQztDQUNGIn0=