appium-mac2-driver 4.5.0 → 4.5.1

package/node_modules/asyncbox/build/cjs/lib/limit-function.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitFunction = getLimitFunction;
+// p-limit is ESM-only. tsc downlevels a plain `import()` in CommonJS output into a
+// require()-in-a-microtask, which still hits Node's require(esm) interop and can race with a
+// concurrent dynamic import() of the same module elsewhere in the process
+// (ERR_REQUIRE_ESM_RACE_CONDITION). Route through `new Function` so tsc can't see or rewrite the
+// import() call, keeping it a genuine native dynamic import in both the ESM and CJS builds.
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+let limitFunctionPromise;
+async function getLimitFunction() {
+    limitFunctionPromise ??= dynamicImport('p-limit');
+    return (await limitFunctionPromise).limitFunction;
+}
+//# sourceMappingURL=limit-function.js.map

package/node_modules/asyncbox/build/cjs/lib/limit-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit-function.js","sourceRoot":"","sources":["../../../lib/limit-function.ts"],"names":[],"mappings":";;AAcA,4CAGC;AAbD,mFAAmF;AACnF,6FAA6F;AAC7F,0EAA0E;AAC1E,iGAAiG;AACjG,4FAA4F;AAC5F,MAAM,aAAa,GAAG,IAAI,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAEhD,CAAC;AAE3B,IAAI,oBAAuD,CAAC;AACrD,KAAK,UAAU,gBAAgB;IACpC,oBAAoB,KAAK,aAAa,CAAC,SAAS,CAAC,CAAC;IAClD,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC,aAAa,CAAC;AACpD,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/lock.d.ts

@@ -0,0 +1,74 @@
+/** Options shared by the {@link AsyncLock} constructor and {@link AsyncLock.acquire}. */
+export interface AsyncLockOptions {
+    /**
+     * Max ms a task may wait in the queue before failing. `0` means never.
+     * @default 0
+     */
+    timeout?: number;
+    /**
+     * Max ms between calling `acquire` and the task finishing (queue wait included). `0` means never.
+     * @default 0
+     */
+    maxOccupationTime?: number;
+    /**
+     * Max ms the task may run once it holds the lock; the lock is then released. `0` means never.
+     * @default 0
+     */
+    maxExecutionTime?: number;
+    /**
+     * Max number of tasks waiting per key; further ones are rejected right away. `0` rejects every
+     * task that would have to wait.
+     * @default 1000
+     */
+    maxPending?: number;
+}
+/** Per-call options of {@link AsyncLock.acquire}; override the constructor ones. */
+export interface AcquireOptions extends AsyncLockOptions {
+    /**
+     * Put the task at the front of the queue instead of the back.
+     * @default false
+     */
+    skipQueue?: boolean;
+}
+type Task<T> = () => T | PromiseLike<T>;
+/**
+ * Promise-based mutex keyed by string. Tasks with the same key run one at a time, in FIFO order.
+ *
+ * Each task runs in the async context (`AsyncLocalStorage`) of the code that called
+ * {@link AsyncLock.acquire}, not in the context of the task that held the lock before it.
+ */
+export declare class AsyncLock {
+    private readonly queues;
+    private readonly defaults;
+    constructor(opts?: AsyncLockOptions);
+    /**
+     * Run `fn` once the lock for `key` is free and release the lock when it settles.
+     *
+     * Multiple keys are held together. They are acquired one by one in sorted order, whatever order
+     * they are given in, so that overlapping calls cannot deadlock; duplicates are ignored. Keys that
+     * are already held stay held while a later one is awaited. `timeout` and `maxOccupationTime` are
+     * budgets for the whole call, while `maxExecutionTime` counts from the moment all the keys are
+     * held and releases all of them.
+     *
+     * @param key - Resource key, or a non-empty array of keys
+     * @param fn - Task to run while holding the lock; may be sync or async
+     * @param opts - Per-call options
+     * @returns The result of `fn`
+     * @throws {TypeError} Synchronously, if an argument is invalid
+     */
+    acquire<T>(key: string | readonly string[], fn: Task<T>, opts?: AcquireOptions): Promise<T>;
+    /**
+     * Number of tasks waiting for `key`, not counting the running one.
+     *
+     * @param key - Resource key
+     */
+    getQueueLength(key: string): number;
+    /**
+     * Whether `key` has a running or pending task. Without a key, whether any key does.
+     *
+     * @param key - Resource key
+     */
+    isBusy(key?: string): boolean;
+}
+export {};
+//# sourceMappingURL=lock.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../lib/lock.ts"],"names":[],"mappings":"AAMA,yFAAyF;AACzF,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,oFAAoF;AACpF,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACtD;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAMxC;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;gBAE1C,IAAI,GAAE,gBAAqB;IAWvC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;IAkB/F;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAInC;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO;CAG9B"}

package/node_modules/asyncbox/build/cjs/lib/lock.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLock = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const DEFAULT_MAX_PENDING = 1000;
+// setTimeout fires after 1 ms for anything above this
+const MAX_TIMER_MS = 2 ** 31 - 1;
+/**
+ * Promise-based mutex keyed by string. Tasks with the same key run one at a time, in FIFO order.
+ *
+ * Each task runs in the async context (`AsyncLocalStorage`) of the code that called
+ * {@link AsyncLock.acquire}, not in the context of the task that held the lock before it.
+ */
+class AsyncLock {
+    queues = new Map();
+    defaults;
+    constructor(opts = {}) {
+        validateOptions(opts);
+        this.defaults = {
+            timeout: 0,
+            maxOccupationTime: 0,
+            maxExecutionTime: 0,
+            maxPending: DEFAULT_MAX_PENDING,
+            ...stripUndefined(opts),
+        };
+    }
+    /**
+     * Run `fn` once the lock for `key` is free and release the lock when it settles.
+     *
+     * Multiple keys are held together. They are acquired one by one in sorted order, whatever order
+     * they are given in, so that overlapping calls cannot deadlock; duplicates are ignored. Keys that
+     * are already held stay held while a later one is awaited. `timeout` and `maxOccupationTime` are
+     * budgets for the whole call, while `maxExecutionTime` counts from the moment all the keys are
+     * held and releases all of them.
+     *
+     * @param key - Resource key, or a non-empty array of keys
+     * @param fn - Task to run while holding the lock; may be sync or async
+     * @param opts - Per-call options
+     * @returns The result of `fn`
+     * @throws {TypeError} Synchronously, if an argument is invalid
+     */
+    acquire(key, fn, opts = {}) {
+        if (typeof fn !== 'function') {
+            throw new TypeError('You must pass a function to execute');
+        }
+        if (typeof key !== 'string' &&
+            !(Array.isArray(key) && key.length > 0 && [...key].every((k) => typeof k === 'string'))) {
+            throw new TypeError('The key must be a string or a non-empty array of strings');
+        }
+        validateOptions(opts);
+        // A canonical order keeps overlapping multi-key calls, e.g. ['a', 'b'] and ['b', 'a'], from deadlocking
+        const keys = typeof key === 'string' ? [key] : [...new Set(key)].sort();
+        const acquisition = new Acquisition(this.queues, keys, fn, { ...this.defaults, ...stripUndefined(opts) });
+        acquisition.enqueue();
+        return acquisition.promise;
+    }
+    /**
+     * Number of tasks waiting for `key`, not counting the running one.
+     *
+     * @param key - Resource key
+     */
+    getQueueLength(key) {
+        return this.queues.get(key)?.length ?? 0;
+    }
+    /**
+     * Whether `key` has a running or pending task. Without a key, whether any key does.
+     *
+     * @param key - Resource key
+     */
+    isBusy(key) {
+        return key === undefined ? this.queues.size > 0 : this.queues.has(key);
+    }
+}
+exports.AsyncLock = AsyncLock;
+/** The place of one acquisition in the queue of one key; once granted, it holds the key. */
+class KeyClaim {
+    queues;
+    key;
+    opts;
+    onGranted;
+    onDenied;
+    holding = false;
+    dropped = false;
+    queueTimer;
+    constructor(queues, key, opts, onGranted, onDenied) {
+        this.queues = queues;
+        this.key = key;
+        this.opts = opts;
+        this.onGranted = onGranted;
+        this.onDenied = onDenied;
+    }
+    /**
+     * Take the key right away if it is free, otherwise wait in its queue.
+     *
+     * @returns Whether the key is held. If not, `onGranted` is called once it is, unless the claim
+     * is denied.
+     */
+    join() {
+        const { timeout, maxPending, skipQueue } = this.opts;
+        const queue = this.queues.get(this.key);
+        if (!queue) {
+            this.queues.set(this.key, []);
+            this.holding = true;
+            return true;
+        }
+        if (queue.length >= maxPending) {
+            this.onDenied(new Error(`Too many pending tasks in queue ${this.key}`));
+        }
+        else {
+            if (skipQueue) {
+                queue.unshift(this.grant);
+            }
+            else {
+                queue.push(this.grant);
+            }
+            if (timeout) {
+                this.queueTimer = setTimeout(() => this.onDenied(new Error(`async-lock timed out in queue ${this.key}`)), timeout);
+            }
+        }
+        return false;
+    }
+    /**
+     * Leave the queue, or release the key if it is held. Idempotent.
+     *
+     * @returns The handover of the key to its next waiter. The caller must run it only after it
+     * has released all of its keys, so that no waiter starts while a batch is partially released.
+     */
+    drop() {
+        if (this.dropped) {
+            return undefined;
+        }
+        this.dropped = true;
+        clearTimeout(this.queueTimer);
+        if (this.holding) {
+            return this.releaseKey();
+        }
+        const queue = this.queues.get(this.key);
+        const idx = queue?.indexOf(this.grant) ?? -1;
+        if (idx >= 0) {
+            queue?.splice(idx, 1);
+        }
+        return undefined;
+    }
+    releaseKey() {
+        const next = this.queues.get(this.key)?.shift();
+        if (!next) {
+            this.queues.delete(this.key);
+        }
+        return next;
+    }
+    // An arrow function, because this exact reference sits in the queue and is removed by drop()
+    grant = () => {
+        clearTimeout(this.queueTimer);
+        this.holding = true;
+        if (this.dropped) {
+            // Dropped while the key was being handed over to it: pass the key on instead of using it
+            this.releaseKey()?.();
+            return;
+        }
+        this.onGranted();
+    };
+}
+/**
+ * One `acquire` call: its promise, its timers and its claims on all of its keys. The keys are
+ * claimed one by one, the task runs once all of them are held and they are released together.
+ */
+class Acquisition {
+    queues;
+    keys;
+    opts;
+    promise;
+    resolve;
+    reject;
+    task;
+    claims = [];
+    running = false;
+    settled = false;
+    queueDeadline = 0;
+    occupationTimer;
+    executionTimer;
+    constructor(queues, keys, task, opts) {
+        this.queues = queues;
+        this.keys = keys;
+        this.opts = opts;
+        // Queued tasks are started from the previous task's promise chain; bind to keep our context
+        this.task = node_async_hooks_1.AsyncResource.bind(task);
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+    /** Start the task right away if all the keys are free, otherwise wait for them. */
+    enqueue() {
+        const { timeout, maxOccupationTime } = this.opts;
+        if (timeout) {
+            this.queueDeadline = performance.now() + timeout;
+        }
+        if (maxOccupationTime) {
+            this.occupationTimer = setTimeout(() => this.expire(), maxOccupationTime);
+        }
+        this.claimKeys(0);
+    }
+    // Free keys are claimed in a loop, not recursively, so that a large batch cannot overflow the stack
+    claimKeys(from) {
+        const { maxPending, skipQueue } = this.opts;
+        try {
+            for (let index = from; index < this.keys.length; index++) {
+                // The queue timeout is a budget for waiting for all the keys, not for each one
+                const timeout = this.queueDeadline ? Math.max(this.queueDeadline - performance.now(), 1) : 0;
+                const claim = new KeyClaim(this.queues, this.keys[index], { timeout, maxPending, skipQueue }, () => this.claimKeys(index + 1), (error) => this.abort(error));
+                this.claims.push(claim);
+                if (!claim.join()) {
+                    return;
+                }
+            }
+            this.execute();
+        }
+        catch (error) {
+            this.abort(error);
+        }
+    }
+    execute() {
+        const { maxExecutionTime } = this.opts;
+        this.running = true;
+        if (maxExecutionTime) {
+            this.executionTimer = setTimeout(() => this.abort(new Error(`Maximum execution time is exceeded ${this.keys.join(', ')}`)), maxExecutionTime);
+        }
+        new Promise((resolve) => resolve(this.task())).then((value) => this.finish({ value }), (error) => this.finish({ error }));
+    }
+    finish(outcome) {
+        this.settle(outcome);
+        this.release();
+    }
+    // Reject and release all the keys; a running task is left to finish on its own
+    abort(error) {
+        this.settle({ error });
+        this.release();
+    }
+    // A running task keeps its keys until it finishes, an unstarted one gives them up
+    expire() {
+        const keys = this.keys.join(', ');
+        if (this.running) {
+            this.settle({ error: new Error(`Maximum occupation time is exceeded while executing ${keys}`) });
+        }
+        else {
+            this.abort(new Error(`Maximum occupation time is exceeded in queue ${keys}`));
+        }
+    }
+    settle(outcome) {
+        if (this.settled) {
+            return;
+        }
+        this.settled = true;
+        clearTimeout(this.occupationTimer);
+        if ('error' in outcome) {
+            this.reject(outcome.error);
+        }
+        else {
+            this.resolve(outcome.value);
+        }
+    }
+    // Idempotent, so a task that outlives its execution timeout cannot release the keys twice
+    release() {
+        clearTimeout(this.executionTimer);
+        const handovers = this.claims
+            .splice(0)
+            .reverse()
+            .map((claim) => claim.drop());
+        for (const handover of handovers) {
+            handover?.();
+        }
+    }
+}
+function validateOptions(opts) {
+    if (opts === null || typeof opts !== 'object') {
+        throw new TypeError('The options must be an object');
+    }
+    for (const name of ['timeout', 'maxOccupationTime', 'maxExecutionTime']) {
+        const value = opts[name];
+        if (value !== undefined && !(Number.isFinite(value) && value >= 0 && value <= MAX_TIMER_MS)) {
+            throw new TypeError(`${name} must be a number of milliseconds between 0 and ${MAX_TIMER_MS}`);
+        }
+    }
+    if (opts.skipQueue !== undefined && typeof opts.skipQueue !== 'boolean') {
+        throw new TypeError('skipQueue must be a boolean');
+    }
+    const { maxPending } = opts;
+    if (maxPending !== undefined && maxPending !== Infinity && !(Number.isInteger(maxPending) && maxPending >= 0)) {
+        throw new TypeError('maxPending must be a non-negative integer or Infinity');
+    }
+}
+function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+//# sourceMappingURL=lock.js.map

package/node_modules/asyncbox/build/cjs/lib/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../../lib/lock.ts"],"names":[],"mappings":"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"}

package/node_modules/asyncbox/build/cjs/lib/long-sleep.d.ts

@@ -0,0 +1,15 @@
+import type { LongSleepOptions } from './types.js';
+/**
+ * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
+ * times. To safely wait for these long times (e.g. in the 5+ minute range), you
+ * can use `longSleep`.
+ *
+ * You can also pass a `progressCb` option which is a callback function that
+ * receives an object with the properties `elapsedMs`, `timeLeft`, and
+ * `progress`. This will be called on every wait interval so you can do your
+ * wait logging or whatever.
+ * @param ms - The number of milliseconds to wait
+ * @param options - Options for controlling the long sleep behavior
+ */
+export declare function longSleep(ms: number, { thresholdMs, intervalMs, progressCb }?: LongSleepOptions): Promise<void>;
+//# sourceMappingURL=long-sleep.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/long-sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"long-sleep.d.ts","sourceRoot":"","sources":["../../../lib/long-sleep.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAIjD;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAC7B,EAAE,EAAE,MAAM,EACV,EAAC,WAAkC,EAAE,UAAiB,EAAE,UAAiB,EAAC,GAAE,gBAAqB,GAChG,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/node_modules/asyncbox/build/cjs/lib/long-sleep.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longSleep = longSleep;
+const sleep_js_1 = require("./sleep.js");
+const LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin
+/**
+ * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
+ * times. To safely wait for these long times (e.g. in the 5+ minute range), you
+ * can use `longSleep`.
+ *
+ * You can also pass a `progressCb` option which is a callback function that
+ * receives an object with the properties `elapsedMs`, `timeLeft`, and
+ * `progress`. This will be called on every wait interval so you can do your
+ * wait logging or whatever.
+ * @param ms - The number of milliseconds to wait
+ * @param options - Options for controlling the long sleep behavior
+ */
+async function longSleep(ms, { thresholdMs = LONG_SLEEP_THRESHOLD, intervalMs = 1000, progressCb = null } = {}) {
+    if (ms < thresholdMs) {
+        return await (0, sleep_js_1.sleep)(ms);
+    }
+    const endAt = performance.now() + ms;
+    let timeLeft;
+    let elapsedMs = 0;
+    do {
+        const pre = performance.now();
+        await (0, sleep_js_1.sleep)(intervalMs);
+        const post = performance.now();
+        timeLeft = endAt - post;
+        elapsedMs = elapsedMs + (post - pre);
+        if (typeof progressCb === 'function') {
+            progressCb({ elapsedMs: Math.round(elapsedMs), timeLeft: Math.round(timeLeft), progress: elapsedMs / ms });
+        }
+    } while (timeLeft > 0);
+}
+//# sourceMappingURL=long-sleep.js.map

package/node_modules/asyncbox/build/cjs/lib/long-sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"long-sleep.js","sourceRoot":"","sources":["../../../lib/long-sleep.ts"],"names":[],"mappings":";;AAiBA,8BAoBC;AArCD,yCAAiC;AAGjC,MAAM,oBAAoB,GAAG,IAAI,CAAC,CAAC,6CAA6C;AAEhF;;;;;;;;;;;GAWG;AACI,KAAK,UAAU,SAAS,CAC7B,EAAU,EACV,EAAC,WAAW,GAAG,oBAAoB,EAAE,UAAU,GAAG,IAAI,EAAE,UAAU,GAAG,IAAI,KAAsB,EAAE;IAEjG,IAAI,EAAE,GAAG,WAAW,EAAE,CAAC;QACrB,OAAO,MAAM,IAAA,gBAAK,EAAC,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;IACrC,IAAI,QAAgB,CAAC;IACrB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,GAAG,CAAC;QACF,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC9B,MAAM,IAAA,gBAAK,EAAC,UAAU,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC/B,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC;QACxB,SAAS,GAAG,SAAS,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;QACrC,IAAI,OAAO,UAAU,KAAK,UAAU,EAAE,CAAC;YACrC,UAAU,CAAC,EAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,SAAS,GAAG,EAAE,EAAC,CAAC,CAAC;QAC3G,CAAC;IACH,CAAC,QAAQ,QAAQ,GAAG,CAAC,EAAE;AACzB,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/retry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * An async/await way of running a method until it doesn't throw an error
+ * @param times - The maximum number of times to retry the function
+ * @param fn - The async function to retry
+ * @param args - Arguments to pass to the function
+ */
+export declare function retry<T = any>(times: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
+/**
+ * You can also use `retryInterval` to add a sleep in between retries. This can
+ * be useful if you want to throttle how fast we retry.
+ * @param times - The maximum number of times to retry the function
+ * @param sleepMs - The number of milliseconds to wait between retries
+ * @param fn - The async function to retry
+ * @param args - Arguments to pass to the function
+ */
+export declare function retryInterval<T = any>(times: number, sleepMs: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
+//# sourceMappingURL=retry.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../lib/retry.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,CAAC,GAAG,GAAG,EACjC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAgBnB;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,CAAC,GAAG,GAAG,EACzC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAiBnB"}

package/node_modules/asyncbox/build/cjs/lib/retry.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = retry;
+exports.retryInterval = retryInterval;
+const sleep_js_1 = require("./sleep.js");
+/**
+ * An async/await way of running a method until it doesn't throw an error
+ * @param times - The maximum number of times to retry the function
+ * @param fn - The async function to retry
+ * @param args - Arguments to pass to the function
+ */
+async function retry(times, fn, ...args) {
+    let tries = 0;
+    let done = false;
+    let res = null;
+    while (!done && tries < times) {
+        tries++;
+        try {
+            res = await fn(...args);
+            done = true;
+        }
+        catch (err) {
+            if (tries >= times) {
+                throw err;
+            }
+        }
+    }
+    return res;
+}
+/**
+ * You can also use `retryInterval` to add a sleep in between retries. This can
+ * be useful if you want to throttle how fast we retry.
+ * @param times - The maximum number of times to retry the function
+ * @param sleepMs - The number of milliseconds to wait between retries
+ * @param fn - The async function to retry
+ * @param args - Arguments to pass to the function
+ */
+async function retryInterval(times, sleepMs, fn, ...args) {
+    let count = 0;
+    const wrapped = async () => {
+        count++;
+        let res;
+        try {
+            res = await fn(...args);
+        }
+        catch (e) {
+            // do not pause when finished the last retry
+            if (count !== times) {
+                await (0, sleep_js_1.sleep)(sleepMs);
+            }
+            throw e;
+        }
+        return res;
+    };
+    return await retry(times, wrapped);
+}
+//# sourceMappingURL=retry.js.map

package/node_modules/asyncbox/build/cjs/lib/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../lib/retry.ts"],"names":[],"mappings":";;AAQA,sBAoBC;AAUD,sCAsBC;AA5DD,yCAAiC;AAEjC;;;;;GAKG;AACI,KAAK,UAAU,KAAK,CACzB,KAAa,EACb,EAAkC,EAClC,GAAG,IAAW;IAEd,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,KAAK,CAAC;IACjB,IAAI,GAAG,GAAa,IAAI,CAAC;IACzB,OAAO,CAAC,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,CAAC;QAC9B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;YACxB,IAAI,GAAG,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;gBACnB,MAAM,GAAG,CAAC;YACZ,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,aAAa,CACjC,KAAa,EACb,OAAe,EACf,EAAkC,EAClC,GAAG,IAAW;IAEd,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,OAAO,GAAG,KAAK,IAAgB,EAAE;QACrC,KAAK,EAAE,CAAC;QACR,IAAI,GAAM,CAAC;QACX,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAC1B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,4CAA4C;YAC5C,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;gBACpB,MAAM,IAAA,gBAAK,EAAC,OAAO,CAAC,CAAC;YACvB,CAAC;YACD,MAAM,CAAC,CAAC;QACV,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IACF,OAAO,MAAM,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/sleep.d.ts

@@ -0,0 +1,20 @@
+import type { CancellablePromise, SleepOptions } from './types.js';
+/**
+ * An async/await version of `setTimeout`. The returned promise has a `cancel()` method that clears
+ * the timer and usually rejects with {@link PromiseCancellationError} unless you use the object form with
+ * `cancelError: null` to resolve on cancel.
+ *
+ * @param ms - Milliseconds to wait
+ * @returns A thenable you can `await`; call `.cancel()` to abort early.
+ */
+export declare function sleep(ms: number): CancellablePromise<void>;
+/**
+ * Object form: `ms` plus optional `cancelError` (non-empty string or `Error`, `null` to resolve on
+ * cancel, or omitted / `undefined` / `''` for default {@link PromiseCancellationError}). Any non-array
+ * object with a finite `ms` is accepted at runtime (including class instances), matching structural typing.
+ *
+ * @param options - Duration and optional cancellation behavior
+ * @returns A thenable you can `await`; call `.cancel()` to abort early.
+ */
+export declare function sleep(options: SleepOptions): CancellablePromise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../lib/sleep.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,kBAAkB,EAAY,YAAY,EAAC,MAAM,YAAY,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/sleep.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+const errors_js_1 = require("./errors.js");
+function sleep(arg) {
+    const { ms, cancelError } = parseSleepArg(arg);
+    let timeoutId;
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise((resolve, reject) => {
+        resolveFn = resolve;
+        rejectFn = reject;
+        timeoutId = setTimeout(resolve, ms);
+    });
+    promise.cancel = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (cancelError === null) {
+            resolveFn?.(undefined);
+        }
+        else {
+            let err;
+            if (typeof cancelError === 'string' && cancelError) {
+                err = new errors_js_1.PromiseCancellationError(cancelError);
+            }
+            else if (cancelError instanceof Error) {
+                err = cancelError;
+            }
+            else {
+                err = new errors_js_1.PromiseCancellationError();
+            }
+            rejectFn?.(err);
+        }
+        resolveFn = undefined;
+        rejectFn = undefined;
+    };
+    return promise;
+}
+/** Non-array object values (including class instances); excludes `null` and arrays. */
+function isSleepArgObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function parseSleepArg(arg) {
+    if (typeof arg === 'number') {
+        if (!Number.isFinite(arg)) {
+            throw new TypeError('sleep: expected a finite number or an object with ms');
+        }
+        return { ms: arg };
+    }
+    if (isSleepArgObject(arg)) {
+        const ms = arg.ms;
+        if (typeof ms !== 'number' || !Number.isFinite(ms)) {
+            throw new TypeError('sleep: options.ms must be a finite number');
+        }
+        return { ms, cancelError: arg.cancelError };
+    }
+    throw new TypeError('sleep: expected a finite number or an object with ms');
+}
+//# sourceMappingURL=sleep.js.map

package/node_modules/asyncbox/build/cjs/lib/sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.js","sourceRoot":"","sources":["../../../lib/sleep.ts"],"names":[],"mappings":";;AAqBA,sBAmCC;AAxDD,2CAAqD;AAqBrD,SAAgB,KAAK,CAAC,GAAa;IACjC,MAAM,EAAC,EAAE,EAAE,WAAW,EAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7C,IAAI,SAAqC,CAAC;IAC1C,IAAI,SAA8C,CAAC;IACnD,IAAI,QAA8C,CAAC;IAEnD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACpD,SAAS,GAAG,OAAO,CAAC;QACpB,QAAQ,GAAG,MAAM,CAAC;QAClB,SAAS,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACtC,CAAC,CAA6B,CAAC;IAE/B,OAAO,CAAC,MAAM,GAAG,GAAG,EAAE;QACpB,IAAI,SAAS,EAAE,CAAC;YACd,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,SAAS,GAAG,SAAS,CAAC;QACxB,CAAC;QACD,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;YACzB,SAAS,EAAE,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,IAAI,GAAU,CAAC;YACf,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,EAAE,CAAC;gBACnD,GAAG,GAAG,IAAI,oCAAwB,CAAC,WAAW,CAAC,CAAC;YAClD,CAAC;iBAAM,IAAI,WAAW,YAAY,KAAK,EAAE,CAAC;gBACxC,GAAG,GAAG,WAAW,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,GAAG,GAAG,IAAI,oCAAwB,EAAE,CAAC;YACvC,CAAC;YACD,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC;QACD,SAAS,GAAG,SAAS,CAAC;QACtB,QAAQ,GAAG,SAAS,CAAC;IACvB,CAAC,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,uFAAuF;AACvF,SAAS,gBAAgB,CAAC,KAAc;IACtC,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED,SAAS,aAAa,CAAC,GAAa;IAClC,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,SAAS,CAAC,sDAAsD,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,EAAC,EAAE,EAAE,GAAG,EAAC,CAAC;IACnB,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,EAAE,GAAG,GAAG,CAAC,EAAE,CAAC;QAClB,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,EAAC,EAAE,EAAE,WAAW,EAAE,GAAG,CAAC,WAAgD,EAAC,CAAC;IACjF,CAAC;IACD,MAAM,IAAI,SAAS,CAAC,sDAAsD,CAAC,CAAC;AAC9E,CAAC"}