@epic-web/workshop-app 5.1.0 → 5.1.2

package/node_modules/type-fest/source/invariant-of.d.ts

@@ -1,78 +0,0 @@
-import type {Opaque} from './opaque';
-
-declare const invariantBrand: unique symbol;
-
-/**
-Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
-
-Use-case:
-- Prevent runtime errors that may occur due to assigning subtypes to supertypes.
-- Improve type signature of object methods like [`Object.keys()` or `Object.entries()`](https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208) by sealing the object type.
-
-@example
-```
-import type {InvariantOf} from 'type-fest';
-
-class Animal {
-	constructor(public name: string){}
-}
-
-class Cat extends Animal {
-	meow() {}
-}
-
-let animalArray: Animal[] = [animal];
-let catArray: Cat[] = [cat];
-
-animalArray = catArray; // Okay if covariant
-animalArray.push(new Animal('another animal')); // Pushed an animal into catArray
-catArray.forEach(c => c.meow()); // Allowed but, error at runtime
-
-let invariantAnimalArray: InvariantOf<Animal>[] = [animal] as InvariantOf<Animal>[];
-let invariantCatArray: InvariantOf<Cat>[] = [cat] as InvariantOf<Cat>[];
-
-invariantAnimalArray = invariantCatArray; // Error: Type 'InvariantOf<Cat>[]' is not assignable to type 'InvariantOf<Animal>[]'.
-```
-
-@example
-```
-import type {InvariantOf} from 'type-fest';
-
-// In covariance (default)
-
-interface FooBar {
-	foo: number;
-	bar: string
-}
-
-interface FooBarBaz extends FooBar {
-	baz: boolean
-}
-
-declare const fooBar: FooBar
-declare const fooBarBaz: FooBarBaz
-
-function keyOfFooBar(fooBar: FooBar) {
-	return Object.keys(fooBar) as (keyof FooBar)[]
-}
-
-keyOfFooBar(fooBar) //=> (keyof FooBar)[]
-keyOfFooBar(fooBarBaz) //=> (keyof FooBar)[] but, (keyof FooBarBaz)[] at runtime
-
-// In invariance
-
-export function invariantOf<Type>(value: Type): InvariantOf<Type> {
-	return value as InvariantOf<Type>;
-}
-
-function keyOfInvariantFooBar(fooBar: InvariantOf<FooBar>) {
-	return Object.keys(fooBar) as (keyof FooBar)[]
-}
-
-keyOfInvariantFooBar(invariantOf(fooBar)); // (keyof FooBar)[]
-keyOfInvariantFooBar(invariantOf(fooBarBaz)); // Error: Argument of type 'InvariantOf<FooBarBaz>' is not assignable to parameter of type 'InvariantOf<FooBar>'.
-```
-
-@category Type
-*/
-export type InvariantOf<Type> = Type & {[invariantBrand]: (_: Type) => Type};

package/node_modules/type-fest/source/is-any.d.ts

@@ -1,29 +0,0 @@
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsAny<T> = 0 extends 1 & T ? true : false;

package/node_modules/type-fest/source/is-equal.d.ts

@@ -1,31 +0,0 @@
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsEqual<A, B> =
-	(<G>() => G extends A ? 1 : 2) extends
-	(<G>() => G extends B ? 1 : 2)
-		? true
-		: false;

package/node_modules/type-fest/source/is-float.d.ts

@@ -1,33 +0,0 @@
-import type {Zero} from './numeric';
-
-/**
-Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
-
-It returns `false` for `Infinity`.
-
-Use-case:
-- If you want to make a conditional branch based on the result of whether a number is a float or not.
-
-@example
-```
-type Float = IsFloat<1.5>;
-//=> true
-
-type IntegerWithDecimal = IsInteger<1.0>;
-//=> false
-
-type NegativeFloat = IsInteger<-1.5>;
-//=> true
-
-type Infinity_ = IsInteger<Infinity>;
-//=> false
-```
-*/
-export type IsFloat<T> =
-T extends number
-	? `${T}` extends `${infer _Sign extends '' | '-'}${number}.${infer Decimal extends number}`
-		? Decimal extends Zero
-			? false
-			: true
-		: false
-	: false;

package/node_modules/type-fest/source/is-integer.d.ts

@@ -1,48 +0,0 @@
-import type {Not} from './internal';
-import type {IsFloat} from './is-float';
-import type {PositiveInfinity, NegativeInfinity} from './numeric';
-
-/**
-Returns a boolean for whether the given number is a integer, like `-5`, `1.0` or `100`.
-
-Like [`Number#IsInteger()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/IsInteger) but for types.
-
-Use-case:
-- If you want to make a conditional branch based on the result of whether a number is a intrger or not.
-
-@example
-```
-type Integer = IsInteger<1>;
-//=> true
-
-type IntegerWithDecimal = IsInteger<1.0>;
-//=> true
-
-type NegativeInteger = IsInteger<-1>;
-//=> true
-
-type Float = IsInteger<1.5>;
-//=> false
-
-// Supports non-decimal numbers
-
-type OctalInteger: IsInteger<0o10>;
-//=> true
-
-type BinaryInteger: IsInteger<0b10>;
-//=> true
-
-type HexadecimalInteger: IsInteger<0x10>;
-//=> true
-```
-*/
-export type IsInteger<T> =
-T extends bigint
-	? true
-	: T extends number
-		? number extends T
-			? false
-			: T extends PositiveInfinity | NegativeInfinity
-				? false
-				: Not<IsFloat<T>>
-		: false;

package/node_modules/type-fest/source/is-literal.d.ts

@@ -1,258 +0,0 @@
-import type {Primitive} from './primitive';
-import type {Numeric} from './numeric';
-import type {IsNotFalse, IsPrimitive} from './internal';
-import type {IsNever} from './is-never';
-
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-LiteralCheck<1, number>
-//=> true
-
-LiteralCheck<number, number>
-//=> false
-
-LiteralCheck<1, string>
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (
-	IsNever<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
-			: false
-		: false
-);
-
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-LiteralChecks<1, Numeric>
-//=> true
-
-LiteralChecks<1n, Numeric>
-//=> true
-
-LiteralChecks<bigint, Numeric>
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (
-	// Conditional type to force union distribution.
-	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
-	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
-		? LiteralCheck<T, LiteralUnionType>
-		: never
-	>
-);
-
-/**
-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).
-
-Useful for:
-	- providing strongly-typed string manipulation functions
-	- constraining strings to be a string literal
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
-
-// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
-function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
-	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
-}
-
-const output = capitalize('hello, world!');
-//=> 'Hello, world!'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsStringLiteral<T> = LiteralCheck<T, string>;
-
-/**
-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).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-	TValue extends string
-		? IsStringLiteral<TEndsWith> extends true
-			? IsStringLiteral<TValue> extends true
-				? TValue extends `${string}${TEndsWith}`
-					? true
-					: false
-				: boolean
-			: boolean
-		: TValue extends number
-			? IsNumericLiteral<TValue> extends true
-				? EndsWith<`${TValue}`, TEndsWith>
-				: false
-			: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-	return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
-
-/**
-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).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsBooleanLiteral} from 'type-fest';
-
-const id = 123;
-
-type GetId<AsString extends boolean> =
-	IsBooleanLiteral<AsString> extends true
-		? AsString extends true
-			? `${typeof id}`
-			: typeof id
-		: number | string;
-
-function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
-	return (options?.asString ? `${id}` : id) as GetId<AsString>;
-}
-
-const numberId = getId();
-//=> 123
-
-const stringId = getId({asString: true});
-//=> '123'
-
-declare const runtimeBoolean: boolean;
-const eitherId = getId({asString: runtimeBoolean});
-//=> number | string
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
-
-/**
-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).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsSymbolLiteral} from 'type-fest';
-
-type Get<Obj extends Record<symbol, number>, Key extends keyof Obj> =
-	IsSymbolLiteral<Key> extends true
-		? Obj[Key]
-		: number;
-
-function get<Obj extends Record<symbol, number>, Key extends keyof Obj>(o: Obj, key: Key) {
-	return o[key] as Get<Obj, Key>;
-}
-
-const symbolLiteral = Symbol('literal');
-const symbolValue: symbol = Symbol('value');
-
-get({[symbolLiteral]: 1} as const, symbolLiteral);
-//=> 1
-
-get({[symbolValue]: 1} as const, symbolValue);
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
-
-/** Helper type for `IsLiteral`. */
-type IsLiteralUnion<T> =
-	| IsStringLiteral<T>
-	| IsNumericLiteral<T>
-	| IsBooleanLiteral<T>
-	| IsSymbolLiteral<T>;
-
-/**
-Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/string-literals/StripLeading.ts
-export type StripLeading<A, B> =
-	A extends string
-		? B extends string
-			? IsLiteral<A> extends true
-				? string extends B ? never : A extends `${B & string}${infer After}` ? After : A
-				: string
-			: A
-		: A;
-
-function stripLeading<Input extends string, Strip extends string>(input: Input, strip: Strip) {
-	return input.replace(`^${strip}`, '') as StripLeading<Input, Strip>;
-}
-
-stripLeading('abc123', 'abc');
-//=> '123'
-
-const str = 'abc123' as string;
-
-stripLeading(str, 'abc');
-//=> string
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsLiteral<T> =
-	IsPrimitive<T> extends true
-		? IsNotFalse<IsLiteralUnion<T>>
-		: false;

package/node_modules/type-fest/source/is-never.d.ts

@@ -1,42 +0,0 @@
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNever<T> = [T] extends [never] ? true : false;

package/node_modules/type-fest/source/is-null.d.ts

@@ -1,20 +0,0 @@
-/**
-Returns a boolean for whether the given type is `null`.
-
-@example
-```
-import type {IsNull} from 'type-fest';
-
-type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
-
-type Example1 = NonNullFallback<null, string>;
-//=> string
-
-type Example2 = NonNullFallback<number, string>;
-//=? number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNull<T> = [T] extends [null] ? true : false;

package/node_modules/type-fest/source/is-unknown.d.ts

@@ -1,52 +0,0 @@
-import type {IsNull} from './is-null';
-
-/**
-Returns a boolean for whether the given type is `unknown`.
-
-@link https://github.com/dsherret/conditional-type-checks/pull/16
-
-Useful in type utilities, such as when dealing with unknown data from API calls.
-
-@example
-```
-import type {IsUnknown} from 'type-fest';
-
-// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts
-type Action<TState, TPayload = void> =
-	IsUnknown<TPayload> extends true
-		? (state: TState) => TState,
-		: (state: TState, payload: TPayload) => TState;
-
-class Store<TState> {
-	constructor(private state: TState) {}
-
-	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
-		this.state = action(this.state, payload);
-		return this.state;
-	}
-
-	// ... other methods
-}
-
-const store = new Store({value: 1});
-declare const someExternalData: unknown;
-
-store.execute(state => ({value: state.value + 1}));
-//=> `TPayload` is `void`
-
-store.execute((state, payload) => ({value: state.value + payload}), 5);
-//=> `TPayload` is `5`
-
-store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
-//=> Errors: `action` is `(state: TState) => TState`
-```
-
-@category Utilities
-*/
-export type IsUnknown<T> = (
-	unknown extends T // `T` can be `unknown` or `any`
-		? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
-			? true
-			: false
-		: false
-);

package/node_modules/type-fest/source/iterable-element.d.ts

@@ -1,54 +0,0 @@
-/**
-Get the element type of an `Iterable`/`AsyncIterable`. For example, an array or a generator.
-
-This can be useful, for example, if you want to get the type that is yielded in a generator function. Often the return type of those functions are not specified.
-
-This type works with both `Iterable`s and `AsyncIterable`s, so it can be use with synchronous and asynchronous generators.
-
-Here is an example of `IterableElement` in action with a generator function:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-function * iAmGenerator() {
-	yield 1;
-	yield 2;
-}
-
-type MeNumber = IterableElement<ReturnType<typeof iAmGenerator>>
-```
-
-And here is an example with an async generator:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-async function * iAmGeneratorAsync() {
-	yield 'hi';
-	yield true;
-}
-
-type MeStringOrBoolean = IterableElement<ReturnType<typeof iAmGeneratorAsync>>
-```
-
-Many types in JavaScript/TypeScript are iterables. This type works on all types that implement those interfaces. For example, `Array`, `Set`, `Map`, `stream.Readable`, etc.
-
-An example with an array of strings:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-type MeString = IterableElement<string[]>
-```
-
-@category Iterable
-*/
-export type IterableElement<TargetIterable> =
-	TargetIterable extends Iterable<infer ElementType> ?
-		ElementType :
-		TargetIterable extends AsyncIterable<infer ElementType> ?
-			ElementType :
-			never;