appium-mac2-driver 4.3.5 → 4.4.0

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

@@ -1,7 +1,6 @@
 import type {If} from './if.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
-import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
@@ -65,21 +64,23 @@ type _ArrayReverse<
 	AfterRestAcc extends UnknownArray = [],
 	Result extends UnknownArray = never,
 > =
-	keyof TArray & `${number}` extends never
-		// Enters this branch, if `TArray` is empty (e.g., `[]`),
-		// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? TArray extends readonly [...infer Rest, infer Last]
-			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
-			: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc] // Add the rest element between the accumulated elements.
-		: TArray extends readonly [(infer First)?, ...infer Rest]
-			? IsOptionalKeyOf<TArray, '0'> extends true
-				? _ArrayReverse<
+	'0' extends keyof TArray
+		// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+		? 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.
+			? TArray extends readonly [unknown, ...unknown[]]
+				? _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
+				: _ArrayReverse<
 					Rest,
 					[First | (If<IsExactOptionalPropertyTypesEnabled, never, undefined>), ...BeforeRestAcc], // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
 					AfterRestAcc,
 					Result | BeforeRestAcc
 				>
-				: _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
-			: never; // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
+			: never // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
+		// Enters this branch, if `TArray` is empty (e.g., `[]`),
+		// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: TArray extends readonly [...infer Rest, infer Last]
+			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
+			: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc]; // Add the rest element between the accumulated elements.
 
 export {};

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

@@ -60,11 +60,11 @@ export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
 }>;
 
 type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
-	? keyof TArray & `${number}` extends never
-		? TArray extends readonly []
+	? '0' extends keyof TArray
+		? Tail
+		: TArray extends readonly []
 			? []
 			: TArray // Happens when `TArray` is a non-tuple array (e.g., `string[]`) or has a leading rest element (e.g., `[...string[], number]`)
-		: Tail
 	: [];
 
 export {};

package/node_modules/type-fest/source/delimiter-case.d.ts

@@ -1,5 +1,5 @@
 import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
 import type {Merge} from './merge.d.ts';
 import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 

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

@@ -161,7 +161,7 @@ type PropertyOf<BaseType, Key extends string, Options extends Required<GetOption
 
 // This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
 /**
-Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
+Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs#get) function.
 
 Use-case: Retrieve a property from deep inside an API response or some other complex object.
 

package/node_modules/type-fest/source/int-closed-range.d.ts

@@ -6,7 +6,7 @@ Generate a union of numbers between a specified start and end (both inclusive),
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
 
-Note: `Start` or `End` must be non-negative and smaller than `999`.
+Note: `Start` and `End` must each be between `-998` and `998`. The maximum is one less than for `IntRange` because the end is incremented internally to make it inclusive. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -23,6 +23,9 @@ type FontSize = IntClosedRange<10, 20>;
 
 type EvenNumber = IntClosedRange<0, 10, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntClosedRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2 | 3
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntClosedRange<0, 100>;`

package/node_modules/type-fest/source/int-range.d.ts

@@ -1,12 +1,16 @@
 import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 
 /**
 Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
 
-Note: `Start` or `End` must be non-negative and smaller than `1000`.
+Note: `Start` and `End` must each be between `-998` and `999`. Negative ranges reach TypeScript's instantiation-depth limit one value earlier, so their supported minimum is one smaller in magnitude than the maximum. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -23,6 +27,9 @@ type FontSize = IntRange<10, 20>;
 
 type EvenNumber = IntRange<0, 11, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
@@ -40,7 +47,41 @@ type Hundreds = IntRange<100, 901, 100>;
 
 @see {@link IntClosedRange}
 */
-export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+export type IntRange<Start extends number, End extends number, Step extends number = 1> =
+	IsNegative<Start> extends true
+		? PrivateNegativeIntRange<Start, End, Step>
+		: PrivateIntRange<Start, End, Step>;
+
+/**
+Removes `StepTuple['length']` elements from the front of `Tuple`, or empties it when it is too short.
+*/
+type DropStep<Tuple extends UnknownArray, StepTuple extends UnknownArray> =
+	Tuple extends [...StepTuple, ...infer Rest extends UnknownArray] ? Rest : [];
+
+/**
+The implementation of `IntRange` for a negative `Start`.
+
+A tuple length can never be negative, so instead of counting up to the value, `Magnitude` counts down from `-Start` and the value is `-Magnitude['length']`. Once `Magnitude` is too short to step again, the range has crossed zero and the rest is delegated to `PrivateIntRange`.
+*/
+type PrivateNegativeIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	// A `Step` below `1` cannot advance the range, so fall back to `1` like `PrivateIntRange` does
+	StepTuple extends UnknownArray = TupleOf<Step> extends [] ? [unknown] : TupleOf<Step>,
+	// How much of the range is left to generate, shortened by `Step` each time, so the range stops at `End`
+	Remaining extends UnknownArray = TupleOf<Subtract<End, Start>>,
+	// The magnitude of the current value, so the value itself is `-Magnitude['length']`
+	Magnitude extends UnknownArray = TupleOf<Absolute<Start>>,
+	Result = never,
+> = Remaining extends []
+	? Result
+	: Magnitude extends [...StepTuple, ...infer NextMagnitude extends UnknownArray]
+		? PrivateNegativeIntRange<Start, End, Step, StepTuple, DropStep<Remaining, StepTuple>, NextMagnitude, Result | ReverseSign<Magnitude['length']>>
+		// Less than a step is left below zero, so `Crossover` is the amount the next step overshoots it by, and counting up can take over from there
+		: StepTuple extends [...Magnitude, ...infer Crossover extends UnknownArray]
+			? Result | ReverseSign<Magnitude['length']> | PrivateIntRange<Crossover['length'], End, Step>
+			: never;
 
 /**
 The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
@@ -54,14 +95,20 @@ type PrivateIntRange<
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
 	List extends unknown[] = TupleOf<Start, never>,
 	EndLengthTuple extends unknown[] = TupleOf<End>,
-> = Gap extends 0
+	// Avoid `GreaterThan<Start, End>` here because the extra type instantiations would make `IntRange<0, 999>` exceed TypeScript's instantiation-depth limit
+	// `TupleOf` represents a negative length as an empty tuple, so a negative `End` must be detected before comparing the tuple lengths
+	// Recursive calls pass `false` because reversal only depends on the initial bounds; the termination checks below still handle reaching or overshooting `End` without repeating this tuple comparison
+	IsReversed extends boolean = IsNegative<End> extends true ? true : List extends [...EndLengthTuple, unknown, ...unknown[]] ? true : false,
+> = IsReversed extends true
+	? never
+	: Gap extends 0
 	// Handle the case that without `Step`
-	? List['length'] extends End // The result of "List[length] === End"
-		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
+		? List['length'] extends End // The result of "List[length] === End"
+			? Exclude<List[number], never> // All unused elements are `never`, so exclude them
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ], EndLengthTuple, false>
 	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
-		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
+		: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
+			? Exclude<List[number], never>
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>], EndLengthTuple, false>;
 
 export {};

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

@@ -1,6 +1,5 @@
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
-import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
 import type {IsExactOptionalPropertyTypesEnabled, IfNotAnyOrNever} from './type.d.ts';
 
@@ -119,26 +118,28 @@ type _CollapseRestElement<
 	BackwardAccumulator extends UnknownArray = [],
 > =
 	TArray extends UnknownArray // For distributing `TArray`
-		? keyof TArray & `${number}` extends never
-			// Enters this branch, if `TArray` is empty (e.g., []),
-			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-			? TArray extends readonly [...infer Rest, infer Last]
-				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
-				: TArray extends readonly []
-					? [...ForwardAccumulator, ...BackwardAccumulator]
-					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
-			: TArray extends readonly [(infer First)?, ...infer Rest]
+		? '0' extends keyof TArray
+			// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+			? TArray extends readonly [(infer First)?, ...infer Rest]
 				? _CollapseRestElement<
 					Rest,
 					[
 						...ForwardAccumulator,
-						'0' extends OptionalKeysOf<TArray>
-							? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-							: First,
+						// 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.
+						TArray extends readonly [unknown, ...unknown[]]
+							? First
+							: If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>, // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
 					],
 					BackwardAccumulator
 				>
 				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+			// Enters this branch, if `TArray` is empty (e.g., []),
+			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+			: TArray extends readonly [...infer Rest, infer Last]
+				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+				: TArray extends readonly []
+					? [...ForwardAccumulator, ...BackwardAccumulator]
+					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
 		: never; // Should never happen
 
 export {};

package/node_modules/type-fest/source/internal/numeric.d.ts

@@ -1,4 +1,3 @@
-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 {IfNotAnyOrNever, IsAnyOrNever} from './type.d.ts';
@@ -69,43 +68,6 @@ type InternalUnionMin<N extends number, T extends UnknownArray = []> =
 		? T['length']
 		: InternalUnionMin<N, [...T, unknown]>;
 
-/**
-Returns the maximum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMax<1 | 3 | 2>;
-//=> 3
-
-type B = UnionMax<number>;
-//=> number
-
-type C = UnionMax<any>;
-//=> any
-
-type D = UnionMax<never>;
-//=> never
-```
-*/
-export type UnionMax<N extends number> =
-	IsAnyOrNever<N> extends true ? N
-		: number extends N ? number
-			: PositiveInfinity extends N ? PositiveInfinity
-				: [N] extends [NegativeInfinity] ? NegativeInfinity
-					: InternalUnionMax<Finite<N>>;
-
-/**
-The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMax<N extends number, T extends UnknownArray = []> =
-	IsNever<N> extends true
-		? T['length']
-		: T['length'] extends N
-			? InternalUnionMax<Exclude<N, T['length']>, T>
-			: InternalUnionMax<N, [...T, unknown]>;
-
 /**
 Returns the number with reversed sign.
 

package/node_modules/type-fest/source/internal/object.d.ts

@@ -7,8 +7,9 @@ import type {IsAny} from '../is-any.d.ts';
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {StringToNumber} from '../string-to-number.d.ts';
+import type {Primitive} from '../primitive.d.ts';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
-import type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
+import type {IfNotAnyOrNever, MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
 import type {ToString} from './string.d.ts';
 
 /**
@@ -274,6 +275,34 @@ export type CollapseLiterals<T> = {} extends T
 		? U
 		: T;
 
+/**
+Returns the base type of a branded type.
+
+@example
+```
+type Brand = {readonly __brand: unique symbol};
+
+type A = UnwrapBrand<string & Brand>;
+//=> string
+
+type B = UnwrapBrand<number & Brand>;
+//=> number
+
+type C = UnwrapBrand<PropertyKey & Brand>;
+//=> PropertyKey
+
+type D = UnwrapBrand<(1 | 200n | 'foo' | 'bar') & Brand>;
+//=> 1 | 200n | 'foo' | 'bar'
+```
+*/
+export type UnwrapBrand<T> = IfNotAnyOrNever<T, {ifNot: _UnwrapBrand<T, Primitive>}>;
+
+type _UnwrapBrand<T, Base> = T extends Primitive
+	? T extends infer U & Pick<T, Exclude<keyof T, KeysOfUnion<Base>>>
+		? U
+		: T
+	: T;
+
 /**
 Normalize keys by including string and number representations wherever applicable.
 

package/node_modules/type-fest/source/is-boolean-literal.d.ts

@@ -0,0 +1,39 @@
+import type {CollapseLiterals, UnwrapBrand} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+@example
+```
+import type {IsBooleanLiteral} from 'type-fest';
+
+type A = IsBooleanLiteral<true>;
+//=> true
+
+type B = IsBooleanLiteral<false>;
+//=> true
+
+type C = IsBooleanLiteral<boolean>;
+//=> false
+
+type D = IsBooleanLiteral<true | false>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsBooleanLiteral<T> = IfNotAnyOrNever<T, {
+	ifNot: _IsBooleanLiteral<CollapseLiterals<UnwrapBrand<T>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsBooleanLiteral<T> = boolean extends T
+	? false
+	: T extends boolean
+		? true
+		: false;
+
+export {};