feat: more sophisticated stdlib definitions

src/main/resources/lib/iterator.d.ts

@@ -0,0 +1,22 @@
+declare interface NormalIterationData<T> {
+	value: T;
+	done: true;
+}
+declare interface DoneIterationData<T> {
+	value: T;
+	done?: false;
+}
+declare type IterationData<T, Return> = NormalIterationData<T> | DoneIterationData<Return>;
+
+declare interface Iterator<T, Return = unknown, Next = unknown> {
+	next(): IterationData<T, Return>;
+	next(val: Next): IterationData<T, Return>;
+	error?(err: unknown): IterationData<T, Return>;
+	return?(val: Return): IterationData<T, Return>;
+}
+declare interface IterableIterator<T, Return = unknown, Next = unknown> extends Iterator<T, Return, Next> {
+	[Symbol.iterator](): this;
+}
+declare interface Iterable<T> {
+	[Symbol.iterator](): Iterator<T>;
+}

src/main/resources/lib/lib.d.ts

@@ -1,10 +1,26 @@
+/// <reference no-default-lib="true"/>
+/// <reference path="./typing.d.ts"/>
+/// <reference path="./iterator.d.ts"/>
+/// <reference path="./values/function.d.ts"/>
+/// <reference path="./values/object.d.ts"/>
+/// <reference path="./values/array.d.ts"/>
+/// <reference path="./values/boolean.d.ts"/>
+/// <reference path="./values/symbol.d.ts"/>
+/// <reference path="./values/string.d.ts"/>
+/// <reference path="./values/number.d.ts"/>
+/// <reference path="./values/regexp.d.ts"/>
+/// <reference path="./async.d.ts"/>
+
 declare function print(...args: any[]): void;
 
-declare type Array = {};
-declare type Boolean = {};
-declare type Function = {};
-declare type IArguments = {};
-declare type Number = {};
-declare type Object = {};
-declare type RegExp = {};
-declare type String = {};
+declare type IArguments = Array<any>;
+
+declare var Array: ArrayConstructor;
+declare var Boolean: BooleanConstructor;
+declare var Function: FunctionConstructor;
+declare var Symbol: SymbolConstructor;
+declare var Number: NumberConstructor;
+declare var Object: ObjectConstructor;
+declare var RegExp: RegExpConstructor;
+declare var String: StringConstructor;
+declare var Promise: PromiseConstructor;

src/main/resources/lib/typing.d.ts

@@ -0,0 +1,9 @@
+declare interface Record<Key, Val> {
+	[key: Key]: Val;
+}
+declare type InstanceType<T> = T extends new (...args: any[]) => infer T ? T : never;
+declare type ReturnType<T> = T extends (...args: any[]) => infer T ? T : never;
+declare type Arguments<T> =
+	T extends (...args: infer T) => any ? T :
+	T extends new (...args: infer T) => any ? T :
+	never;

src/main/resources/lib/values/array.d.ts

@@ -0,0 +1,39 @@
+declare interface Array<T> {
+	length: number;
+	[i: number]: T;
+
+	forEach(this: T[], cb: (val: T, i: number, self: this) => void, self?: any): void;
+	join(this: T[], delim?: string): void;
+
+	push(this: T[], ...elements: T[]): number;
+	pop(this: T[]): T | undefined;
+
+	unshift(this: T[], ...elements: T[]): number;
+	shift(this: T[]): T | undefined;
+
+	concat(this: T[], ...elements: (T | T[])[]): T | undefined;
+	slice(this: T[], start?: number, end?: number): T | undefined;
+	splice(this: T[], start?: number, count?: number): T[];
+	splice(this: T[], start: number | undefined, count: number | undefined, ...elements: T[]): T[];
+
+	map<T2>(this: T[], cb: (val: T, i: number, self: this) => T2, self?: any): T2[];
+	filter(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): T[];
+	some(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): boolean;
+	find(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): T | undefined;
+	indexOf(this: T[], el: T, start?: number): number;
+	lastIndexOf(this: T[], el: T, start?: number): number;
+
+	sort(this: T[], cb?: (a: T, b: T) => number): T[];
+
+	[Symbol.iterator](): IterableIterator<T>;
+}
+declare interface ArrayConstructor {
+	new <T>(len: number): T[];
+	new <T>(...elements: T[]): T[];
+
+	<T>(len: number): T[];
+	<T>(...elements: T[]): T[];
+
+	isArray(val: any): val is any[];
+	// from(val: any): val is any[];
+}

src/main/resources/lib/values/boolean.d.ts

@@ -0,0 +1,8 @@
+declare interface Boolean {
+	valueOf(): boolean;
+	toString(): string;
+}
+declare interface BooleanConstructor {
+	new (val?: unknown): Boolean;
+	(val?: unknown): boolean;
+}

src/main/resources/lib/values/function.d.ts

@@ -0,0 +1,25 @@
+declare interface Function {
+	prototype: unknown;
+
+	valueOf(): this;
+	toString(): string;
+
+	apply<Args extends readonly any[], Ret, Self>(this: (this: Self, ...args: Args) => Ret, self: Self, args: Args): Ret;
+	call<Args extends readonly any[], Ret, Self>(this: (this: Self, ...args: Args) => Ret, self: Self, ...args: Args): Ret;
+	bind<T extends (...args: any[]) => any>(this: T): T;
+	bind<
+		Bound extends readonly any[],
+		Args extends readonly any[],
+		Ret, Self
+	>(this: (this: Self, ...args: [...Bound, ...Args]) => Ret, self: Self, ...bound: Bound): (this: void, ...args: Args) => Ret;
+}
+declare interface CallableFunction extends Function {
+	(...args: unknown[]): unknown;
+}
+declare interface NewableFunction extends Function {
+	new (...args: unknown[]): unknown;
+}
+declare interface FunctionConstructor {
+	new (val?: string): (this: unknown, ...args: unknown[]) => unknown;
+	(val?: string): (this: unknown, ...args: unknown[]) => unknown;
+}

src/main/resources/lib/values/number.d.ts

@@ -0,0 +1,24 @@
+declare interface Number {
+	valueOf(): number;
+	toString(): string;
+}
+declare interface NumberConstructor {
+	(val?: unknown): number;
+	new (val?: unknown): Number;
+
+	isFinite(value: number): boolean;
+	isInteger(value: number): boolean;
+	isNaN(value: number): boolean;
+	isSafeInteger(value: number): boolean;
+	parseFloat(value: unknown): number;
+	parseInt(value: unknown, radix?: number): number;
+
+	readonly EPSILON: number;
+	readonly MIN_SAFE_INTEGER: number;
+	readonly MAX_SAFE_INTEGER: number;
+	readonly POSITIVE_INFINITY: number;
+	readonly NEGATIVE_INFINITY: number;
+	readonly NaN: number;
+	readonly MAX_VALUE: number;
+	readonly MIN_VALUE: number;
+}

src/main/resources/lib/values/object.d.ts

@@ -0,0 +1,57 @@
+type AssignResult<Arr extends readonly object[]> =
+	Arr extends [...infer Rest extends object[], infer B extends object] ? {
+		[x in keyof B | keyof AssignResult<Rest>]:
+			x extends keyof B ? B[x] :
+			x extends keyof AssignResult<Rest> ? AssignResult<Rest>[x] :
+			never
+	} : {};
+
+declare interface PropertyDescriptor {
+	configurable?: boolean;
+	enumerable?: boolean;
+	value?: any;
+	writable?: boolean;
+	get?(): any;
+	set?(v: any): void;
+}
+declare interface PropertyDescriptorMap {
+	[key: PropertyKey]: PropertyDescriptor;
+}
+
+declare interface Object {
+	valueOf(): number;
+	toString(): string;
+}
+declare interface ObjectConstructor {
+	new (val: string): String;
+	(val: string): String;
+	new (val: number): Number;
+	new (val: number): Number;
+	(val: number): Number;
+	new (val: boolean): Boolean;
+	(val: boolean): Boolean;
+	new (val: symbol): Symbol;
+	(val: symbol): Symbol;
+	new <T extends object>(val: T): T;
+	<T extends object>(val: T): T;
+	new (): object;
+	(): object;
+
+	getOwnPropertyDescriptor(obj: object, key: any): PropertyDescriptor;
+	defineProperty<T extends object>(obj: T, key: string | symbol, desc: PropertyDescriptor): T;
+	defineProperties<T extends object>(obj: T, desc: PropertyDescriptorMap): T;
+
+	create<T extends object>(proto: T, desc?: PropertyDescriptorMap): T;
+	assign<First extends object, T extends readonly object[]>(targeT: First, ...arr: T): AssignResult<[First, ...T]>;
+
+	setPrototypeOf<T extends object>(obj: T, proto: object | null): T
+	getPrototypeOf(obj: object): object | null;
+
+	keys<T extends object>(obj: T): (keyof T)[];
+	values<T extends object>(obj: T): T[keyof T][];
+	entries<T extends object>(obj: T): [key: keyof T, val: T[keyof T]][];
+
+	preventExtensions<T>(obj: T): T;
+	seal<T>(obj: T): T;
+	freeze<T>(obj: T): T;
+}

src/main/resources/lib/values/regexp.d.ts

@@ -0,0 +1,36 @@
+declare interface RegExpMatchArray extends Array<string> {
+	0: string;
+
+	index?: number;
+	input?: string;
+
+	groups?: { [key: string]: string };
+	indices?: [start: number, end: number][] & {
+		[key: string]: [start: number, end: number]
+	}
+}
+
+declare interface RegExp {
+	lastIndex: number;
+
+	readonly source: string;
+	readonly flags: string;
+
+	readonly indices: boolean;
+	readonly global: boolean;
+	readonly ignoreCase: boolean;
+	readonly multiline: boolean;
+	readonly dotall: boolean;
+	readonly unicode: boolean;
+	readonly unicodeSets: boolean;
+	readonly sticky: boolean;
+
+	exec(target: string): RegExpMatchArray | null;
+	text(target: string): boolean
+	[Symbol.split](target: string, limit?: number): string[];
+	[Symbol.replace](target: string, replacer: any): string;
+}
+declare interface RegExpConstructor {
+	new (val: string, flags?: string): String;
+	(val: string, flags?: string): String;
+}

src/main/resources/lib/values/string.d.ts

@@ -0,0 +1,39 @@
+declare interface String {
+	readonly length: number;
+	[key: number]: string;
+
+	toString(): string;
+	valueOf(): string;
+
+	at(index: number): string | undefined;
+	charAt(i: number): string | undefined;
+	charCodeAt(i: number): string;
+	codePointAt(i: number): string;
+
+	includes(search: string, offset?: number): number;
+	indexOf(search: string, offset?: number): number;
+	lastIndexOf(search: string, offset?: number): number;
+
+	trim(): string;
+	trimStart(): string;
+	trimEnd(): string;
+	toLowerCase(): string;
+	toUpperCase(): string;
+
+	split(val?: any, limit?: number): string[];
+	replace(val: any, replacer: any): string;
+	replaceAll(val: any, replacer: any): string;
+
+	slice(start?: number, end?: number): string;
+	substring(start?: number, end?: number): string;
+	substr(start?: number, count?: number): string;
+
+	[Symbol.iterator](): IterableIterator<string>;
+}
+declare interface StringConstructor {
+	new (val: unknown): String;
+	(val: unknown): string;
+
+	fromCharCode(...chars: readonly number[]): string;
+	fromCodePoint(...points: readonly number[]): string;
+}

src/main/resources/lib/values/symbol.d.ts

@@ -0,0 +1,19 @@
+declare interface Symbol {
+	readonly description: string | undefined;
+
+	valueOf(): symbol;
+	toString(): string;
+}
+declare interface SymbolConstructor {
+	(val?: string): symbol;
+	for(val: string): symbol;
+
+	readonly asyncIterator: unique symbol;
+	readonly iterator: unique symbol;
+	readonly match: unique symbol;
+	readonly matchAll: unique symbol;
+	readonly replace: unique symbol;
+	readonly search: unique symbol;
+	readonly split: unique symbol;
+	readonly toStringTag: unique symbol;
+}