dep 1.0.0 → 1.1.0

package/node_modules/boxen/node_modules/type-fest/source/int-range.d.ts

@@ -1,55 +0,0 @@
-import type {BuildTuple} from './internal';
-import type {Subtract} from './subtract';
-
-/**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
-
-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`.
-
-Use-cases:
-1. This can be used to define a set of valid input/output values. for example:
-	```
-	type Age = IntRange<0, 120>;
-	type FontSize = IntRange<10, 20>;
-	type EvenNumber = IntRange<0, 11, 2>; //=> 0 | 2 | 4 | 6 | 8 | 10
-	```
-2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
-
-@example
-```
-import type {IntRange} from 'type-fest';
-
-// Create union type `0 | 1 | ... | 9`
-type ZeroToNine = IntRange<0, 10>;
-
-// Create union type `100 | 200 | 300 | ... | 900`
-type Hundreds = IntRange<100, 901, 100>;
-```
-
-@see IntClosedRange
-*/
-export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
-
-/**
-The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
-*/
-type PrivateIntRange<
-	Start extends number,
-	End extends number,
-	Step extends number,
-	Gap extends number = Subtract<Step, 1>, // The gap between each number, gap = step - 1
-	List extends unknown[] = BuildTuple<Start, never>, // The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
-	EndLengthTuple extends unknown[] = BuildTuple<End>,
-> = 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'] ]>
-	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...BuildTuple<Gap, never>` maybe make `List` too long.
-		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...BuildTuple<Gap, never>]>;

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

@@ -1,126 +0,0 @@
-import type {IfNever} from '../if-never';
-import type {UnknownArray} from '../unknown-array';
-
-/**
-Infer the length of the given array `<T>`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
-*/
-type ArrayLength<T extends readonly unknown[]> = T extends {readonly length: infer L} ? L : never;
-
-/**
-Matches any unknown array or tuple.
-*/
-export type UnknownArrayOrTuple = readonly [...unknown[]];
-// TODO: should unknown-array be updated?
-
-/**
-Extracts the type of the first element of an array or tuple.
-*/
-export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]]
-	? THead
-	: never;
-
-/**
-Extract the element of an array that also works for array union.
-
-Returns `never` if T is not an array.
-
-It creates a type-safe way to access the element type of `unknown` type.
-*/
-export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
-
-/**
-Returns the static, fixed-length portion of the given array, excluding variable-length parts.
-
-@example
-```
-type A = [string, number, boolean, ...string[]];
-type B = StaticPartOfArray<A>;
-//=> [string, number, boolean]
-```
-*/
-export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
-	T extends unknown
-		? number extends T['length'] ?
-			T extends readonly [infer U, ...infer V]
-				? StaticPartOfArray<V, [...Result, U]>
-				: Result
-			: T
-		: never; // Should never happen
-
-/**
-Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
-
-@example
-```
-type A = [string, number, boolean, ...string[]];
-type B = VariablePartOfArray<A>;
-//=> string[]
-```
-*/
-export type VariablePartOfArray<T extends UnknownArray> =
-	T extends unknown
-		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
-			? U
-			: []
-		: never; // Should never happen
-
-/**
-Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
-
-@example
-```
-type ReadonlyArray = readonly string[];
-type NormalArray = string[];
-
-type ReadonlyResult = SetArrayAccess<NormalArray, true>;
-//=> readonly string[]
-
-type NormalResult = SetArrayAccess<ReadonlyArray, false>;
-//=> string[]
-```
-*/
-export type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
-T extends readonly [...infer U] ?
-	IsReadonly extends true
-		? readonly [...U]
-		: [...U]
-	: T;
-
-/**
-Returns whether the given array `T` is readonly.
-*/
-export type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
-
-/**
-An if-else-like type that resolves depending on whether the given array is readonly.
-
-@see {@link IsArrayReadonly}
-
-@example
-```
-import type {ArrayTail} from 'type-fest';
-
-type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-	ArrayTail<TArray> extends infer Tail
-		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-		: never;
-
-type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
-//=> readonly [number, boolean]
-
-type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
-//=> [number, boolean]
-
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
-
-type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
-//=> 'bar'
-```
-*/
-export type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> =
-	IsArrayReadonly<T> extends infer Result
-		? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly
-		: never; // Should never happen

package/node_modules/boxen/node_modules/type-fest/source/internal/characters.d.ts

@@ -1,67 +0,0 @@
-export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
-
-export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-
-export type Whitespace =
-	| '\u{9}' // '\t'
-	| '\u{A}' // '\n'
-	| '\u{B}' // '\v'
-	| '\u{C}' // '\f'
-	| '\u{D}' // '\r'
-	| '\u{20}' // ' '
-	| '\u{85}'
-	| '\u{A0}'
-	| '\u{1680}'
-	| '\u{2000}'
-	| '\u{2001}'
-	| '\u{2002}'
-	| '\u{2003}'
-	| '\u{2004}'
-	| '\u{2005}'
-	| '\u{2006}'
-	| '\u{2007}'
-	| '\u{2008}'
-	| '\u{2009}'
-	| '\u{200A}'
-	| '\u{2028}'
-	| '\u{2029}'
-	| '\u{202F}'
-	| '\u{205F}'
-	| '\u{3000}'
-	| '\u{FEFF}';
-
-export type WordSeparators = '-' | '_' | Whitespace;
-
-export type AsciiPunctuation =
-	| '!'
-	| '"'
-	| '#'
-	| '$'
-	| '%'
-	| '&'
-	| '\''
-	| '('
-	| ')'
-	| '*'
-	| '+'
-	| ','
-	| '-'
-	| '.'
-	| '/'
-	| ':'
-	| ';'
-	| '<'
-	| '='
-	| '>'
-	| '?'
-	| '@'
-	| '['
-	| '\\'
-	| ']'
-	| '^'
-	| '_'
-	| '`'
-	| '{'
-	| '|'
-	| '}'
-	| '~';

package/node_modules/boxen/node_modules/type-fest/source/internal/index.d.ts

@@ -1,8 +0,0 @@
-export type * from './array';
-export type * from './characters';
-export type * from './keys';
-export type * from './numeric';
-export type * from './object';
-export type * from './string';
-export type * from './tuple';
-export type * from './type';

package/node_modules/boxen/node_modules/type-fest/source/internal/keys.d.ts

@@ -1,97 +0,0 @@
-import type {IsAny} from '../is-any';
-import type {IsLiteral} from '../is-literal';
-import type {ToString} from './string';
-
-// Returns `never` if the key or property is not jsonable without testing whether the property is required or optional otherwise return the key.
-type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
-	? never
-	: Type[Key] extends symbol
-		? never
-		/*
-		To prevent a problem where an object with only a `name` property is incorrectly treated as assignable to a function, we first check if the property is a record.
-		This check is necessary, because without it, if we don't verify whether the property is a record, an object with a type of `{name: any}` would return `never` due to its potential assignability to a function.
-		See: https://github.com/sindresorhus/type-fest/issues/657
-		*/
-		: Type[Key] extends Record<string, unknown>
-			? Key
-			: [(...arguments_: any[]) => any] extends [Type[Key]]
-				? never
-				: Key;
-
-/**
-Returns the required keys.
-*/
-export type FilterDefinedKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? Key
-		: undefined extends T[Key]
-			? never
-			: T[Key] extends undefined
-				? never
-				: BaseKeyFilter<T, Key>;
-}[keyof T],
-undefined
->;
-
-/**
-Returns the optional keys.
-*/
-export type FilterOptionalKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? never
-		: undefined extends T[Key]
-			? T[Key] extends undefined
-				? never
-				: BaseKeyFilter<T, Key>
-			: never;
-}[keyof T],
-undefined
->;
-
-/**
-Disallows any of the given keys.
-*/
-export type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
-
-/**
-Utility type to retrieve only literal keys from type.
-*/
-export type LiteralKeyOf<T> = keyof {[K in keyof T as IsLiteral<K> extends true ? K : never]-?: never};
-
-/**
-Get the exact version of the given `Key` in the given object `T`.
-
-Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
-
-@example
-```
-type Object = {
-	0: number;
-	'1': string;
-};
-
-type Key1 = ExactKey<Object, '0'>;
-//=> 0
-type Key2 = ExactKey<Object, 0>;
-//=> 0
-
-type Key3 = ExactKey<Object, '1'>;
-//=> '1'
-type Key4 = ExactKey<Object, 1>;
-//=> '1'
-```
-
-@category Object
-*/
-export type ExactKey<T extends object, Key extends PropertyKey> =
-Key extends keyof T
-	? Key
-	: ToString<Key> extends keyof T
-		? ToString<Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof T
-				? NumberKey
-				: never
-			: never;

package/node_modules/boxen/node_modules/type-fest/source/internal/numeric.d.ts

@@ -1,118 +0,0 @@
-import type {IsNever} from '../is-never';
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {UnknownArray} from '../unknown-array';
-import type {StringToNumber} from './string';
-
-/**
-Returns the absolute value of a given value.
-
-@example
-```
-NumberAbsolute<-1>;
-//=> 1
-
-NumberAbsolute<1>;
-//=> 1
-
-NumberAbsolute<NegativeInfinity>
-//=> PositiveInfinity
-```
-*/
-export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
-
-/**
-Check whether the given type is a number or a number string.
-
-Supports floating-point as a string.
-
-@example
-```
-type A = IsNumberLike<'1'>;
-//=> true
-
-type B = IsNumberLike<'-1.1'>;
-//=> true
-
-type C = IsNumberLike<1>;
-//=> true
-
-type D = IsNumberLike<'a'>;
-//=> false
-*/
-export type IsNumberLike<N> =
-	N extends number ? true
-		:	N extends `${number}`
-			? true
-			: N extends `${number}.${number}`
-				? true
-				: false;
-
-/**
-Returns the minimum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMin<3 | 1 | 2>;
-//=> 1
-```
-*/
-export type UnionMin<N extends number> = InternalUnionMin<N>;
-
-/**
-The actual implementation of `UnionMin`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMin<N extends number, T extends UnknownArray = []> =
-	T['length'] extends N
-		? 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
-```
-*/
-export type UnionMax<N extends number> = InternalUnionMax<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.
-
-@example
-```
-ReverseSign<-1>;
-//=> 1
-
-ReverseSign<1>;
-//=> -1
-
-ReverseSign<NegativeInfinity>
-//=> PositiveInfinity
-
-ReverseSign<PositiveInfinity>
-//=> NegativeInfinity
-```
-*/
-export type ReverseSign<N extends number> =
-	// Handle edge cases
-	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
-	// Handle negative numbers
-	`${N}` extends `-${infer P extends number}` ? P
-		// Handle positive numbers
-		: `-${N}` extends `${infer R extends number}` ? R : never;