dep 1.0.0 → 1.1.0

package/node_modules/boxen/node_modules/type-fest/source/tuple-to-object.d.ts

@@ -1,42 +0,0 @@
-import type {IsTuple} from './is-tuple';
-import type {UnknownArray} from './unknown-array';
-import type {IfAny} from './if-any';
-
-/**
-Transforms a tuple into an object, mapping each tuple index to its corresponding type as a key-value pair.
-
-Note: Tuple labels are [lost in the transformation process](https://stackoverflow.com/a/70398429/11719314). For example, `TupleToObject<[x: number, y: number]>` produces `{0: number; 1: number}`, and not `{x: number; y: number}`.
-
-@example
-```
-type Example1 = TupleToObject<[number, string, boolean]>;
-//=> { 0: number; 1: string; 2: boolean }
-
-// Tuples with optional indices
-type Example2 = TupleToObject<[number, string?, boolean?]>;
-//=> { 0: number; 1?: string; 2?: boolean }
-
-// Readonly tuples
-type Example3 = TupleToObject<readonly [number, string?]>;
-//=> { readonly 0: number; readonly 1?: string }
-
-// Non-tuple arrays get transformed into index signatures
-type Example4 = TupleToObject<string[]>;
-//=> { [x: number]: string }
-
-// Tuples with rest elements
-type Example5 = TupleToObject<[number, string, ...boolean[]]>;
-//=> { [x: number]: number | string | boolean; 0: number; 1: string }
-
-// Tuple labels are not preserved
-type Example6 = TupleToObject<[x: number, y: number]>;
-//=> { 0: number; 1: number }
-```
-
-@category Array
-*/
-export type TupleToObject<TArray extends UnknownArray> = IfAny<TArray, any, {
-	[
-	Key in keyof TArray as Key & (`${number}` | (IsTuple<TArray> extends true ? never : number))
-	]: TArray[Key];
-}>;

package/node_modules/boxen/node_modules/type-fest/source/tuple-to-union.d.ts

@@ -1,51 +0,0 @@
-/**
-Convert a tuple/array into a union type of its elements.
-
-This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
-
-@example
-```
-import type {TupleToUnion} from 'type-fest';
-
-const destinations = ['a', 'b', 'c'] as const;
-
-type Destination = TupleToUnion<typeof destinations>;
-//=> 'a' | 'b' | 'c'
-
-function verifyDestination(destination: unknown): destination is Destination {
-	return destinations.includes(destination as any);
-}
-
-type RequestBody = {
-	deliverTo: Destination;
-};
-
-function verifyRequestBody(body: unknown): body is RequestBody {
-	const deliverTo = (body as any).deliverTo;
-	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
-}
-```
-
-Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
-
-@example
-```
-const destinations = ['a', 'b', 'c'] as const;
-
-type Destination = typeof destinations[number];
-//=> 'a' | 'b' | 'c'
-
-const erroringType = new Set(['a', 'b', 'c']);
-
-type ErroringType = typeof erroringType[number];
-//=> Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
-
-const numberBool: { [n: number]: boolean } = { 1: true };
-
-type NumberBool = typeof numberBool[number];
-//=> boolean
-```
-
-@category Array
-*/
-export type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;

package/node_modules/boxen/node_modules/type-fest/source/typed-array.d.ts

@@ -1,17 +0,0 @@
-/**
-Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
-
-@category Array
-*/
-export type TypedArray =
-	| Int8Array
-	| Uint8Array
-	| Uint8ClampedArray
-	| Int16Array
-	| Uint16Array
-	| Int32Array
-	| Uint32Array
-	| Float32Array
-	| Float64Array
-	| BigInt64Array
-	| BigUint64Array;

package/node_modules/boxen/node_modules/type-fest/source/undefined-on-partial-deep.d.ts

@@ -1,80 +0,0 @@
-import type {BuiltIns} from './internal';
-
-/**
-Create a deep version of another type where all optional keys are set to also accept `undefined`.
-
-Note: This is only needed when the [`exactOptionalPropertyTypes`](https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes) TSConfig setting is enabled.
-
-Use-cases:
-- When `exactOptionalPropertyTypes` is enabled, an object like `{a: undefined}` is not assignable to the type `{a?: number}`. You can use `UndefinedOnPartialDeep<{a?: number}>` to make it assignable.
-
-@example
-```
-import type {UndefinedOnPartialDeep} from 'type-fest';
-
-interface Settings {
-	optionA: string;
-	optionB?: number;
-	subOption: {
-		subOptionA: boolean;
-		subOptionB?: boolean;
-	}
-};
-
-const testSettingsA: Settings = {
-	optionA: 'foo',
-	optionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true.
-	subOption: {
-		subOptionA: true,
-		subOptionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true
-	},
-};
-
-const testSettingsB: UndefinedOnPartialDeep<Settings> = {
-	optionA: 'foo',
-	optionB: undefined, // 👉 `optionB` can be set to undefined now.
-	subOption: {
-		subOptionA: true,
-		subOptionB: undefined, // 👉 `subOptionB` can be set to undefined now.
-	},
-};
-```
-*/
-export type UndefinedOnPartialDeep<T> =
-	// Handle built-in type and function
-	T extends BuiltIns | Function
-		? T
-		// Handle tuple and array
-		: T extends readonly unknown[]
-			? UndefinedOnPartialList<T>
-			// Handle map and readonly map
-			: T extends Map<infer K, infer V>
-				? Map<K, UndefinedOnPartialDeep<V>>
-				: T extends ReadonlyMap<infer K, infer V>
-					? ReadonlyMap<K, UndefinedOnPartialDeep<V>>
-					// Handle set and readonly set
-					: T extends Set<infer K>
-						? Set<UndefinedOnPartialDeep<K>>
-						: T extends ReadonlySet<infer K>
-							? ReadonlySet<UndefinedOnPartialDeep<K>>
-							// Handle object
-							: T extends Record<any, any>
-								? {
-									[KeyType in keyof T]: undefined extends T[KeyType]
-										? UndefinedOnPartialDeep<T[KeyType]> | undefined
-										: UndefinedOnPartialDeep<T[KeyType]>
-								}
-								: T; // If T is not builtins / function / array / map / set / object, return T
-
-// Handle tuples and arrays
-type UndefinedOnPartialList<T extends readonly unknown[]> = T extends []
-	? []
-	: T extends [infer F, ...infer R]
-		? [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
-		: T extends readonly [infer F, ...infer R]
-			? readonly [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
-			: T extends Array<infer F>
-				? Array<UndefinedOnPartialDeep<F>>
-				: T extends ReadonlyArray<infer F>
-					? ReadonlyArray<UndefinedOnPartialDeep<F>>
-					: never;

package/node_modules/boxen/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -1,61 +0,0 @@
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-export type UnionToIntersection<Union> = (
-	// `extends unknown` is always going to be the case and is used to convert the
-	// `Union` into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	Union extends unknown
-		// The union type is used as the only argument to a function since the union
-		// of function arguments is an intersection.
-		? (distributedUnion: Union) => void
-		// This won't happen.
-		: never
-		// Infer the `Intersection` type since TypeScript represents the positional
-		// arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void)
-	// The `& Union` is to allow indexing by the resulting type
-	? Intersection & Union
-	: never;

package/node_modules/boxen/node_modules/type-fest/source/union-to-tuple.d.ts

@@ -1,56 +0,0 @@
-import type {IsNever} from './is-never';
-import type {UnionToIntersection} from './union-to-intersection';
-
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-type LastOfUnion<T> =
-UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
-	? R
-	: never;
-
-/**
-Convert a union type into an unordered tuple type of its elements.
-
-"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
-
-This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-type Numbers = 1 | 2 | 3;
-type NumbersTuple = UnionToTuple<Numbers>;
-//=> [1, 2, 3]
-```
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-const pets = {
-  dog: '🐶',
-  cat: '🐱',
-  snake: '🐍',
-};
-
-type Pet = keyof typeof pets;
-//=> 'dog' | 'cat' | 'snake'
-
-const petList = Object.keys(pets) as UnionToTuple<Pet>;
-//=> ['dog', 'cat', 'snake']
-```
-
-@category Array
-*/
-export type UnionToTuple<T, L = LastOfUnion<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<Exclude<T, L>>, L]
-	: [];

package/node_modules/boxen/node_modules/type-fest/source/unknown-array.d.ts

@@ -1,25 +0,0 @@
-/**
-Represents an array with `unknown` value.
-
-Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownArray} from 'type-fest';
-
-type IsArray<T> = T extends UnknownArray ? true : false;
-
-type A = IsArray<['foo']>;
-//=> true
-
-type B = IsArray<readonly number[]>;
-//=> true
-
-type C = IsArray<string>;
-//=> false
-```
-
-@category Type
-@category Array
-*/
-export type UnknownArray = readonly unknown[];

package/node_modules/boxen/node_modules/type-fest/source/unknown-map.d.ts

@@ -1,24 +0,0 @@
-/**
-Represents a map with `unknown` key and value.
-
-Use case: You want a type that all maps can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownMap} from 'type-fest';
-
-type IsMap<T> = T extends UnknownMap ? true : false;
-
-type A = IsMap<Map<string, number>>;
-//=> true
-
-type B = IsMap<ReadonlyMap<number, string>>;
-//=> true
-
-type C = IsMap<string>;
-//=> false
-```
-
-@category Type
-*/
-export type UnknownMap = ReadonlyMap<unknown, unknown>;

package/node_modules/boxen/node_modules/type-fest/source/unknown-record.d.ts

@@ -1,31 +0,0 @@
-/**
-Represents an object with `unknown` value. You probably want this instead of `{}`.
-
-Use case: You have an object whose keys and values are unknown to you.
-
-@example
-```
-import type {UnknownRecord} from 'type-fest';
-
-function toJson(object: UnknownRecord) {
-	return JSON.stringify(object);
-}
-
-toJson({hello: 'world'});
-//=> '{"hello":"world"}'
-
-function isObject(value: unknown): value is UnknownRecord {
-	return typeof value === 'object' && value !== null;
-}
-
-isObject({hello: 'world'});
-//=> true
-
-isObject('hello');
-//=> false
-```
-
-@category Type
-@category Object
-*/
-export type UnknownRecord = Record<PropertyKey, unknown>;

package/node_modules/boxen/node_modules/type-fest/source/unknown-set.d.ts

@@ -1,24 +0,0 @@
-/**
-Represents a set with `unknown` value.
-
-Use case: You want a type that all sets can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownSet} from 'type-fest';
-
-type IsSet<T> = T extends UnknownSet ? true : false;
-
-type A = IsSet<Set<string>>;
-//=> true
-
-type B = IsSet<ReadonlySet<number>>;
-//=> true
-
-type C = IsSet<string>;
-//=> false
-```
-
-@category Type
-*/
-export type UnknownSet = ReadonlySet<unknown>;

package/node_modules/boxen/node_modules/type-fest/source/value-of.d.ts

@@ -1,42 +0,0 @@
-/**
-Create a union of the given object's values, and optionally specify which keys to get the values from.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-	'foo': 1,
-	'bar': 2,
-	'biz': 3
-}
-
-// main.ts
-import type {ValueOf} from 'type-fest';
-import data = require('./data.json');
-
-export function getData(name: string): ValueOf<typeof data> {
-	return data[name];
-}
-
-export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
-	return data[name];
-}
-
-// file.ts
-import {getData, onlyBar} from './main';
-
-getData('foo');
-//=> 1
-
-onlyBar('foo');
-//=> TypeError ...
-
-onlyBar('bar');
-//=> 2
-```
-
-@category Object
-*/
-export type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];

package/node_modules/boxen/node_modules/type-fest/source/words.d.ts

@@ -1,118 +0,0 @@
-import type {
-	ApplyDefaultOptions,
-	IsLowerCase,
-	IsNumeric,
-	IsUpperCase,
-	WordSeparators,
-} from './internal';
-
-type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
-
-type RemoveLastCharacter<
-	Sentence extends string,
-	Character extends string,
-> = Sentence extends `${infer LeftSide}${Character}`
-	? SkipEmptyWord<LeftSide>
-	: never;
-
-/**
-Words options.
-
-@see {@link Words}
-*/
-export type WordsOptions = {
-	/**
-	Split on numeric sequence.
-
-	@default true
-
-	@example
-	```
-	type Example1 = Words<'p2pNetwork', {splitOnNumbers: true}>;
-	//=> ["p", "2", "p", "Network"]
-
-	type Example2 = Words<'p2pNetwork', {splitOnNumbers: false}>;
-	//=> ["p2p", "Network"]
-	```
-	*/
-	splitOnNumbers?: boolean;
-};
-
-export type DefaultWordsOptions = {
-	splitOnNumbers: true;
-};
-
-/**
-Split a string (almost) like Lodash's `_.words()` function.
-
-- Split on each word that begins with a capital letter.
-- Split on each {@link WordSeparators}.
-- Split on numeric sequence.
-
-@example
-```
-import type {Words} from 'type-fest';
-
-type Words0 = Words<'helloWorld'>;
-//=> ['hello', 'World']
-
-type Words1 = Words<'helloWORLD'>;
-//=> ['hello', 'WORLD']
-
-type Words2 = Words<'hello-world'>;
-//=> ['hello', 'world']
-
-type Words3 = Words<'--hello the_world'>;
-//=> ['hello', 'the', 'world']
-
-type Words4 = Words<'lifeIs42'>;
-//=> ['life', 'Is', '42']
-
-type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
-//=> ['p2p', 'Network']
-```
-
-@category Change case
-@category Template literal
-*/
-export type Words<Sentence extends string, Options extends WordsOptions = {}> =
-	WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, DefaultWordsOptions, Options>>;
-
-type WordsImplementation<
-	Sentence extends string,
-	Options extends Required<WordsOptions>,
-	LastCharacter extends string = '',
-	CurrentWord extends string = '',
-> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
-	? FirstCharacter extends WordSeparators
-		// Skip word separator
-		? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>]
-		: LastCharacter extends ''
-			// Fist char of word
-			? WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>
-			// Case change: non-numeric to numeric
-			: [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-				? Options['splitOnNumbers'] extends true
-					// Split on number: push word
-					? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
-					// No split on number: concat word
-					: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-				// Case change: numeric to non-numeric
-				: [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-					? Options['splitOnNumbers'] extends true
-						// Split on number: push word
-						? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
-						// No split on number: concat word
-						: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-					// No case change: concat word
-					: [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-						? WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-					// Case change: lower to upper, push word
-						: [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>]
-							? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
-						// Case change: upper to lower, brings back the last character, push word
-							: [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>]
-								? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>]
-							// No case change: concat word
-								: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-	: [...SkipEmptyWord<CurrentWord>];

package/node_modules/boxen/node_modules/type-fest/source/writable-deep.d.ts

@@ -1,83 +0,0 @@
-import type {BuiltIns, HasMultipleCallSignatures} from './internal';
-
-/**
-Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
-
-This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
-
-@example
-```
-import type {WritableDeep} from 'type-fest';
-
-type Foo = {
-	readonly a: number;
-	readonly b: readonly string[]; // To show that mutability is deeply affected.
-	readonly c: boolean;
-};
-
-const writableDeepFoo: WritableDeep<Foo> = {a: 1, b: ['2'], c: true};
-writableDeepFoo.a = 3;
-writableDeepFoo.b[0] = 'new value';
-writableDeepFoo.b = ['something'];
-```
-
-Note that types containing overloaded functions are not made deeply writable due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
-
-@see Writable
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-export type WritableDeep<T> = T extends BuiltIns
-	? T
-	: T extends (...arguments_: any[]) => unknown
-		? {} extends WritableObjectDeep<T>
-			? T
-			: HasMultipleCallSignatures<T> extends true
-				? T
-				: ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
-		: T extends ReadonlyMap<unknown, unknown>
-			? WritableMapDeep<T>
-			: T extends ReadonlySet<unknown>
-				? WritableSetDeep<T>
-				: T extends readonly unknown[]
-					? WritableArrayDeep<T>
-					: T extends object
-						? WritableObjectDeep<T>
-						: unknown;
-
-/**
-Same as `WritableDeep`, but accepts only `Map`s as inputs. Internal helper for `WritableDeep`.
-*/
-type WritableMapDeep<MapType extends ReadonlyMap<unknown, unknown>> =
-	MapType extends ReadonlyMap<infer KeyType, infer ValueType>
-		? Map<WritableDeep<KeyType>, WritableDeep<ValueType>>
-		: MapType; // Should not heppen
-
-/**
-Same as `WritableDeep`, but accepts only `Set`s as inputs. Internal helper for `WritableDeep`.
-*/
-type WritableSetDeep<SetType extends ReadonlySet<unknown>> =
-	SetType extends ReadonlySet<infer ItemType>
-		? Set<WritableDeep<ItemType>>
-		: SetType; // Should not heppen
-
-/**
-Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper for `WritableDeep`.
-*/
-type WritableObjectDeep<ObjectType extends object> = {
-	-readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>
-};
-
-/**
-Same as `WritableDeep`, but accepts only `Array`s as inputs. Internal helper for `WritableDeep`.
-*/
-type WritableArrayDeep<ArrayType extends readonly unknown[]> =
-	ArrayType extends readonly [] ? []
-		: ArrayType extends readonly [...infer U, infer V] ? [...WritableArrayDeep<U>, WritableDeep<V>]
-			: ArrayType extends readonly [infer U, ...infer V] ? [WritableDeep<U>, ...WritableArrayDeep<V>]
-				: ArrayType extends ReadonlyArray<infer U> ? Array<WritableDeep<U>>
-					: ArrayType extends Array<infer U> ? Array<WritableDeep<U>>
-						: ArrayType;
-