appium-mac2-driver 4.3.5 → 4.4.0

package/node_modules/type-fest/source/rename-keys.d.ts

@@ -0,0 +1,163 @@
+import type {IsLiteral} from './is-literal.d.ts';
+import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SetReadonly} from './set-readonly.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+
+/**
+Rename keys in an object type according to a map of old-to-new names.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type User = {
+	id: string;
+	firstName: string;
+	createdAt: Date;
+};
+
+type Renamed = RenameKeys<User, {firstName: 'first_name'; createdAt: 'created_at'}>;
+//=> {id: string; first_name: string; created_at: Date}
+```
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type SearchInput = {
+	textQuery: string;
+	voiceQuery: Blob;
+	imageQuery: File;
+};
+
+type Normalized = RenameKeys<SearchInput, {textQuery: 'query'; voiceQuery: 'query'; imageQuery: 'query'}>;
+//=> {query: string | Blob | File}
+```
+
+Note: When multiple source keys map to the same target, the target's value type is the union of the contributors' value types. The target is optional only when every contributor is optional, and is `readonly` when any contributor is `readonly`. With `exactOptionalPropertyTypes` disabled, the value type of a mixed-optionality merge also includes `undefined`.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+// All colliding keys are required, so the target is required.
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// All colliding keys are optional, so the target is optional.
+type B = RenameKeys<{a?: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x?: 1 | 2}
+
+// One of the colliding keys is required, so the target is required.
+type C = RenameKeys<{a: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// One of the colliding keys is `readonly`, so the target is `readonly`.
+type D = RenameKeys<{readonly a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {readonly x: 1 | 2}
+```
+
+@example
+```
+// @exactOptionalPropertyTypes: false
+import type {RenameKeys} from 'type-fest';
+
+// With `exactOptionalPropertyTypes` disabled, a mixed-optionality merge includes `undefined`.
+type E = RenameKeys<{a?: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2 | undefined}
+```
+
+Note: A union target distributes, producing one output key per member.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: string}, {a: 'b' | 'c'}>;
+//=> {b: string; c: string}
+```
+
+Note: An entry whose value is not a literal `PropertyKey` (such as `string`) is also ignored, leaving that key's name unchanged.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1}, {a: string}>;
+//=> {a: 1}
+
+type B = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: symbol}>;
+//=> {x: 1; b: 2}
+```
+
+Note: A rename map entry whose key is not a property of the source type is ignored.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; c: 'y'}>;
+//=> {x: 1; b: 2}
+```
+
+@category Object
+*/
+export type RenameKeys<
+	BaseType extends object,
+	RenameMap extends Record<PropertyKey, PropertyKey>,
+> = IfNotAnyOrNever<BaseType, {
+	ifNot: BaseType extends unknown // For distributing `BaseType`
+		? RenameMap extends unknown // For distributing `RenameMap`
+			? RenameOnce<BaseType, NormalizeMap<RenameMap>>
+			: never
+		: never;
+}>;
+
+type RenameOnce<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	RestoreMergedUndefined<BaseType, RenameMap,
+		ApplyReadonly<BaseType, RenameMap,
+			ApplyRequired<BaseType, RenameMap,
+				RenameNaive<BaseType, RenameMap>>>>;
+
+type RenameNaive<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	// Two keys mapping to one target produce a union value and keep only the first key's modifiers.
+	// Like for example, `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}` produces `{x?: 1 | 2}`, taking `a`'s optional.
+	[Key in keyof BaseType as TargetOf<Key, RenameMap>]: Required<BaseType>[Key];
+};
+
+// A merged target kept only one modifier in `RenameNaive`, so re-force these from every contributor.
+type ApplyRequired<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetRequired<Renamed, TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+type ApplyReadonly<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetReadonly<Renamed, TargetOf<ReadonlyKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+// `exactOptionalPropertyTypes` off keeps `undefined` on a target that merged a required and an optional source.
+// Source `{a?: 1; x: 2}` with `{a: 'x'}` gives `{x: 1 | 2 | undefined}`.
+type RestoreMergedUndefined<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Result> =
+	IsExactOptionalPropertyTypesEnabled extends true
+		? Result
+		: {
+			[Key in keyof Result]: Key extends MergedTargets<BaseType, RenameMap>
+				? Result[Key] | undefined
+				: Result[Key];
+		};
+
+type MergedTargets<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	// Targets renamed from both a required and an optional key prefer the required modifier.
+	// Required `b` and optional `a` both rename to `x` in `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}`.
+	TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap>
+	& TargetOf<OptionalKeysOf<OmitIndexSignature<BaseType>>, RenameMap>;
+
+type NormalizeMap<RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	-readonly [Key in keyof RenameMap as true extends IsLiteral<RenameMap[Key]> ? Key : never]-?: RenameMap[Key];
+};
+
+type TargetOf<SourceKey extends PropertyKey, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	SourceKey extends keyof RenameMap ? RenameMap[SourceKey] : SourceKey;
+
+export {};

package/node_modules/type-fest/source/set-required.d.ts

@@ -1,7 +1,6 @@
 import type {Except} from './except.d.ts';
 import type {If} from './if.d.ts';
 import type {HomomorphicPick, IsArrayReadonly} from './internal/index.d.ts';
-import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
@@ -57,19 +56,21 @@ type SetArrayRequired<
 	Counter extends any[] = [],
 	Accumulator extends UnknownArray = [],
 > = TArray extends unknown // For distributing `TArray` when it's a union
-	? keyof TArray & `${number}` extends never
-		// Exit if `TArray` is empty (e.g., []), or
-		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? [...Accumulator, ...TArray]
-		: TArray extends readonly [(infer First)?, ...infer Rest]
-			? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
-				? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+	? '0' extends keyof TArray
+		? TArray extends readonly [(infer First)?, ...infer Rest]
+			// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
+			// Unlike the other array loops, this one has no `any` guard above it, so the check is wrapped in tuples to stop `any` from matching both branches.
+			? [TArray] extends [readonly [unknown, ...unknown[]]]
+				? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
+				: `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
 					? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
 					// If the current element is optional, but it doesn't need to be required,
 					// then we can exit early, since no further elements can now be made required.
 					: [...Accumulator, ...TArray]
-				: SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]>
 			: never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+		// Exit if `TArray` is empty (e.g., []), or
+		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: [...Accumulator, ...TArray]
 	: never; // Should never happen
 
 export {};

package/node_modules/type-fest/source/shared-union-fields-deep.d.ts

@@ -1,4 +1,5 @@
-import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {NonRecursiveType, UnionMin, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {UnionMax} from './union-max.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
@@ -106,11 +107,12 @@ export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOp
 Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
 */
 type SharedObjectUnionFieldsDeep<Union, Options extends Required<SharedUnionFieldsDeepOptions>> =
-	// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-	keyof Union extends infer Keys
+	// Extract the shared keys from the union. Throughout this type, use `Keys` instead of `keyof Union`
+	// to prevent the mapped type from distributing over the union.
+	keyof Union extends infer Keys extends keyof Union
 		? IsNever<Keys> extends false
 			? {
-				[Key in keyof Union]:
+				[Key in Keys]:
 				Union[Key] extends NonRecursiveType
 					? Union[Key]
 					// Remove `undefined` from the union to support optional

package/node_modules/type-fest/source/some-extend.d.ts

@@ -95,10 +95,15 @@ type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
 @category Array
 */
 export type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> =
-	_SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
-
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
-	ifNot: TArray extends readonly [infer First, ...infer Rest]
+	IfNotAnyOrNever<CollapseRestElement<TArray>, {
+		ifNot: _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+		ifAny: false;
+		ifNever: false;
+	}>;
+
+// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> =
+	TArray extends readonly [infer First, ...infer Rest]
 		? IsNever<First> extends true
 			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
 				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
@@ -108,8 +113,5 @@ type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<Som
 				? true
 				: _SomeExtend<Rest, Type, Options>
 		: false;
-	ifAny: false;
-	ifNever: false;
-}>;
 
 export {};

package/node_modules/type-fest/source/split-on-rest-element.d.ts

@@ -1,6 +1,5 @@
 import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
-import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 import type {If} from './if.d.ts';
@@ -84,25 +83,27 @@ export type _SplitOnRestElement<
 	HeadAcc extends UnknownArray = [],
 	TailAcc extends UnknownArray = [],
 > =
-	keyof Array_ & `${number}` extends never
-		// Enters this branch, if `Array_` is empty (e.g., []),
-		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? Array_ extends readonly [...infer Rest, infer Last]
-			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
-			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc] // Add the rest element between the accumulated elements.
-		: Array_ extends readonly [(infer First)?, ...infer Rest]
+	'0' extends keyof Array_
+		// Enters this branch, if `Array_` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+		? Array_ extends readonly [(infer First)?, ...infer Rest]
 			? _SplitOnRestElement<
 				Rest, Options,
 				[
 					...HeadAcc,
-					...IsOptionalKeyOf<Array_, '0'> extends true
-						? Options['preserveOptionalModifier'] extends false
+					// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends Array_`, are several times slower.
+					...Array_ extends readonly [unknown, ...unknown[]]
+						? [First]
+						: Options['preserveOptionalModifier'] extends false
 							? [If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>] // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-							: [First?]
-						: [First],
+							: [First?],
 				],
 				TailAcc
 			> // Accumulate elements that are present before the rest element.
-			: never; // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+			: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+		// Enters this branch, if `Array_` is empty (e.g., []),
+		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: Array_ extends readonly [...infer Rest, infer Last]
+			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
+			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc]; // Add the rest element between the accumulated elements.
 
 export {};

package/node_modules/type-fest/source/split.d.ts

@@ -1,6 +1,6 @@
 import type {And} from './and.d.ts';
 import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**
@@ -64,27 +64,38 @@ export type Split<
 	Delimiter extends string,
 	Options extends SplitOptions = {},
 > =
-	SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
+	_Split<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
 
-type SplitHelper<
+type _Split<
 	S extends string,
 	Delimiter extends string,
 	Options extends Required<SplitOptions>,
-	Accumulator extends string[] = [],
 > = S extends string // For distributing `S`
 	? Delimiter extends string // For distributing `Delimiter`
 		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
 		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
-			? S extends `${infer Head}${Delimiter}${infer Tail}`
-				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
-				: Delimiter extends ''
-					? S extends ''
-						? Accumulator
-						: [...Accumulator, S]
-					: [...Accumulator, S]
+			// The `extends infer` step keeps `SplitOnDelimiter` out of this conditional's tail-recursion chain, so the loop gets the full recursion budget to itself.
+			? SplitOnDelimiter<S, Delimiter> extends infer Result ? Result : never
 			// Otherwise, return `string[]`
 			: string[]
 		: never // Should never happen
 	: never; // Should never happen
 
+/**
+Splits `S` on `Delimiter`.
+
+`S` and `Delimiter` must already be distributed, so that the checks performed by `_Split` do not have to be repeated on every recursion step.
+*/
+type SplitOnDelimiter<
+	S extends string,
+	Delimiter extends string,
+	Accumulator extends string[] = [],
+> = S extends `${infer Head}${Delimiter}${infer Tail}`
+	? SplitOnDelimiter<Tail, Delimiter, [...Accumulator, Head]>
+	: Delimiter extends ''
+		? S extends ''
+			? Accumulator
+			: [...Accumulator, S]
+		: [...Accumulator, S];
+
 export {};

package/node_modules/type-fest/source/string-repeat.d.ts

@@ -1,4 +1,4 @@
-import type {IsNumericLiteral} from './is-literal.d.ts';
+import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
 import type {IsNegative} from './numeric.d.ts';
 import type {DigitCharacter} from './characters.d.ts';
 

package/node_modules/type-fest/source/string-to-array.d.ts

@@ -1,6 +1,6 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever} from './internal/type.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**

package/node_modules/type-fest/source/tsconfig-json.d.ts

@@ -1266,7 +1266,7 @@ export namespace TsConfigJson {
 		exclude?: string[];
 
 		/**
-		Disable infering what types should be added based on filenames in a project.
+		Disable inferring what types should be added based on filenames in a project.
 		*/
 		disableFilenameBasedTypeAcquisition?: boolean;
 	};

package/node_modules/type-fest/source/typed-array.d.ts

@@ -1,6 +1,10 @@
+import type {FindGlobalType} from './find-global-type.d.ts';
+
 /**
 Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
 
+`Float16Array` is included only when it exists in your TypeScript `lib` (`ESNext` or `ES2025` and later).
+
 @category Array
 */
 export type TypedArray =
@@ -11,6 +15,8 @@ export type TypedArray =
 	| Uint16Array
 	| Int32Array
 	| Uint32Array
+	// Looked up through `globalThis` so that a `lib` without `Float16Array` gets `never` here instead of a compile error. The `prototype` type is `Float16Array<ArrayBufferLike>`, matching the other members.
+	| FindGlobalType<'Float16Array'>['prototype']
 	| Float32Array
 	| Float64Array
 	| BigInt64Array

package/node_modules/type-fest/source/union-max.d.ts

@@ -0,0 +1,56 @@
+import type {IsNever} from './is-never.d.ts';
+import type {Finite, NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {IsAnyOrNever} from './internal/type.d.ts';
+
+/**
+Returns the maximum number in a union of numbers.
+
+Use this to derive a maximum retry count or concurrency limit from a fixed set of supported values.
+
+Supports small non-negative integer literals, plus `PositiveInfinity` and `NegativeInfinity`. Negative finite numbers and fractional numbers are not supported. Large integers or unions can exceed TypeScript’s recursion limit.
+
+Returns `number`, `any`, or `never` when given those types.
+
+@example
+```
+import type {UnionMax} from 'type-fest';
+
+const retryCounts = [0, 2, 5] as const;
+type MaximumRetries = UnionMax<typeof retryCounts[number]>;
+//=> 5
+
+const maximumRetries: MaximumRetries = 5;
+```
+
+@example
+```
+import type {PositiveInfinity, UnionMax} from 'type-fest';
+
+type Unlimited = UnionMax<1 | 5 | PositiveInfinity>;
+//=> Infinity
+```
+
+The implementation counts upward using a tuple, removing each matching union member until none remain. Infinity and non-literal inputs are handled before counting.
+
+@see https://github.com/sindresorhus/type-fest/issues/676
+@category Numeric
+*/
+export type UnionMax<NumberUnion extends number> =
+	IsAnyOrNever<NumberUnion> extends true ? NumberUnion
+		: number extends NumberUnion ? number
+			: PositiveInfinity extends NumberUnion ? PositiveInfinity
+				: [NumberUnion] extends [NegativeInfinity] ? NegativeInfinity
+					: InternalUnionMax<Finite<NumberUnion>>;
+
+/**
+The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
+*/
+type InternalUnionMax<NumberUnion extends number, Counter extends UnknownArray = []> =
+	IsNever<NumberUnion> extends true
+		? Counter['length']
+		: Counter['length'] extends NumberUnion
+			? InternalUnionMax<Exclude<NumberUnion, Counter['length']>, Counter>
+			: InternalUnionMax<NumberUnion, [...Counter, unknown]>;
+
+export {};

package/node_modules/type-fest/source/writable.d.ts

@@ -61,8 +61,8 @@ export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
 				: Simplify<
 					// Pick just the keys that are not writable from the base type.
 					Except<BaseType, Keys>
-					// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
-					& {-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+					// Make the specified keys writable.
+					& {-readonly [KeyType in keyof BaseType as KeyType extends Keys ? KeyType : never]: BaseType[KeyType]}
 				>;
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-mac2-driver",
-  "version": "4.3.5",
+  "version": "4.4.0",
   "description": "XCTest-based Appium driver for macOS apps automation",
   "keywords": [
     "XCTest",
@@ -45,9 +45,10 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@appium/strongbox": "2.0.0",
+    "@appium/strongbox": "2.0.1",
     "@colors/colors": "1.6.1",
-    "appium-xcode": "7.1.1",
+    "appium-xcode": "7.2.3",
+    "async-lock": "1.4.1",
     "asyncbox": "6.4.3",
     "axios": "1.20.0",
     "portscanner": "2.2.0",
@@ -81,6 +82,7 @@
     "@appium/strongbox",
     "@colors/colors",
     "appium-xcode",
+    "async-lock",
     "asyncbox",
     "axios",
     "portscanner",