appium-mac2-driver 4.3.5 → 4.4.0

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

@@ -1,272 +1,14 @@
-import type {Primitive} from './primitive.d.ts';
-import type {_Numeric} from './numeric.d.ts';
-import type {CollapseLiterals, IfNotAnyOrNever, IsNotFalse, IsPrimitive} from './internal/index.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
+import type {IsBooleanLiteral} from './is-boolean-literal.d.ts';
+import type {IsSymbolLiteral} from './is-symbol-literal.d.ts';
 import type {IsNever} from './is-never.d.ts';
-import type {TagContainer, UnwrapTagged} from './tagged.d.ts';
-
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-type A = LiteralCheck<1, number>;
-//=> true
-
-type B = LiteralCheck<number, number>;
-//=> false
-
-type C = LiteralCheck<1, string>;
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (
-	IsNever<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
-			: false
-		: false
-);
-
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-type A = LiteralChecks<1, Numeric>;
-//=> true
-
-type B = LiteralChecks<1n, Numeric>;
-//=> true
-
-type C = LiteralChecks<bigint, Numeric>;
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (
-	// Conditional type to force union distribution.
-	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
-	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
-		? LiteralCheck<T, LiteralUnionType>
-		: never
-	>
-);
-
-/**
-Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed string manipulation functions
-	- constraining strings to be a string literal
-	- type utilities, such as when constructing parsers and ASTs
-
-The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
-
-// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
-function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
-	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
-}
-
-const output = capitalize('hello, world!');
-//=> 'Hello, world!'
-```
-
-@example
-```
-// String types with infinite set of possible values return `false`.
-
-import type {IsStringLiteral} from 'type-fest';
-
-type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
-//=> false
-
-type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
-//=> false
-
-// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
-
-type Length<S extends string, Counter extends never[] = []> =
-	IsStringLiteral<S> extends false
-		? number // return `number` for infinite string types
-		: S extends `${string}${infer Tail}`
-			? Length<Tail, [...Counter, never]>
-			: Counter['length'];
-
-type L1 = Length<Lowercase<string>>;
-//=> number
-
-type L2 = Length<`${number}`>;
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsStringLiteral<S> = IfNotAnyOrNever<S, {
-	ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
-	ifAny: false;
-	ifNever: false;
-}>;
-
-export type _IsStringLiteral<S> =
-// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
-// and since `{}` extends index signatures, the result becomes `false`.
-	S extends string
-		? {} extends Record<S, never>
-			? false
-			: true
-		: false;
-
-/**
-Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral, IsStringLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/modules/types/src/boolean-logic/operators/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-	TValue extends string
-		? IsStringLiteral<TEndsWith> extends true
-			? IsStringLiteral<TValue> extends true
-				? TValue extends `${string}${TEndsWith}`
-					? true
-					: false
-				: boolean
-			: boolean
-		: TValue extends number
-			? IsNumericLiteral<TValue> extends true
-				? EndsWith<`${TValue}`, TEndsWith>
-				: false
-			: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-	return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123_456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNumericLiteral<T> = LiteralChecks<T, _Numeric>;
-
-/**
-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).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsBooleanLiteral} from 'type-fest';
-
-const id = 123;
-
-type GetId<AsString extends boolean> =
-	IsBooleanLiteral<AsString> extends true
-		? AsString extends true
-			? `${typeof id}`
-			: typeof id
-		: number | string;
-
-function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
-	return (options?.asString ? `${id}` : id) as GetId<AsString>;
-}
-
-const numberId = getId();
-//=> 123
-
-const stringId = getId({asString: true});
-//=> '123'
-
-declare const runtimeBoolean: boolean;
-const eitherId = getId({asString: runtimeBoolean});
-//=> string | number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
-
-/**
-Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsSymbolLiteral} from 'type-fest';
-
-type Get<Object_ extends Record<symbol, number>, Key extends keyof Object_> =
-	IsSymbolLiteral<Key> extends true
-		? Object_[Key]
-		: number;
-
-function get<Object_ extends Record<symbol, number>, Key extends keyof Object_>(o: Object_, key: Key) {
-	return o[key] as Get<Object_, Key>;
-}
-
-const symbolLiteral = Symbol('literal');
-let symbolValue = Symbol('value1');
-symbolValue = Symbol('value2');
-
-get({[symbolLiteral]: 1} as const, symbolLiteral);
-//=> 1
-
-get({[symbolValue]: 1} as const, symbolValue);
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
-
-/** Helper type for `IsLiteral`. */
-type IsLiteralUnion<T> =
-	| IsStringLiteral<T>
-	| IsNumericLiteral<T>
-	| IsBooleanLiteral<T>
-	| IsSymbolLiteral<T>;
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {CollapseLiterals, UnwrapBrand} from './internal/object.d.ts';
 
 /**
 Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
 @example
 ```
 import type {IsLiteral} from 'type-fest';
@@ -302,16 +44,48 @@ type I = IsLiteral<symbol>;
 type J = IsLiteral<true>;
 //=> true
 
-type K = IsLiteral<boolean>;
+type K = IsLiteral<false>;
+//=> true
+
+type L = IsLiteral<boolean>;
 //=> false
+
+type M = IsLiteral<1 | 'foo' | false>;
+//=> true
+
+type N = IsLiteral<string | number | symbol>;
+//=> false
+
+type O = IsLiteral<1000n | string | true>;
+//=> boolean
 ```
 
 @category Type Guard
 @category Utilities
 */
-export type IsLiteral<T> =
-	IsPrimitive<T> extends true
-		? IsNotFalse<IsLiteralUnion<T>>
-		: false;
+export type IsLiteral<T> = IfNotAnyOrNever<T, {
+	ifNot: _IsLiteral<CollapseLiterals<UnwrapBrand<T>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsLiteral<T> =
+	| (Extract<T, boolean> extends infer Bools
+		// We can't instantiate `IsBooleanLiteral` with `never`,
+		// because that will add an extraneous `false` to the result if there are no booleans.
+		? IsNever<Bools> extends true
+			? never
+			: IsBooleanLiteral<Bools>
+		: never)
+	| (IsLiteralNonBools<Exclude<T, boolean>>);
+
+type IsLiteralNonBools<T> =
+	T extends number | bigint
+		? IsNumericLiteral<T>
+		: T extends string
+			? IsStringLiteral<T>
+			: T extends symbol
+				? IsSymbolLiteral<T>
+				: false;
 
 export {};

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

@@ -0,0 +1,50 @@
+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 `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+@example
+```
+import type {IsNumericLiteral} from 'type-fest';
+
+type A = IsNumericLiteral<0>;
+//=> true
+
+type B = IsNumericLiteral<number>;
+//=> false
+
+type C = IsNumericLiteral<100n>;
+//=> true
+
+type D = IsNumericLiteral<bigint>;
+//=> false
+
+type E = IsNumericLiteral<1 | 2 | 10n | 20n>;
+//=> true
+
+type F = IsNumericLiteral<number | bigint>;
+//=> false
+
+type G = IsNumericLiteral<1 | bigint>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNumericLiteral<T> = IfNotAnyOrNever<T, {
+	ifNot: _IsNumericLiteral<CollapseLiterals<UnwrapBrand<T>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsNumericLiteral<T> = T extends number | bigint
+	? number extends T
+		? false
+		: bigint extends T
+			? false
+			: true
+	: false;
+
+export {};

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

@@ -0,0 +1,72 @@
+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 `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type A = IsStringLiteral<'foo'>;
+//=> true
+
+type B = IsStringLiteral<string>;
+//=> false
+
+// String types with infinite set of possible values return `false`
+type C = IsStringLiteral<`on${string}`>;
+//=> false
+
+type D = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type E = IsStringLiteral<'foo' | 'bar' | 'baz'>;
+//=> true
+
+type F = IsStringLiteral<'sm' | 'md' | 'lg' | `${number}px`>;
+//=> boolean
+```
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type StringLength<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends true
+		? S extends `${string}${infer Tail}`
+			? StringLength<Tail, [...Counter, never]>
+			: Counter['length']
+		: number; // return `number` for non-literal string types
+
+type L1 = StringLength<'foobar'>;
+//=> 6
+
+type L2 = StringLength<Lowercase<string>>;
+//=> number
+
+type L3 = StringLength<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+	ifNot: _IsStringLiteral<CollapseLiterals<UnwrapBrand<S>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsStringLiteral<S> =
+	// If `S` is an infinite string type (e.g., `on${string}`), `Record<S, never>` produces an index signature,
+	// and since `{}` extends index signatures, the result becomes `false`.
+	S extends string
+		? {} extends Record<S, never>
+			? false
+			: true
+		: false;
+
+export {};

package/node_modules/type-fest/source/is-symbol-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 `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+@example
+```
+import type {IsSymbolLiteral} from 'type-fest';
+
+declare const symbolLiteral1: unique symbol;
+declare const symbolLiteral2: unique symbol;
+
+type A = IsSymbolLiteral<typeof symbolLiteral1>;
+//=> true
+
+type B = IsSymbolLiteral<symbol>;
+//=> false
+
+type C = IsSymbolLiteral<typeof symbolLiteral1 | typeof symbolLiteral2>;
+//=> true
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsSymbolLiteral<T> = IfNotAnyOrNever<T, {
+	ifNot: _IsSymbolLiteral<CollapseLiterals<UnwrapBrand<T>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsSymbolLiteral<T> = T extends symbol
+	? symbol extends T
+		? false
+		: true
+	: false;
+
+export {};

package/node_modules/type-fest/source/is-tuple.d.ts

@@ -81,9 +81,9 @@ type _IsTuple<
 		TArray extends unknown // For distributing `TArray`
 			? number extends TArray['length']
 				? Options['fixedLengthOnly'] extends false
-					? If<IsNever<keyof TArray & `${number}`>,
-						TArray extends readonly [...any, any] ? true : false, // To handle cases where a non-rest element follows a rest element, e.g., `[...number[], number]`
-						true>
+					? '0' extends keyof TArray
+						? true
+						: TArray extends readonly [...any, any] ? true : false // To handle cases where a non-rest element follows a rest element, e.g., `[...number[], number]`
 					: false
 				: true
 			: false

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

@@ -25,15 +25,11 @@ type JsonifyList<T extends UnknownArray> = T extends readonly []
 			? JsonValue[]
 			: Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
 
-type FilterJsonableKeys<T extends object> = {
-	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
-}[keyof T];
-
 /**
 JSON serialize objects (not including arrays) and classes.
 */
 type JsonifyObject<T extends object> = {
-	[Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
+	[Key in keyof T as T[Key] extends NotJsonable ? never : Key]: Jsonify<T[Key]>;
 };
 
 /**

package/node_modules/type-fest/source/merge-deep.d.ts

@@ -18,9 +18,9 @@ type Writable<TArray extends UnknownArray> = {-readonly [Key in keyof TArray]: T
 
 // Using the default `ArrayTail` type causes issues, refer https://github.com/sindresorhus/type-fest/pull/1175/files#r2134694728.
 type ArrayTail<TArray extends UnknownArray> = TArray extends unknown // For distributing `TArray`
-	? keyof TArray & `${number}` extends never
-		? []
-		: Writable<_ArrayTail<TArray>>
+	? '0' extends keyof TArray
+		? Writable<_ArrayTail<TArray>>
+		: []
 	: never; // Should never happen
 
 type SimplifyDeepExcludeArray<T> = SimplifyDeep<T, UnknownArray>;

package/node_modules/type-fest/source/remove-prefix.d.ts

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

package/node_modules/type-fest/source/remove-suffix.d.ts

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