type HelloWorld = string // expected to be a string

type MyPick<T, K extends keyof T> = { [A in K]: T[A] }

type MyReadonly<T> = { readonly [A in keyof T]: T[A] }

type TupleToObject<T extends readonly (keyof any)[]> = { [A in T[number]]: A }

type First<A extends unknown[]> = A extends [] ? never : A[0]

type First<A extends unknown[]> = A extends [infer B, ...unknown[]] ? B : never

type Length<T extends readonly unknown[]> = T['length']

type MyExclude<T, U> = T extends U ? never : T

type MyAwaited<T> = T extends {then: (onFulfilled: (value: infer A) => unknown) => unknown} ? MyAwaited<A> : T

type If<C extends boolean, T, F> = C extends true ? T : F

type Concat<T extends readonly unknown[], U extends readonly unknown[]> = [...T, ...U]

type Includes<T extends readonly any[], U> = T extends [infer A, ...infer B]
	? (<C>() => C extends A ? 1 : 0) extends (<C>() => C extends U ? 1 : 0) ? true : Includes<B, U>
	: false

type Push<T extends unknown[], U> = [...T, U]

type Unshift<T extends unknown[], U> = [U, ...T]

type MyParameters<T extends (...args: any[]) => unknown> = T extends (...args: infer A) => unknown ? A : never

type MyReturnType<T> = T extends (...args: any[]) => infer A ? A : never

type MyOmit<T, K extends keyof T> = { [A in keyof T as A extends K ? never : A]: T[A] }

type MyReadonly2<T, K extends keyof T = keyof T> =
	& { readonly [A in K]: T[A] }
	& { [A in keyof T as A extends K ? never : A]: T[A] }

type DeepReadonly<T> = { readonly [A in keyof T]: T[A] extends (...args: any[]) => unknown ? T[A] : DeepReadonly<T[A]> }

type TupleToUnion<T extends unknown[]> = T[number]

type Chainable<A = object> = {
	option<B extends string, C>(
		key: B extends keyof A ? never : B,
		value: C,
	): Chainable<{ [D in keyof A as D extends B ? never : D]: A[D] } & { [_ in B]: C }>
	get(): A
}

type Last<A extends unknown[]> = A extends [...unknown[], infer B] ? B : never

type Pop<A extends unknown[]> = A extends [...infer B, unknown] ? B : []

declare function PromiseAll<A extends unknown[]> (
	values: [...A],
): Promise<{ [B in keyof A]: A[B] extends Promise<infer C> | infer C ? C : never }>

type LookUp<A, B> = A extends {type: B} ? A : never

type TrimLeft<A extends string> = A extends `${' ' | '\n' | '\t'}${infer B}` ? TrimLeft<B> : A

type Trim<A extends string> = A extends `${' ' | '\n' | '\t'}${infer B}` | `${infer B}${' ' | '\n' | '\t'}` ? Trim<B> : A

type MyCapitalize<A extends string> = A extends `${infer B}${infer C}` ? `${Uppercase<B>}${C}` : A

type Replace<S extends string, From extends string, To extends string> = From extends '' ? S
	: S extends `${infer A}${From}${infer B}` ? `${A}${To}${B}`
	: S

type ReplaceAll<S extends string, From extends string, To extends string> = From extends '' ? S
	: S extends `${infer A}${From}${infer B}` ? `${A}${To}${ReplaceAll<B, From, To>}`
	: S