pull-request-split-advisor 3.1.2

package/node_modules/type-fest/source/distributed-omit.d.ts

@@ -0,0 +1,89 @@
+import type {KeysOfUnion} from './keys-of-union';
+
+/**
+Omits keys from a type, distributing the operation over a union.
+
+TypeScript's `Omit` doesn't distribute over unions, leading to the erasure of unique properties from union members when omitting keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Omit. Essentially, using `Omit` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
+
+Example:
+
+```
+type A = {
+	discriminant: 'A';
+	foo: string;
+	a: number;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: string;
+	b: string;
+};
+
+type Union = A | B;
+
+type OmittedUnion = Omit<Union, 'foo'>;
+//=> {discriminant: 'A' | 'B'}
+
+const omittedUnion: OmittedUnion = createOmittedUnion();
+
+if (omittedUnion.discriminant === 'A') {
+	// We would like to narrow `omittedUnion`'s type
+	// to `A` here, but we can't because `Omit`
+	// doesn't distribute over unions.
+
+	omittedUnion.a;
+ 	//=> Error: `a` is not a property of `{discriminant: 'A' | 'B'}`
+}
+```
+
+While `Except` solves this problem, it restricts the keys you can omit to the ones that are present in **ALL** union members, where `DistributedOmit` allows you to omit keys that are present in **ANY** union member.
+
+@example
+```
+type A = {
+	discriminant: 'A';
+	foo: string;
+	a: number;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: string;
+	bar: string;
+	b: string;
+};
+
+type C = {
+	discriminant: 'C';
+	bar: string;
+	c: boolean;
+};
+
+// Notice that `foo` exists in `A` and `B`, but not in `C`, and
+// `bar` exists in `B` and `C`, but not in `A`.
+
+type Union = A | B | C;
+
+type OmittedUnion = DistributedOmit<Union, 'foo' | 'bar'>;
+
+const omittedUnion: OmittedUnion = createOmittedUnion();
+
+if (omittedUnion.discriminant === 'A') {
+	omittedUnion.a;
+ 	//=> OK
+
+	omittedUnion.foo;
+ 	//=> Error: `foo` is not a property of `{discriminant: 'A'; a: string}`
+
+	omittedUnion.bar;
+ 	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`
+}
+```
+
+@category Object
+*/
+export type DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
+	ObjectType extends unknown
+		? Omit<ObjectType, KeyType>
+		: never;

package/node_modules/type-fest/source/distributed-pick.d.ts

@@ -0,0 +1,85 @@
+import type {KeysOfUnion} from './keys-of-union';
+
+/**
+Pick keys from a type, distributing the operation over a union.
+
+TypeScript's `Pick` doesn't distribute over unions, leading to the erasure of unique properties from union members when picking keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Pick. Essentially, using `Pick` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
+
+Example:
+
+```
+type A = {
+	discriminant: 'A';
+	foo: {
+		bar: string;
+	};
+};
+
+type B = {
+	discriminant: 'B';
+	foo: {
+		baz: string;
+	};
+};
+
+type Union = A | B;
+
+type PickedUnion = Pick<Union, 'discriminant' | 'foo'>;
+//=> {discriminant: 'A' | 'B', foo: {bar: string} | {baz: string}}
+
+const pickedUnion: PickedUnion = createPickedUnion();
+
+if (pickedUnion.discriminant === 'A') {
+	// We would like to narrow `pickedUnion`'s type
+	// to `A` here, but we can't because `Pick`
+	// doesn't distribute over unions.
+
+	pickedUnion.foo.bar;
+	//=> Error: Property 'bar' does not exist on type '{bar: string} | {baz: string}'.
+}
+```
+
+@example
+```
+type A = {
+	discriminant: 'A';
+	foo: {
+		bar: string;
+	};
+	extraneous: boolean;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: {
+		baz: string;
+	};
+	extraneous: boolean;
+};
+
+// Notice that `foo.bar` exists in `A` but not in `B`.
+
+type Union = A | B;
+
+type PickedUnion = DistributedPick<Union, 'discriminant' | 'foo'>;
+
+const pickedUnion: PickedUnion = createPickedUnion();
+
+if (pickedUnion.discriminant === 'A') {
+	pickedUnion.foo.bar;
+ 	//=> OK
+
+	pickedUnion.extraneous;
+	//=> Error: Property `extraneous` does not exist on type `Pick<A, 'discriminant' | 'foo'>`.
+
+	pickedUnion.foo.baz;
+	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`.
+}
+```
+
+@category Object
+*/
+export type DistributedPick<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
+	ObjectType extends unknown
+		? Pick<ObjectType, Extract<KeyType, keyof ObjectType>>
+		: never;

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

@@ -0,0 +1,46 @@
+declare const emptyObjectSymbol: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+export type EmptyObject = {[emptyObjectSymbol]?: never};
+
+/**
+Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
+
+@example
+```
+import type {IsEmptyObject} from 'type-fest';
+
+type Pass = IsEmptyObject<{}>; //=> true
+type Fail = IsEmptyObject<[]>; //=> false
+type Fail = IsEmptyObject<null>; //=> false
+```
+
+@see EmptyObject
+@category Object
+*/
+export type IsEmptyObject<T> = T extends EmptyObject ? true : false;

package/node_modules/type-fest/source/enforce-optional.d.ts

@@ -0,0 +1,47 @@
+import type {Simplify} from './simplify';
+
+// Returns `never` if the key is optional otherwise return the key type.
+type RequiredFilter<Type, Key extends keyof Type> = undefined extends Type[Key]
+	? Type[Key] extends undefined
+		? Key
+		: never
+	: Key;
+
+// Returns `never` if the key is required otherwise return the key type.
+type OptionalFilter<Type, Key extends keyof Type> = undefined extends Type[Key]
+	? Type[Key] extends undefined
+		? never
+		: Key
+	: never;
+
+/**
+Enforce optional keys (by adding the `?` operator) for keys that have a union with `undefined`.
+
+@example
+```
+import type {EnforceOptional} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b?: string;
+	c: undefined;
+	d: number | undefined;
+};
+
+type FooBar = EnforceOptional<Foo>;
+// => {
+// 	a: string;
+// 	b?: string;
+// 	c: undefined;
+// 	d?: number;
+// }
+```
+
+@internal
+@category Object
+*/
+export type EnforceOptional<ObjectType> = Simplify<{
+	[Key in keyof ObjectType as RequiredFilter<ObjectType, Key>]: ObjectType[Key]
+} & {
+	[Key in keyof ObjectType as OptionalFilter<ObjectType, Key>]?: Exclude<ObjectType[Key], undefined>
+}>;

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

@@ -0,0 +1,62 @@
+import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
+
+type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
+type MapEntries<BaseType> = Array<MapEntry<BaseType>>;
+type ObjectEntries<BaseType> = Array<ObjectEntry<BaseType>>;
+type SetEntries<BaseType extends Set<unknown>> = Array<SetEntry<BaseType>>;
+
+/**
+Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries.
+
+For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
+
+@see `Entry` if you want to just access the type of a single entry.
+
+@example
+```
+import type {Entries} from 'type-fest';
+
+interface Example {
+	someKey: number;
+}
+
+const manipulatesEntries = (examples: Entries<Example>) => examples.map(example => [
+	// Does some arbitrary processing on the key (with type information available)
+	example[0].toUpperCase(),
+
+	// Does some arbitrary processing on the value (with type information available)
+	example[1].toFixed()
+]);
+
+const example: Example = {someKey: 1};
+const entries = Object.entries(example) as Entries<Example>;
+const output = manipulatesEntries(entries);
+
+// Objects
+const objectExample = {a: 1};
+const objectEntries: Entries<typeof objectExample> = [['a', 1]];
+
+// Arrays
+const arrayExample = ['a', 1];
+const arrayEntries: Entries<typeof arrayExample> = [[0, 'a'], [1, 1]];
+
+// Maps
+const mapExample = new Map([['a', 1]]);
+const mapEntries: Entries<typeof mapExample> = [['a', 1]];
+
+// Sets
+const setExample = new Set(['a', 1]);
+const setEntries: Entries<typeof setExample> = [['a', 'a'], [1, 1]];
+```
+
+@category Object
+@category Map
+@category Set
+@category Array
+*/
+export type Entries<BaseType> =
+	BaseType extends Map<unknown, unknown> ? MapEntries<BaseType>
+		: BaseType extends Set<unknown> ? SetEntries<BaseType>
+			: BaseType extends readonly unknown[] ? ArrayEntries<BaseType>
+				: BaseType extends object ? ObjectEntries<BaseType>
+					: never;

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

@@ -0,0 +1,65 @@
+type MapKey<BaseType> = BaseType extends Map<infer KeyType, unknown> ? KeyType : never;
+type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
+
+export type ArrayEntry<BaseType extends readonly unknown[]> = [number, BaseType[number]];
+export type MapEntry<BaseType> = [MapKey<BaseType>, MapValue<BaseType>];
+export type ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
+export type SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
+
+/**
+Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
+
+For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
+
+@see `Entries` if you want to just access the type of the array of entries (which is the return of the `.entries()` method).
+
+@example
+```
+import type {Entry} from 'type-fest';
+
+interface Example {
+	someKey: number;
+}
+
+const manipulatesEntry = (example: Entry<Example>) => [
+	// Does some arbitrary processing on the key (with type information available)
+	example[0].toUpperCase(),
+
+	// Does some arbitrary processing on the value (with type information available)
+	example[1].toFixed(),
+];
+
+const example: Example = {someKey: 1};
+const entry = Object.entries(example)[0] as Entry<Example>;
+const output = manipulatesEntry(entry);
+
+// Objects
+const objectExample = {a: 1};
+const objectEntry: Entry<typeof objectExample> = ['a', 1];
+
+// Arrays
+const arrayExample = ['a', 1];
+const arrayEntryString: Entry<typeof arrayExample> = [0, 'a'];
+const arrayEntryNumber: Entry<typeof arrayExample> = [1, 1];
+
+// Maps
+const mapExample = new Map([['a', 1]]);
+const mapEntry: Entry<typeof mapExample> = ['a', 1];
+
+// Sets
+const setExample = new Set(['a', 1]);
+const setEntryString: Entry<typeof setExample> = ['a', 'a'];
+const setEntryNumber: Entry<typeof setExample> = [1, 1];
+```
+
+@category Object
+@category Map
+@category Array
+@category Set
+*/
+export type Entry<BaseType> =
+	BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
+		: BaseType extends Set<unknown> ? SetEntry<BaseType>
+			: BaseType extends readonly unknown[] ? ArrayEntry<BaseType>
+				: BaseType extends object ? ObjectEntry<BaseType>
+					: never;

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

@@ -0,0 +1,68 @@
+import type {ArrayElement, ObjectValue} from './internal';
+import type {IsEqual} from './is-equal';
+import type {KeysOfUnion} from './keys-of-union';
+import type {IsUnknown} from './is-unknown';
+import type {Primitive} from './primitive';
+
+/**
+Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
+- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
+- Mark these excess keys as `never`.
+*/
+type ExactObject<ParameterType, InputType> = {[Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>}
+& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+
+/**
+Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
+
+This is useful for function type-guarding to reject arguments with excess properties. Due to the nature of TypeScript, it does not complain if excess properties are provided unless the provided value is an object literal.
+
+*Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/12936) if you want to have this type as a built-in in TypeScript.*
+
+@example
+```
+type OnlyAcceptName = {name: string};
+
+function onlyAcceptName(arguments_: OnlyAcceptName) {}
+
+// TypeScript complains about excess properties when an object literal is provided.
+onlyAcceptName({name: 'name', id: 1});
+//=> `id` is excess
+
+// TypeScript does not complain about excess properties when the provided value is a variable (not an object literal).
+const invalidInput = {name: 'name', id: 1};
+onlyAcceptName(invalidInput); // No errors
+```
+
+Having `Exact` allows TypeScript to reject excess properties.
+
+@example
+```
+import {Exact} from 'type-fest';
+
+type OnlyAcceptName = {name: string};
+
+function onlyAcceptNameImproved<T extends Exact<OnlyAcceptName, T>>(arguments_: T) {}
+
+const invalidInput = {name: 'name', id: 1};
+onlyAcceptNameImproved(invalidInput); // Compilation error
+```
+
+[Read more](https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-defined)
+
+@category Utilities
+*/
+export type Exact<ParameterType, InputType> =
+	// Before distributing, check if the two types are equal and if so, return the parameter type immediately
+	IsEqual<ParameterType, InputType> extends true ? ParameterType
+		// If the parameter is a primitive, return it as is immediately to avoid it being converted to a complex type
+		: ParameterType extends Primitive ? ParameterType
+			// If the parameter is an unknown, return it as is immediately to avoid it being converted to a complex type
+			: IsUnknown<ParameterType> extends true ? unknown
+				// If the parameter is a Function, return it as is because this type is not capable of handling function, leave it to TypeScript
+				: ParameterType extends Function ? ParameterType
+					// Convert union of array to array of union: A[] & B[] => (A & B)[]
+					: ParameterType extends unknown[] ? Array<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+						// In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray.
+						: ParameterType extends readonly unknown[] ? ReadonlyArray<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+							: ExactObject<ParameterType, InputType>;

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

@@ -0,0 +1,108 @@
+import type {ApplyDefaultOptions} from './internal';
+import type {IsEqual} from './is-equal';
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+type DefaultExceptOptions = {
+	requireExactProps: false;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; [x: number]: string; }
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayload = Except<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
+```
+
+@category Object
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
+	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});

package/node_modules/type-fest/source/find-global-type.d.ts

@@ -0,0 +1,64 @@
+/**
+Tries to find the type of a global with the given name.
+
+Limitations: Due to peculiarities with the behavior of `globalThis`, "globally defined" only includes `var` declarations in `declare global` blocks, not `let` or `const` declarations.
+
+@example
+```
+import type {FindGlobalType} from 'type-fest';
+
+declare global {
+	const foo: number; // let and const don't work
+	var bar: string;   // var works
+}
+
+type FooType = FindGlobalType<'foo'>     //=> never (let/const don't work)
+type BarType = FindGlobalType<'bar'>     //=> string
+type OtherType = FindGlobalType<'other'> //=> never (no global named 'other')
+```
+
+@category Utilities
+*/
+export type FindGlobalType<Name extends string> = typeof globalThis extends Record<Name, infer T> ? T : never;
+
+/**
+Tries to find one or more types from their globally-defined constructors.
+
+Use-case: Conditionally referencing DOM types only when the DOM library present.
+
+*Limitations:* Due to peculiarities with the behavior of `globalThis`, "globally defined" has a narrow definition in this case. Declaring a class in a `declare global` block won't work, instead you must declare its type using an interface and declare its constructor as a `var` (*not* `let`/`const`) inside the `declare global` block.
+
+@example
+```
+import type {FindGlobalInstanceType} from 'type-fest';
+
+class Point {
+	constructor(public x: number, public y: number) {}
+}
+
+type PointLike = Point | FindGlobalInstanceType<'DOMPoint'>;
+```
+
+@example
+```
+import type {FindGlobalInstanceType} from 'type-fest';
+
+declare global {
+	// Class syntax won't add the key to `globalThis`
+	class Foo {}
+
+	// interface + constructor style works
+	interface Bar {}
+	var Bar: new () => Bar; // Not let or const
+}
+
+type FindFoo = FindGlobalInstanceType<'Foo'>; // Doesn't work
+type FindBar = FindGlobalInstanceType<'Bar'>; // Works
+```
+
+@category Utilities
+*/
+export type FindGlobalInstanceType<Name extends string> =
+	Name extends string
+		? typeof globalThis extends Record<Name, abstract new (...arguments: any[]) => infer T> ? T : never
+		: never;

package/node_modules/type-fest/source/fixed-length-array.d.ts

@@ -0,0 +1,43 @@
+/**
+Methods to exclude.
+*/
+type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift';
+
+/**
+Create a type that represents an array of the given type and length. The array's length and the `Array` prototype methods that manipulate its length are excluded in the resulting type.
+
+Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similar type built into TypeScript.
+
+Use-cases:
+- Declaring fixed-length tuples or arrays with a large number of items.
+- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
+- Creating an array of coordinates with a static length, for example, length of 3 for a 3D vector.
+
+Note: This type does not prevent out-of-bounds access. Prefer `ReadonlyTuple` unless you need mutability.
+
+@example
+```
+import type {FixedLengthArray} from 'type-fest';
+
+type FencingTeam = FixedLengthArray<string, 3>;
+
+const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
+
+const homeFencingTeam: FencingTeam = ['George', 'John'];
+//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
+
+guestFencingTeam.push('Sam');
+//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
+```
+
+@category Array
+@see ReadonlyTuple
+*/
+export type FixedLengthArray<Element, Length extends number, ArrayPrototype = [Element, ...Element[]]> = Pick<
+ArrayPrototype,
+Exclude<keyof ArrayPrototype, ArrayLengthMutationKeys>
+> & {
+	[index: number]: Element;
+	[Symbol.iterator]: () => IterableIterator<Element>;
+	readonly length: Length;
+};