appium-mac2-driver 4.3.5 → 4.3.6

package/node_modules/stream-buffers/lib/writable_streambuffer.js

@@ -1,97 +1,72 @@
-var util = require("util"),
-	stream = require("stream"),
-	constants = require("./constants");
-
-// TODO: clear up specs on returning false from a write and emitting a drain event.
-// Does this mean if I return false from a write, I should ignore any write requests between that false return and the drain event?
-var WritableStreamBuffer = module.exports = function(opts) {
-	var that = this;
-
-	stream.Stream.call(this);
-
-	opts = opts || {};
-	var initialSize = opts.initialSize || constants.DEFAULT_INITIAL_SIZE;
-	var incrementAmount = opts.incrementAmount || constants.DEFAULT_INCREMENT_AMOUNT;
-
-	var buffer = new Buffer(initialSize);
-	var size = 0;
-
-	this.writable = true;
-	this.readable = false;
-
-	this.size = function() {
-		return size;
-	};
-
-	this.maxSize = function() {
-		return buffer.length;
-	};
-
-	this.getContents = function(length) {
-		if(!size) return false;
-
-		var data = new Buffer(Math.min(length || size, size));
-		buffer.copy(data, 0, 0, data.length);
-
-		if(data.length < size)
-			buffer.copy(buffer, 0, data.length);
-
-		size -= data.length;
-
-		return data;
-	};
-
-	this.getContentsAsString = function(encoding, length) {
-		if(!size) return false;
-
-		var data = buffer.toString(encoding || "utf8", 0, Math.min(length || size, size));
-		var dataLength = Buffer.byteLength(data);
-
-		if(dataLength < size)
-			buffer.copy(buffer, 0, dataLength);
-
-		size -= dataLength;
-		return data;
-	};
-
-	var increaseBufferIfNecessary = function(incomingDataSize) {
-		if((buffer.length - size) < incomingDataSize) {
-			var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount);
-
-			var newBuffer = new Buffer(buffer.length + (incrementAmount * factor));
-			buffer.copy(newBuffer, 0, 0, size);
-			buffer = newBuffer;
-		}
-	};
-
-	this.write = function(data, encoding, callback) {
-		if(!that.writable) return;
-
-		if(Buffer.isBuffer(data)) {
-			increaseBufferIfNecessary(data.length);
-			data.copy(buffer, size, 0);
-			size += data.length;
-		}
-		else {
-			data = data + "";
-			increaseBufferIfNecessary(Buffer.byteLength(data));
-			buffer.write(data, size, encoding || "utf8");
-			size += Buffer.byteLength(data);
-		}
-		
-		if(typeof callback === "function") { callback() ;}
-	};
-
-	this.end = function() {
-		var args = Array.prototype.slice.apply(arguments);
-		if(args.length) that.write.apply(that, args);
-		that.emit('finish');
-		that.destroy();
-	};
-
-	this.destroySoon = this.destroy = function() {
-		that.writable = false;
-		that.emit("close");
-	};
-};
-util.inherits(WritableStreamBuffer, stream.Stream);
+'use strict';
+
+var util = require('util');
+var stream = require('stream');
+var constants = require('./constants');
+
+var WritableStreamBuffer = module.exports = function(opts) {
+  opts = opts || {};
+  opts.decodeStrings = true;
+
+  stream.Writable.call(this, opts);
+
+  var initialSize = opts.initialSize || constants.DEFAULT_INITIAL_SIZE;
+  var incrementAmount = opts.incrementAmount || constants.DEFAULT_INCREMENT_AMOUNT;
+
+  var buffer = new Buffer(initialSize);
+  var size = 0;
+
+  this.size = function() {
+    return size;
+  };
+
+  this.maxSize = function() {
+    return buffer.length;
+  };
+
+  this.getContents = function(length) {
+    if(!size) return false;
+
+    var data = new Buffer(Math.min(length || size, size));
+    buffer.copy(data, 0, 0, data.length);
+
+    if(data.length < size)
+      buffer.copy(buffer, 0, data.length);
+
+    size -= data.length;
+
+    return data;
+  };
+
+  this.getContentsAsString = function(encoding, length) {
+    if(!size) return false;
+
+    var data = buffer.toString(encoding || 'utf8', 0, Math.min(length || size, size));
+    var dataLength = Buffer.byteLength(data);
+
+    if(dataLength < size)
+      buffer.copy(buffer, 0, dataLength);
+
+    size -= dataLength;
+    return data;
+  };
+
+  var increaseBufferIfNecessary = function(incomingDataSize) {
+    if((buffer.length - size) < incomingDataSize) {
+      var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount);
+
+      var newBuffer = new Buffer(buffer.length + (incrementAmount * factor));
+      buffer.copy(newBuffer, 0, 0, size);
+      buffer = newBuffer;
+    }
+  };
+
+  this._write = function(chunk, encoding, callback) {
+    increaseBufferIfNecessary(chunk.length);
+    chunk.copy(buffer, size, 0);
+    size += chunk.length;
+    callback();
+  };
+};
+
+util.inherits(WritableStreamBuffer, stream.Writable);

package/node_modules/stream-buffers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-buffers",
-  "version": "2.2.0",
+  "version": "3.0.3",
   "description": "Buffer-backed Streams for reading and writing.",
   "keywords": [
     "memory streams",
@@ -12,10 +12,11 @@
   "engines": {
     "node": ">= 0.10.0"
   },
-  "dependencies": {},
   "devDependencies": {
-    "istanbul": "~0.3.2",
-    "vows": ">= 0.5.6"
+    "chai": "^3.4.1",
+    "eslint": "^8.38.0",
+    "istanbul": "^0.4.0",
+    "mocha": "^9.1.2"
   },
   "license": "Unlicense",
   "repository": {
@@ -23,6 +24,7 @@
     "url": "https://github.com/samcday/node-stream-buffer.git"
   },
   "scripts": {
-    "test": "[ -n \"$NO_COVERAGE\" ] && vows --spec || istanbul cover vows -- --spec"
+    "test": "istanbul test _mocha",
+    "lint": "eslint ."
   }
 }

package/node_modules/type-fest/index.d.ts

@@ -99,10 +99,12 @@ export type {LessThan} from './source/less-than.d.ts';
 export type {LessThanOrEqual} from './source/less-than-or-equal.d.ts';
 export type {Sum} from './source/sum.d.ts';
 export type {Subtract} from './source/subtract.d.ts';
+export type {UnionMax} from './source/union-max.d.ts';
 export type {KeyAsString} from './source/key-as-string.d.ts';
 export type {Exact} from './source/exact.d.ts';
 export type {ReadonlyTuple} from './source/readonly-tuple.d.ts';
 export type {OverrideProperties} from './source/override-properties.d.ts';
+export type {RenameKeys} from './source/rename-keys.d.ts';
 export type {OptionalKeysOf} from './source/optional-keys-of.d.ts';
 export type {IsOptionalKeyOf} from './source/is-optional-key-of.d.ts';
 export type {HasOptionalKeys} from './source/has-optional-keys.d.ts';
@@ -127,13 +129,11 @@ export type {UnionToTuple} from './source/union-to-tuple.d.ts';
 export type {IntRange} from './source/int-range.d.ts';
 export type {IntClosedRange} from './source/int-closed-range.d.ts';
 export type {IsEqual} from './source/is-equal.d.ts';
-export type {
-	IsLiteral,
-	IsStringLiteral,
-	IsNumericLiteral,
-	IsBooleanLiteral,
-	IsSymbolLiteral,
-} from './source/is-literal.d.ts';
+export type {IsLiteral} from './source/is-literal.d.ts';
+export type {IsStringLiteral} from './source/is-string-literal.d.ts';
+export type {IsNumericLiteral} from './source/is-numeric-literal.d.ts';
+export type {IsBooleanLiteral} from './source/is-boolean-literal.d.ts';
+export type {IsSymbolLiteral} from './source/is-symbol-literal.d.ts';
 export type {IsAny} from './source/is-any.d.ts';
 export type {IfAny} from './source/if-any.d.ts';
 export type {IsNever} from './source/is-never.d.ts';

package/node_modules/type-fest/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.8.0",
+	"version": "5.10.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -26,6 +26,7 @@
 	},
 	"scripts": {
 		"test:tsc": "node --max-old-space-size=6144 ./node_modules/.bin/tsc",
+		"test:minimum-lib": "node --max-old-space-size=6144 ./node_modules/.bin/tsc -p tsconfig.minimum-lib.json",
 		"test:tsd": "node --max-old-space-size=6144 ./node_modules/.bin/tsd",
 		"test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo --ignores=lint-processors/fixtures/**/*.d.ts '**/*.{js,ts,md}'",
 		"test:linter": "node --test",

package/node_modules/type-fest/readme.md

@@ -29,17 +29,6 @@
 					<sup>An open-source framework that supports any programming language, cloud provider, or deployment automation tool.</sup>
 				</div>
 			</a>
-			<br>
-			<br>
-			<a href="https://circleback.ai?utm_source=sindresorhus&utm_medium=sponsorship&utm_campaign=awesome-list&utm_id=type-fest">
-				<div>
-					<img width="300" src="https://sindresorhus.com/assets/thanks/circleback-logo.png?x" alt="Circleback logo">
-				</div>
-				<b>Get the most out of every conversation.</b>
-				<div>
-					<sup>AI-powered meeting notes, automations, and search. Give AI agents the context they need to get things done.</sup>
-				</div>
-			</a>
 		</p>
 	</div>
 	<br>
@@ -121,6 +110,7 @@ Click the type names for complete docs.
 - [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.
 - [`OverrideProperties`](source/override-properties.d.ts) - Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
+- [`RenameKeys`](source/rename-keys.d.ts) - Rename keys in an object type according to a map of old-to-new names.
 - [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys, while keeping the remaining keys as is.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly one of the given keys and disallows more, while keeping the remaining keys as is.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys, while keeping the remaining keys as is.
@@ -164,7 +154,7 @@ Click the type names for complete docs.
 - [`SetParameterType`](source/set-parameter-type.d.ts) - Create a function that replaces some parameters with the given parameters.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 - [`SimplifyDeep`](source/simplify-deep.d.ts) - Deeply simplifies an object type.
-- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
+- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs#get) function.
 - [`KeyAsString`](source/key-as-string.d.ts) - Get keys of the given type as strings.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.
 - [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
@@ -215,10 +205,10 @@ Click the type names for complete docs.
 
 - [`If`](source/if.d.ts) - An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 - [`IsLiteral`](source/is-literal.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).
-- [`IsStringLiteral`](source/is-literal.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).
-- [`IsNumericLiteral`](source/is-literal.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).
-- [`IsBooleanLiteral`](source/is-literal.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).
-- [`IsSymbolLiteral`](source/is-literal.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).
+- [`IsStringLiteral`](source/is-string-literal.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).
+- [`IsNumericLiteral`](source/is-numeric-literal.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).
+- [`IsBooleanLiteral`](source/is-boolean-literal.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).
+- [`IsSymbolLiteral`](source/is-symbol-literal.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).
 - [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`.
 - [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`.
 - [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`.
@@ -311,6 +301,7 @@ Click the type names for complete docs.
 - [`LessThanOrEqual`](source/less-than-or-equal.d.ts) - Returns a boolean for whether a given number is less than or equal to another number.
 - [`Sum`](source/sum.d.ts) - Returns the sum of two numbers.
 - [`Subtract`](source/subtract.d.ts) - Returns the difference between two numbers.
+- [`UnionMax`](source/union-max.d.ts) - Returns the maximum number in a union of numbers.
 - [`Absolute`](source/absolute.d.ts) - Returns the absolute value of the specified number or bigint.
 - [`StringToNumber`](source/string-to-number.d.ts) - Converts a numeric string to a number.
 

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

@@ -101,10 +101,15 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @category Array
 */
 export type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> =
-	_AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, {
-	ifNot: TArray extends readonly [infer First, ...infer Rest]
+	IfNotAnyOrNever<CollapseRestElement<TArray>, {
+		ifNot: _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
+		ifAny: false;
+		ifNever: false;
+	}>;
+
+// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> =
+	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, recurse further.
@@ -114,8 +119,5 @@ type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllE
 				? _AllExtend<Rest, Type, Options>
 				: false
 		: true;
-	ifAny: false;
-	ifNever: false;
-}>;
 
 export {};

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.