appium-mac2-driver 4.6.0 → 4.6.1

package/node_modules/@appium/support/node_modules/asyncbox/lib/retry.ts

@@ -0,0 +1,61 @@
+import {sleep} from './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
+ */
+export async function retry<T = any>(
+  times: number,
+  fn: (...args: any[]) => Promise<T>,
+  ...args: any[]
+): Promise<T | null> {
+  let tries = 0;
+  let done = false;
+  let res: T | null = 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
+ */
+export async function retryInterval<T = any>(
+  times: number,
+  sleepMs: number,
+  fn: (...args: any[]) => Promise<T>,
+  ...args: any[]
+): Promise<T | null> {
+  let count = 0;
+  const wrapped = async (): Promise<T> => {
+    count++;
+    let res: T;
+    try {
+      res = await fn(...args);
+    } catch (e) {
+      // do not pause when finished the last retry
+      if (count !== times) {
+        await sleep(sleepMs);
+      }
+      throw e;
+    }
+    return res;
+  };
+  return await retry(times, wrapped);
+}

package/node_modules/@appium/support/node_modules/asyncbox/lib/sleep.ts

@@ -0,0 +1,79 @@
+import {PromiseCancellationError} from './errors.js';
+import type {CancellablePromise, SleepArg, 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 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 function sleep(options: SleepOptions): CancellablePromise<void>;
+export function sleep(arg: SleepArg): CancellablePromise<void> {
+  const {ms, cancelError} = parseSleepArg(arg);
+  let timeoutId: NodeJS.Timeout | undefined;
+  let resolveFn: ((value: void) => void) | undefined;
+  let rejectFn: ((error: Error) => void) | undefined;
+
+  const promise = new Promise<void>((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+    timeoutId = setTimeout(resolve, ms);
+  }) as CancellablePromise<void>;
+
+  promise.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+    if (cancelError === null) {
+      resolveFn?.(undefined);
+    } else {
+      let err: Error;
+      if (typeof cancelError === 'string' && cancelError) {
+        err = new PromiseCancellationError(cancelError);
+      } else if (cancelError instanceof Error) {
+        err = cancelError;
+      } else {
+        err = new PromiseCancellationError();
+      }
+      rejectFn?.(err);
+    }
+    resolveFn = undefined;
+    rejectFn = undefined;
+  };
+
+  return promise;
+}
+
+/** Non-array object values (including class instances); excludes `null` and arrays. */
+function isSleepArgObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseSleepArg(arg: SleepArg): {ms: number; cancelError?: string | Error | null} {
+  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 as string | Error | null | undefined};
+  }
+  throw new TypeError('sleep: expected a finite number or an object with ms');
+}

package/node_modules/@appium/support/node_modules/asyncbox/lib/types.ts

@@ -0,0 +1,88 @@
+/**
+ * Parameter provided to a progress callback
+ */
+export interface Progress {
+  /** Elapsed time in milliseconds since the operation started */
+  elapsedMs: number;
+  /** Remaining time in milliseconds until the operation completes */
+  timeLeft: number;
+  /** Progress as a number between 0 and 1 (0 = not started, 1 = complete) */
+  progress: number;
+}
+
+/**
+ * Progress callback for {@link longSleep}
+ */
+export type ProgressCallback = (progress: Progress) => void;
+
+/**
+ * Options for {@link longSleep}
+ */
+export interface LongSleepOptions {
+  /** Minimum duration in milliseconds before using long sleep behavior.
+   * @default 5000
+   */
+  thresholdMs?: number;
+  /** Interval in milliseconds between progress callbacks.
+   * @default 1000
+   */
+  intervalMs?: number;
+  /** Optional callback function to receive progress updates during the sleep */
+  progressCb?: ProgressCallback | null;
+}
+
+/**
+ * Options for {@link asyncmap} and {@link asyncfilter}
+ */
+export type MapFilterOptions = boolean | {concurrency: number};
+
+/**
+ * Object form of {@link sleep}'s argument: duration plus optional cancellation rejection override.
+ * Structural typing allows class instances; {@link sleep} accepts any non-array object with a finite `ms`.
+ */
+export interface SleepOptions {
+  /** Duration in milliseconds */
+  ms: number;
+  /**
+   * When {@link sleep}'s `cancel` runs: a non-empty string becomes {@link PromiseCancellationError}
+   * with that message; an `Error` rejects with that same instance; `null` resolves the promise
+   * instead of rejecting; omitted, `undefined`, or `''` use the default {@link PromiseCancellationError}.
+   */
+  cancelError?: string | Error | null;
+}
+
+/**
+ * Argument to {@link sleep}: either milliseconds or an options object (see {@link SleepOptions}).
+ */
+export type SleepArg = number | SleepOptions;
+
+/**
+ * A promise with a {@linkcode cancel} method (e.g. from {@link sleep}).
+ *
+ * @typeParam T - Resolved value type; {@link sleep} uses `void`.
+ */
+export type CancellablePromise<T = void> = Promise<T> & {
+  cancel: () => void;
+};
+
+/**
+ * Options for {@link waitForCondition}
+ */
+export interface WaitForConditionOptions {
+  /** Maximum time to wait in milliseconds.
+   * @default 5000
+   */
+  waitMs?: number;
+  /** Interval in milliseconds between condition checks.
+   * @default 500
+   */
+  intervalMs?: number;
+  /** Optional logger object with a debug method for logging wait progress */
+  logger?: {
+    debug: (...args: any[]) => void;
+  };
+  /** Custom error message (string) or Error object to throw if condition is not met.
+   * If not provided, a default error is thrown
+   */
+  error?: string | Error;
+}

package/node_modules/@appium/support/node_modules/asyncbox/lib/wait-for-condition.ts

@@ -0,0 +1,52 @@
+import {sleep} from './sleep.js';
+import type {WaitForConditionOptions} from './types.js';
+
+/**
+ * Takes a condition (a function returning a boolean or boolean promise), and
+ * waits until the condition is true.
+ *
+ * Throws a `/Condition unmet/` error if the condition has not been satisfied
+ * within the allocated time, unless an error is provided in the options, as the
+ * `error` property, which is either thrown itself, or used as the message.
+ *
+ * The condition result is returned if it is not falsy. If the condition throws an
+ * error then this exception will be immediately passed through.
+ *
+ * The default options are: `{ waitMs: 5000, intervalMs: 500 }`
+ * @param condFn - The condition function to evaluate
+ * @param options - Options for controlling the wait behavior
+ */
+export async function waitForCondition<T>(
+  condFn: () => Promise<T> | T,
+  options: WaitForConditionOptions = {},
+): Promise<T> {
+  const opts: WaitForConditionOptions & {waitMs: number; intervalMs: number} = {
+    ...options,
+    waitMs: typeof options.waitMs === 'number' ? options.waitMs : 5000,
+    intervalMs: typeof options.intervalMs === 'number' ? options.intervalMs : 500,
+  };
+  const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : () => undefined;
+  const error = opts.error;
+  const begunAt = performance.now();
+  const endAt = begunAt + opts.waitMs;
+  const spin = async function spin(): Promise<T> {
+    const result = await condFn();
+    if (result) {
+      return result;
+    }
+    const now = performance.now();
+    const waited = Math.round(now - begunAt);
+    const remainingTime = endAt - now;
+    if (now < endAt) {
+      debug(`Waited for ${waited} ms so far`);
+      await sleep(Math.min(opts.intervalMs, remainingTime));
+      return await spin();
+    }
+    // if there is an error option, it is either a string message or an error itself
+    if (error) {
+      throw typeof error === 'string' ? new Error(error) : error;
+    }
+    throw new Error(`Condition unmet after ${waited} ms. Timing out.`);
+  };
+  return await spin();
+}

package/node_modules/@appium/support/node_modules/asyncbox/lib/with-timeout.ts

@@ -0,0 +1,43 @@
+import {TimeoutError} from './errors.js';
+
+/**
+ * Resolves with `promise` or rejects if it does not settle before `timeoutMs`.
+ *
+ * If the deadline passes first: with no third argument (or a falsy non-error value), rejects
+ * with {@link TimeoutError} whose message includes `timeoutMs`; with a non-empty string,
+ * rejects with {@link TimeoutError} using that message; with an `Error` instance, rejects
+ * with that same instance.
+ *
+ * @param promise - Promise to race against the timeout.
+ * @param timeoutMs - Maximum time in milliseconds before rejecting if `promise` has not settled.
+ * @param messageOrError - Optional override for the timeout rejection: custom {@link TimeoutError}
+ * message when the string is non-empty, or an existing `Error` to reject with verbatim.
+ * Omitted, `undefined`, or other falsy non-error values use the default timeout message (includes `timeoutMs`).
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  messageOrError?: string | Error,
+): Promise<T> {
+  let timer: NodeJS.Timeout | null = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_resolve, reject) => {
+        timer = setTimeout(() => {
+          if (typeof messageOrError === 'string' && messageOrError) {
+            reject(new TimeoutError(messageOrError));
+          } else if (!messageOrError) {
+            reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+          } else {
+            reject(messageOrError);
+          }
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}

package/node_modules/@appium/support/node_modules/asyncbox/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "asyncbox",
+  "version": "6.5.0",
+  "description": "A collection of small async/await utilities",
+  "keywords": [
+    "async",
+    "async/await",
+    "es7"
+  ],
+  "bugs": {
+    "url": "https://github.com/appium/asyncbox/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "jlipps@gmail.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/appium/asyncbox.git"
+  },
+  "bin": {},
+  "directories": {
+    "lib": "./lib"
+  },
+  "files": [
+    "lib/**/*",
+    "build/cjs/lib/**/*",
+    "build/cjs/package.json",
+    "build/esm/lib/**/*",
+    "build/esm/package.json"
+  ],
+  "type": "module",
+  "main": "./build/cjs/lib/index.js",
+  "module": "./build/esm/lib/index.js",
+  "types": "./build/cjs/lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./build/esm/lib/index.d.ts",
+        "default": "./build/esm/lib/index.js"
+      },
+      "require": {
+        "types": "./build/cjs/lib/index.d.ts",
+        "default": "./build/cjs/lib/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.esm.json tsconfig.cjs.json",
+    "postbuild": "node scripts/postbuild.mjs",
+    "clean": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
+    "rebuild": "npm run clean; npm run build",
+    "dev": "npm run build -- --watch",
+    "prepare": "npm run rebuild",
+    "test": "node --test --enable-source-maps --test-force-exit --test-timeout=60000 \"./build/esm/test/**/*.spec.js\" \"./test/*.spec.cjs\"",
+    "lint": "oxlint -c oxlint.config.mjs .",
+    "lint:fix": "oxlint -c oxlint.config.mjs --fix .",
+    "format": "oxfmt -c oxfmt.config.mjs .",
+    "format:check": "oxfmt -c oxfmt.config.mjs --check .",
+    "watch": "npm run dev"
+  },
+  "dependencies": {
+    "p-limit": "^7.2.0"
+  },
+  "devDependencies": {
+    "@appium/oxc-config": "^1.1.0",
+    "@appium/semantic-release-config": "^1.1.0",
+    "@appium/tsconfig": "^1.2.0",
+    "@types/node": "^26.1.0"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
+    "npm": ">=10"
+  }
+}

package/node_modules/asyncbox/README.md

@@ -158,10 +158,10 @@ const newItemsMaxTwo = await asyncmap(items, slowSquare, {concurrency: 2});
 Takes a condition (a function returning a boolean or boolean promise),
 and waits until the condition is true.
 
-Throws a `/Condition unmet/` error if the condition has not been
-satisfied within the allocated time, unless an error is provided in
-the options, as the `error` property, which is either thrown itself, or
-used as the message.
+Throws a `ConditionUnmetError` (message matches `/Condition unmet/`) if the
+condition has not been satisfied within the allocated time, unless an error is
+provided in the options, as the `error` property, which is either thrown itself,
+or used as the message of a `ConditionUnmetError`.
 
 The condition result is returned if it is not falsy. If the condition
 throws an error then this exception will be immediately passed through.
@@ -251,6 +251,20 @@ Times are in ms, up to 2147483647, and `0` means no limit.
 - `maxPending` (default `1000`) - max tasks waiting per key; further ones are rejected right away, so `0` rejects every task that would have to wait
 - `skipQueue` (default `false`, per call only) - put the task at the front of the queue
 
+### Errors
+
+The built-in errors of this package extend `AsyncboxError` and carry a stable `code`,
+so match them by `instanceof` or `err.code` instead of the message text. Caller-supplied
+errors (e.g. the `error` option of `waitForCondition`) are passed through as is:
+
+| Class | `code` | Thrown by |
+| --- | --- | --- |
+| `TimeoutError` | `ERR_ASYNCBOX_TIMEOUT` | `withTimeout` |
+| `ConditionUnmetError` (extends `TimeoutError`) | `ERR_ASYNCBOX_CONDITION_UNMET` | `waitForCondition` |
+| `LockTimeoutError` (extends `TimeoutError`) | `ERR_ASYNCBOX_LOCK_TIMEOUT` | `AsyncLock` (queue, execution or occupation time exceeded) |
+| `LockQueueFullError` | `ERR_ASYNCBOX_LOCK_QUEUE_FULL` | `AsyncLock` (`maxPending` reached) |
+| `PromiseCancellationError` | `ERR_ASYNCBOX_CANCELLED` | `sleep` cancellation |
+
 ### Run the tests
 
 ```

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

@@ -1,9 +1,27 @@
+/** Base class of the built-in typed errors of this package; match by `instanceof` or {@link AsyncboxError.code}. */
+export declare class AsyncboxError extends Error {
+    /** Stable machine-readable identifier, e.g. `ERR_ASYNCBOX_TIMEOUT` */
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
 /** Error thrown by {@link withTimeout} when the deadline is exceeded. */
-export declare class TimeoutError extends Error {
+export declare class TimeoutError extends AsyncboxError {
+    constructor(message?: string, code?: string);
+}
+/** Thrown by {@link waitForCondition} when the condition is not met in time. */
+export declare class ConditionUnmetError extends TimeoutError {
+    constructor(message?: string);
+}
+/** Thrown by {@link AsyncLock} when a queue, execution or occupation time limit is exceeded. */
+export declare class LockTimeoutError extends TimeoutError {
+    constructor(message?: string);
+}
+/** Thrown by {@link AsyncLock} when the queue of a key already holds `maxPending` tasks. */
+export declare class LockQueueFullError extends AsyncboxError {
     constructor(message?: string);
 }
 /** Thrown when a promise is cancelled via `cancel`. */
-export declare class PromiseCancellationError extends Error {
+export declare class PromiseCancellationError extends AsyncboxError {
     constructor(message?: string);
 }
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,uDAAuD;AACvD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,GAAE,MAA4B;CAIlD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":"AAAA,oHAAoH;AACpH,qBAAa,aAAc,SAAQ,KAAK;IACtC,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAuB;CAK3D;AAED,yEAAyE;AACzE,qBAAa,YAAa,SAAQ,aAAa;gBACjC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,MAA+B;CAIpE;AAED,gFAAgF;AAChF,qBAAa,mBAAoB,SAAQ,YAAY;gBACvC,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,gGAAgG;AAChG,qBAAa,gBAAiB,SAAQ,YAAY;gBACpC,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,4FAA4F;AAC5F,qBAAa,kBAAmB,SAAQ,aAAa;gBACvC,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,uDAAuD;AACvD,qBAAa,wBAAyB,SAAQ,aAAa;gBAC7C,OAAO,GAAE,MAA4B;CAIlD"}

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

@@ -1,18 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromiseCancellationError = exports.TimeoutError = void 0;
+exports.PromiseCancellationError = exports.LockQueueFullError = exports.LockTimeoutError = exports.ConditionUnmetError = exports.TimeoutError = exports.AsyncboxError = void 0;
+/** Base class of the built-in typed errors of this package; match by `instanceof` or {@link AsyncboxError.code}. */
+class AsyncboxError extends Error {
+    /** Stable machine-readable identifier, e.g. `ERR_ASYNCBOX_TIMEOUT` */
+    code;
+    constructor(message, code = 'ERR_ASYNCBOX') {
+        super(message);
+        this.name = 'AsyncboxError';
+        this.code = code;
+    }
+}
+exports.AsyncboxError = AsyncboxError;
 /** Error thrown by {@link withTimeout} when the deadline is exceeded. */
-class TimeoutError extends Error {
-    constructor(message) {
-        super(message ?? 'Operation timed out');
+class TimeoutError extends AsyncboxError {
+    constructor(message, code = 'ERR_ASYNCBOX_TIMEOUT') {
+        super(message ?? 'Operation timed out', code);
         this.name = 'TimeoutError';
     }
 }
 exports.TimeoutError = TimeoutError;
+/** Thrown by {@link waitForCondition} when the condition is not met in time. */
+class ConditionUnmetError extends TimeoutError {
+    constructor(message) {
+        super(message ?? 'Condition unmet', 'ERR_ASYNCBOX_CONDITION_UNMET');
+        this.name = 'ConditionUnmetError';
+    }
+}
+exports.ConditionUnmetError = ConditionUnmetError;
+/** Thrown by {@link AsyncLock} when a queue, execution or occupation time limit is exceeded. */
+class LockTimeoutError extends TimeoutError {
+    constructor(message) {
+        super(message ?? 'Lock timed out', 'ERR_ASYNCBOX_LOCK_TIMEOUT');
+        this.name = 'LockTimeoutError';
+    }
+}
+exports.LockTimeoutError = LockTimeoutError;
+/** Thrown by {@link AsyncLock} when the queue of a key already holds `maxPending` tasks. */
+class LockQueueFullError extends AsyncboxError {
+    constructor(message) {
+        super(message ?? 'Too many pending tasks in queue', 'ERR_ASYNCBOX_LOCK_QUEUE_FULL');
+        this.name = 'LockQueueFullError';
+    }
+}
+exports.LockQueueFullError = LockQueueFullError;
 /** Thrown when a promise is cancelled via `cancel`. */
-class PromiseCancellationError extends Error {
+class PromiseCancellationError extends AsyncboxError {
     constructor(message = 'Promise cancelled') {
-        super(message);
+        super(message, 'ERR_ASYNCBOX_CANCELLED');
         this.name = 'PromiseCancellationError';
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":";;;AAAA,yEAAyE;AACzE,MAAa,YAAa,SAAQ,KAAK;IACrC,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,qBAAqB,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AALD,oCAKC;AAED,uDAAuD;AACvD,MAAa,wBAAyB,SAAQ,KAAK;IACjD,YAAY,UAAkB,mBAAmB;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AALD,4DAKC"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":";;;AAAA,oHAAoH;AACpH,MAAa,aAAc,SAAQ,KAAK;IACtC,sEAAsE;IAC7D,IAAI,CAAS;IAEtB,YAAY,OAAe,EAAE,OAAe,cAAc;QACxD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AATD,sCASC;AAED,yEAAyE;AACzE,MAAa,YAAa,SAAQ,aAAa;IAC7C,YAAY,OAAgB,EAAE,OAAe,sBAAsB;QACjE,KAAK,CAAC,OAAO,IAAI,qBAAqB,EAAE,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AALD,oCAKC;AAED,gFAAgF;AAChF,MAAa,mBAAoB,SAAQ,YAAY;IACnD,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,iBAAiB,EAAE,8BAA8B,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AALD,kDAKC;AAED,gGAAgG;AAChG,MAAa,gBAAiB,SAAQ,YAAY;IAChD,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,gBAAgB,EAAE,2BAA2B,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAED,4FAA4F;AAC5F,MAAa,kBAAmB,SAAQ,aAAa;IACnD,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,iCAAiC,EAAE,8BAA8B,CAAC,CAAC;QACpF,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAED,uDAAuD;AACvD,MAAa,wBAAyB,SAAQ,aAAa;IACzD,YAAY,UAAkB,mBAAmB;QAC/C,KAAK,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AALD,4DAKC"}

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

@@ -1,4 +1,4 @@
-export { TimeoutError, PromiseCancellationError } from './errors.js';
+export { AsyncboxError, TimeoutError, ConditionUnmetError, LockTimeoutError, LockQueueFullError, PromiseCancellationError, } from './errors.js';
 export { sleep } from './sleep.js';
 export { withTimeout } from './with-timeout.js';
 export { longSleep } from './long-sleep.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,wBAAwB,EAAC,MAAM,aAAa,CAAC;AACnE,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,KAAK,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAChD,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,YAAY,EAAC,gBAAgB,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;AAChE,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,uBAAuB,GACxB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,KAAK,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAChD,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,YAAY,EAAC,gBAAgB,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;AAChE,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,uBAAuB,GACxB,MAAM,YAAY,CAAC"}

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

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLock = exports.waitForCondition = exports.asyncfilter = exports.asyncmap = exports.retryInterval = exports.retry = exports.longSleep = exports.withTimeout = exports.sleep = exports.PromiseCancellationError = exports.TimeoutError = void 0;
+exports.AsyncLock = exports.waitForCondition = exports.asyncfilter = exports.asyncmap = exports.retryInterval = exports.retry = exports.longSleep = exports.withTimeout = exports.sleep = exports.PromiseCancellationError = exports.LockQueueFullError = exports.LockTimeoutError = exports.ConditionUnmetError = exports.TimeoutError = exports.AsyncboxError = void 0;
 var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "AsyncboxError", { enumerable: true, get: function () { return errors_js_1.AsyncboxError; } });
 Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+Object.defineProperty(exports, "ConditionUnmetError", { enumerable: true, get: function () { return errors_js_1.ConditionUnmetError; } });
+Object.defineProperty(exports, "LockTimeoutError", { enumerable: true, get: function () { return errors_js_1.LockTimeoutError; } });
+Object.defineProperty(exports, "LockQueueFullError", { enumerable: true, get: function () { return errors_js_1.LockQueueFullError; } });
 Object.defineProperty(exports, "PromiseCancellationError", { enumerable: true, get: function () { return errors_js_1.PromiseCancellationError; } });
 var sleep_js_1 = require("./sleep.js");
 Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return sleep_js_1.sleep; } });

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":";;;AAAA,yCAAmE;AAA3D,yGAAA,YAAY,OAAA;AAAE,qHAAA,wBAAwB,OAAA;AAC9C,uCAAiC;AAAzB,iGAAA,KAAK,OAAA;AACb,qDAA8C;AAAtC,8GAAA,WAAW,OAAA;AACnB,iDAA0C;AAAlC,0GAAA,SAAS,OAAA;AACjB,uCAAgD;AAAxC,iGAAA,KAAK,OAAA;AAAE,yGAAA,aAAa,OAAA;AAC5B,6CAAuC;AAA/B,uGAAA,QAAQ,OAAA;AAChB,mDAA6C;AAArC,6GAAA,WAAW,OAAA;AACnB,iEAAyD;AAAjD,yHAAA,gBAAgB,OAAA;AACxB,qCAAoC;AAA5B,oGAAA,SAAS,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":";;;AAAA,yCAOqB;AANnB,0GAAA,aAAa,OAAA;AACb,yGAAA,YAAY,OAAA;AACZ,gHAAA,mBAAmB,OAAA;AACnB,6GAAA,gBAAgB,OAAA;AAChB,+GAAA,kBAAkB,OAAA;AAClB,qHAAA,wBAAwB,OAAA;AAE1B,uCAAiC;AAAzB,iGAAA,KAAK,OAAA;AACb,qDAA8C;AAAtC,8GAAA,WAAW,OAAA;AACnB,iDAA0C;AAAlC,0GAAA,SAAS,OAAA;AACjB,uCAAgD;AAAxC,iGAAA,KAAK,OAAA;AAAE,yGAAA,aAAa,OAAA;AAC5B,6CAAuC;AAA/B,uGAAA,QAAQ,OAAA;AAChB,mDAA6C;AAArC,6GAAA,WAAW,OAAA;AACnB,iEAAyD;AAAjD,yHAAA,gBAAgB,OAAA;AACxB,qCAAoC;AAA5B,oGAAA,SAAS,OAAA"}

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

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncLock = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
+const errors_js_1 = require("./errors.js");
 const DEFAULT_MAX_PENDING = 1000;
 // setTimeout fires after 1 ms for anything above this
 const MAX_TIMER_MS = 2 ** 31 - 1;
@@ -104,7 +105,7 @@ class KeyClaim {
             return true;
         }
         if (queue.length >= maxPending) {
-            this.onDenied(new Error(`Too many pending tasks in queue ${this.key}`));
+            this.onDenied(new errors_js_1.LockQueueFullError(`Too many pending tasks in queue ${this.key}`));
         }
         else {
             if (skipQueue) {
@@ -114,7 +115,7 @@ class KeyClaim {
                 queue.push(this.grant);
             }
             if (timeout) {
-                this.queueTimer = setTimeout(() => this.onDenied(new Error(`async-lock timed out in queue ${this.key}`)), timeout);
+                this.queueTimer = setTimeout(() => this.onDenied(new errors_js_1.LockTimeoutError(`async-lock timed out in queue ${this.key}`)), timeout);
             }
         }
         return false;
@@ -223,7 +224,7 @@ class Acquisition {
         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);
+            this.executionTimer = setTimeout(() => this.abort(new errors_js_1.LockTimeoutError(`Maximum execution time is exceeded ${this.keys.join(', ')}`)), maxExecutionTime);
         }
         new Promise((resolve) => resolve(this.task())).then((value) => this.finish({ value }), (error) => this.finish({ error }));
     }
@@ -240,10 +241,10 @@ class Acquisition {
     expire() {
         const keys = this.keys.join(', ');
         if (this.running) {
-            this.settle({ error: new Error(`Maximum occupation time is exceeded while executing ${keys}`) });
+            this.settle({ error: new errors_js_1.LockTimeoutError(`Maximum occupation time is exceeded while executing ${keys}`) });
         }
         else {
-            this.abort(new Error(`Maximum occupation time is exceeded in queue ${keys}`));
+            this.abort(new errors_js_1.LockTimeoutError(`Maximum occupation time is exceeded in queue ${keys}`));
         }
     }
     settle(outcome) {