@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -1,89 +0,0 @@
-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/ink/node_modules/type-fest/source/distributed-pick.d.ts

@@ -1,85 +0,0 @@
-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/ink/node_modules/type-fest/source/empty-object.d.ts

@@ -1,46 +0,0 @@
-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/ink/node_modules/type-fest/source/enforce-optional.d.ts

@@ -1,47 +0,0 @@
-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/ink/node_modules/type-fest/source/entries.d.ts

@@ -1,62 +0,0 @@
-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/ink/node_modules/type-fest/source/entry.d.ts

@@ -1,65 +0,0 @@
-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/ink/node_modules/type-fest/source/exact.d.ts

@@ -1,68 +0,0 @@
-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/ink/node_modules/type-fest/source/except.d.ts

@@ -1,108 +0,0 @@
-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/ink/node_modules/type-fest/source/find-global-type.d.ts

@@ -1,64 +0,0 @@
-/**
-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/ink/node_modules/type-fest/source/fixed-length-array.d.ts

@@ -1,43 +0,0 @@
-/**
-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;
-};