appium-mac2-driver 4.6.0 → 4.6.1

package/node_modules/@appium/support/node_modules/asyncbox/README.md

@@ -0,0 +1,258 @@
+asyncbox
+========
+
+A collection of ES7 async/await utilities. Install via NPM:
+
+```
+npm install asyncbox
+```
+
+Published as both ESM and CommonJS, so `import {sleep} from 'asyncbox'` and `const {sleep} = require('asyncbox')` both work.
+
+Then, behold!
+
+### Sleep
+
+An async/await version of setTimeout
+
+```js
+import { sleep } from 'asyncbox';
+
+async function myFn () {
+    // do some stuff
+    await sleep(1000); // wait one second
+    // do some other stuff
+};
+```
+
+### withTimeout
+
+Race a promise against a deadline. If the promise settles first, its result is returned; if the deadline passes first, the call rejects. By default that rejection is a `TimeoutError` whose message includes how long you waited; you can pass a non-empty string for a custom `TimeoutError` message, or an `Error` instance to reject with that exact value. Omitted or other falsy third arguments (except a real `Error`) use the default timeout message.
+
+`withTimeout` only stops *waiting* on the promise: the underlying async work keeps running (there is no built-in cancellation). Aborting a `fetch`, clearing timers, or tearing down other resources is the caller’s responsibility if you need that behavior.
+
+```js
+import { withTimeout, TimeoutError } from 'asyncbox';
+
+// default: TimeoutError, message includes timeoutMs
+await withTimeout(fetch('/slow').then((r) => r.json()), 5000);
+
+// custom TimeoutError message
+await withTimeout(slowWork(), 10_000, 'slowWork exceeded 10s');
+
+// reject with a specific error you constructed (same object on timeout)
+const err = new MyAppError('upstream did not respond');
+await withTimeout(slowWork(), 5000, err);
+```
+
+Cancelling an in-flight `fetch` when the timeout wins:
+
+```js
+import { withTimeout, TimeoutError } from 'asyncbox';
+
+async function fetchJsonWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const body = fetch(url, { signal: controller.signal }).then((r) => r.json());
+  try {
+    return await withTimeout(body, timeoutMs);
+  } catch (err) {
+    if (err instanceof TimeoutError) {
+      controller.abort();
+    }
+    throw err;
+  }
+}
+```
+
+### Long Sleep
+
+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`:
+
+```js
+import { longSleep } from 'asyncbox';
+
+async function myFn () {
+  await longSleep(10 * 60 * 1000); // wait for 10 mins
+  await longSleep(5000, {thresholdMs: 10000}); // wait for 5s. Anything below the thresholdMs will use a single sleep
+  await longSleep(5000, {intervalMs: 500}); // check the clock every 500ms to see if waiting should stop
+}
+```
+
+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.
+
+```js
+function progressCb({elapsedMs, timeLeft, progress}) {
+  console.log(`We are {progress * 100}% complete waiting`);
+}
+await longSleep(10 * 60 * 1000, {progressCb});
+```
+
+### Retry
+
+An async/await way of running a method until it doesn't throw an error
+
+```js
+import { sleep, retry } from 'asyncbox';
+
+async function flakeyFunction (val1, val2) {
+    if (val1 < 10) {
+        throw new Error("this is a flakey value");
+    }
+    await sleep(1000);
+    return val1 + val2;
+}
+
+async function myFn () {
+    let randVals = [Math.random() * 100, Math.random() * 100];
+
+    // run flakeyFunction up to 3 times until it succeeds.
+    // if it doesn't, we'll get the error thrown in this context
+    let randSum = await retry(3, flakeyFunction, ...randVals);
+}
+```
+
+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:
+
+```js
+await retryInterval(3, 1500, expensiveFunction, ...args);
+```
+
+### Filter/Map
+
+Filter and map are pretty handy concepts, and now you can write filter and map
+functions that execute asynchronously!
+
+```js
+import { asyncmap, asyncfilter } from 'asyncbox';
+```
+
+Then in your async functions, you can do:
+
+```js
+const items = [1, 2, 3, 4];
+const slowSquare = async (n) => { await sleep(5); return n * n; };
+let newItems = await asyncmap(items, slowSquare);
+console.log(newItems);  // [1, 4, 9, 16];
+
+const slowEven = async (n) => { await sleep(5); return n % 2 === 0; };
+newItems = await asyncfilter(items, slowEven);
+console.log(newItems); // [2, 4];
+```
+
+By default, `asyncmap` and `asyncfilter` run their operations in parallel, but you
+can set the third argument to `false` to enforce sequential execution, or set a custom
+concurrency pool limit using `{concurrency: <number>}`:
+
+```js
+const items = [1, 2, 3, 4];
+const slowSquare = async (n) => { await sleep(5); return n * n; };
+// this will run sequentially (~20ms)
+const newItemsSeq = await asyncmap(items, slowSquare, false);
+// this will handle 2 items at a time (~10ms)
+const newItemsMaxTwo = await asyncmap(items, slowSquare, {concurrency: 2});
+```
+
+### waitForCondition
+
+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 }`
+
+```js
+// define your own condition
+function condFn () { return Math.random()*1000 > 995; }
+
+// with default params
+await waitForCondition(condFn);
+
+// with options
+await waitForCondition(condFn, {
+  waitMs: 300000,
+  intervalMs: 10000
+});
+
+// pass a logger to get extra debug info
+await waitForCondition(condFn, {
+  waitMs: 300000,
+  intervalMs: 10000
+  logger: myLogger // expects a debug method
+});
+
+// pass an error string to get that message in the resulting exception
+try {
+  await waitForCondition(condFn, {
+    error: 'Unable to satisfy condition'
+  });
+} catch (err) {
+  // err.message === 'Unable to satisfy condition'
+}
+
+// pass an error instance to be thrown
+const error = new Error('Unable to satisfy condition');
+try {
+  await waitForCondition(condFn, {
+    error: error
+  });
+} catch (err) {
+  // err === error
+}
+```
+
+### AsyncLock
+
+A promise-based mutex keyed by string, derived from the unmaintained
+[async-lock](https://github.com/rogierschouten/async-lock) (MIT). Tasks with the
+same key run one at a time in FIFO order; different keys run concurrently.
+
+Differences from `async-lock`: promises only (no callbacks, custom `Promise`
+or domain support), and each task runs in the `AsyncLocalStorage` context of
+its own `acquire` caller instead of the previous lock holder's one, so no
+`AsyncResource.bind` is needed. A task that outlives `maxExecutionTime` can no
+longer release the lock a second time, and queued tasks that time out are
+removed from the queue.
+
+```js
+import {AsyncLock} from 'asyncbox';
+
+const lock = new AsyncLock({maxPending: 10});
+
+const result = await lock.acquire('key', async () => {
+  // runs exclusively for 'key'
+  return 42;
+});
+
+// several keys are held together; they are acquired in sorted order, so overlapping calls cannot deadlock
+await lock.acquire(['key1', 'key2'], () => {});
+
+// per-call options: timeout, maxOccupationTime, maxExecutionTime, maxPending, skipQueue
+await lock.acquire('key', () => {}, {timeout: 5000, skipQueue: true});
+
+lock.getQueueLength('key'); // tasks waiting for the key (the running one is not counted)
+lock.isBusy('key'); // running or pending tasks for the key
+lock.isBusy(); // any key
+```
+
+Options can be passed to the constructor and overridden per `acquire` call.
+Times are in ms, up to 2147483647, and `0` means no limit.
+
+- `timeout` (default `0`) - max wait in the queue (for all the keys of a multi-key call together) before the task is rejected and dropped
+- `maxOccupationTime` (default `0`) - max time from `acquire` to completion, queue wait included; one budget is shared by all keys of a multi-key call
+- `maxExecutionTime` (default `0`) - max time the task may run while holding the lock; the lock is released when exceeded (for a multi-key call, it counts from when all keys are held and releases all of them)
+- `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
+
+### Run the tests
+
+```
+npm test
+```

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncfilter.d.ts

@@ -0,0 +1,9 @@
+import type { MapFilterOptions } from './types.js';
+/**
+ * Similar to `Array.prototype.filter`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to filter
+ * @param filter - The function to test each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+export declare function asyncfilter<T>(coll: T[], filter: (value: T) => boolean | Promise<boolean>, options?: MapFilterOptions): Promise<T[]>;
+//# sourceMappingURL=asyncfilter.d.ts.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncfilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncfilter.d.ts","sourceRoot":"","sources":["../../../lib/asyncfilter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAChD,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAwBd"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncfilter.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncfilter = asyncfilter;
+const limit_function_js_1 = require("./limit-function.js");
+/**
+ * Similar to `Array.prototype.filter`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to filter
+ * @param filter - The function to test each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+async function asyncfilter(coll, filter, options = true) {
+    if (options === null) {
+        throw new Error('Options cannot be null');
+    }
+    // limitFunction requires the filter to always return a promise
+    const filterAsync = async (value) => filter(value);
+    if (options === false) {
+        return coll.reduce(async (accP, item) => {
+            const acc = await accP;
+            if (await filterAsync(item)) {
+                acc.push(item);
+            }
+            return acc;
+        }, Promise.resolve([]));
+    }
+    const adjustedFilter = options === true ? filterAsync : (await (0, limit_function_js_1.getLimitFunction)())(filterAsync, { concurrency: options.concurrency });
+    const bools = await Promise.all(coll.map(adjustedFilter));
+    return coll.reduce((acc, item, i) => {
+        if (bools[i]) {
+            acc.push(item);
+        }
+        return acc;
+    }, []);
+}
+//# sourceMappingURL=asyncfilter.js.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncfilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncfilter.js","sourceRoot":"","sources":["../../../lib/asyncfilter.ts"],"names":[],"mappings":";;AASA,kCA4BC;AArCD,2DAAqD;AAGrD;;;;;GAKG;AACI,KAAK,UAAU,WAAW,CAC/B,IAAS,EACT,MAAgD,EAChD,UAA4B,IAAI;IAEhC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IACD,+DAA+D;IAC/D,MAAM,WAAW,GAAG,KAAK,EAAE,KAAQ,EAAoB,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxE,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,MAAM,CAAe,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;YACpD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC;YACvB,IAAI,MAAM,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjB,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,cAAc,GAClB,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,IAAA,oCAAgB,GAAE,CAAC,CAAC,WAAW,EAAE,EAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAC,CAAC,CAAC;IAC/G,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;IAC1D,OAAO,IAAI,CAAC,MAAM,CAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE;QACvC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACb,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncmap.d.ts

@@ -0,0 +1,9 @@
+import type { MapFilterOptions } from './types.js';
+/**
+ * Similar to `Array.prototype.map`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to map over
+ * @param mapper - The function to apply to each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+export declare function asyncmap<T, R>(coll: T[], mapper: (value: T) => R | Promise<R>, options?: MapFilterOptions): Promise<R[]>;
+//# sourceMappingURL=asyncmap.d.ts.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncmap.d.ts","sourceRoot":"","sources":["../../../lib/asyncmap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAed"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncmap.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncmap = asyncmap;
+const limit_function_js_1 = require("./limit-function.js");
+/**
+ * Similar to `Array.prototype.map`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to map over
+ * @param mapper - The function to apply to each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+async function asyncmap(coll, mapper, options = true) {
+    if (options === null) {
+        throw new Error('Options cannot be null');
+    }
+    // limitFunction requires the mapper to always return a promise
+    const mapperAsync = async (value) => mapper(value);
+    if (options === false) {
+        return coll.reduce(async (acc, item) => [...(await acc), await mapperAsync(item)], Promise.resolve([]));
+    }
+    const adjustedMapper = options === true ? mapperAsync : (await (0, limit_function_js_1.getLimitFunction)())(mapperAsync, { concurrency: options.concurrency });
+    return Promise.all(coll.map(adjustedMapper));
+}
+//# sourceMappingURL=asyncmap.js.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/asyncmap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncmap.js","sourceRoot":"","sources":["../../../lib/asyncmap.ts"],"names":[],"mappings":";;AASA,4BAmBC;AA5BD,2DAAqD;AAGrD;;;;;GAKG;AACI,KAAK,UAAU,QAAQ,CAC5B,IAAS,EACT,MAAoC,EACpC,UAA4B,IAAI;IAEhC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IACD,+DAA+D;IAC/D,MAAM,WAAW,GAAG,KAAK,EAAE,KAAQ,EAAc,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAClE,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,MAAM,CAChB,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC,EAC9D,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CACpB,CAAC;IACJ,CAAC;IACD,MAAM,cAAc,GAClB,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,IAAA,oCAAgB,GAAE,CAAC,CAAC,WAAW,EAAE,EAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAC,CAAC,CAAC;IAC/G,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;AAC/C,CAAC"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/errors.d.ts

@@ -0,0 +1,9 @@
+/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+/** Thrown when a promise is cancelled via `cancel`. */
+export declare class PromiseCancellationError extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +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"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseCancellationError = exports.TimeoutError = void 0;
+/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message ?? 'Operation timed out');
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+/** Thrown when a promise is cancelled via `cancel`. */
+class PromiseCancellationError extends Error {
+    constructor(message = 'Promise cancelled') {
+        super(message);
+        this.name = 'PromiseCancellationError';
+    }
+}
+exports.PromiseCancellationError = PromiseCancellationError;
+//# sourceMappingURL=errors.js.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/errors.js.map

@@ -0,0 +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"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { TimeoutError, PromiseCancellationError } from './errors.js';
+export { sleep } from './sleep.js';
+export { withTimeout } from './with-timeout.js';
+export { longSleep } from './long-sleep.js';
+export { retry, retryInterval } from './retry.js';
+export { asyncmap } from './asyncmap.js';
+export { asyncfilter } from './asyncfilter.js';
+export { waitForCondition } from './wait-for-condition.js';
+export { AsyncLock } from './lock.js';
+export type { AsyncLockOptions, AcquireOptions } from './lock.js';
+export type { CancellablePromise, Progress, ProgressCallback, LongSleepOptions, MapFilterOptions, SleepArg, SleepOptions, WaitForConditionOptions, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/index.js

@@ -0,0 +1,24 @@
+"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;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+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; } });
+var with_timeout_js_1 = require("./with-timeout.js");
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return with_timeout_js_1.withTimeout; } });
+var long_sleep_js_1 = require("./long-sleep.js");
+Object.defineProperty(exports, "longSleep", { enumerable: true, get: function () { return long_sleep_js_1.longSleep; } });
+var retry_js_1 = require("./retry.js");
+Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return retry_js_1.retry; } });
+Object.defineProperty(exports, "retryInterval", { enumerable: true, get: function () { return retry_js_1.retryInterval; } });
+var asyncmap_js_1 = require("./asyncmap.js");
+Object.defineProperty(exports, "asyncmap", { enumerable: true, get: function () { return asyncmap_js_1.asyncmap; } });
+var asyncfilter_js_1 = require("./asyncfilter.js");
+Object.defineProperty(exports, "asyncfilter", { enumerable: true, get: function () { return asyncfilter_js_1.asyncfilter; } });
+var wait_for_condition_js_1 = require("./wait-for-condition.js");
+Object.defineProperty(exports, "waitForCondition", { enumerable: true, get: function () { return wait_for_condition_js_1.waitForCondition; } });
+var lock_js_1 = require("./lock.js");
+Object.defineProperty(exports, "AsyncLock", { enumerable: true, get: function () { return lock_js_1.AsyncLock; } });
+//# sourceMappingURL=index.js.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/index.js.map

@@ -0,0 +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"}

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/limit-function.d.ts

@@ -0,0 +1,3 @@
+import type { limitFunction } from 'p-limit';
+export declare function getLimitFunction(): Promise<typeof limitFunction>;
+//# sourceMappingURL=limit-function.d.ts.map

package/node_modules/@appium/support/node_modules/asyncbox/build/cjs/lib/limit-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit-function.d.ts","sourceRoot":"","sources":["../../../lib/limit-function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,SAAS,CAAC;AAc3C,wBAAsB,gBAAgB,kCAGrC"}

package/node_modules/@appium/support/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/@appium/support/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/@appium/support/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/@appium/support/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"}