587 lines
20 KiB
TypeScript
587 lines
20 KiB
TypeScript
type PropertyDescriptor<T, ThisT> = {
|
|
value: any;
|
|
writable?: boolean;
|
|
enumerable?: boolean;
|
|
configurable?: boolean;
|
|
} | {
|
|
get?(this: ThisT): T;
|
|
set(this: ThisT, val: T): void;
|
|
enumerable?: boolean;
|
|
configurable?: boolean;
|
|
} | {
|
|
get(this: ThisT): T;
|
|
set?(this: ThisT, val: T): void;
|
|
enumerable?: boolean;
|
|
configurable?: boolean;
|
|
};
|
|
type Exclude<T, U> = T extends U ? never : T;
|
|
type Extract<T, U> = T extends U ? T : never;
|
|
type Record<KeyT extends string | number | symbol, ValT> = { [x in KeyT]: ValT }
|
|
type ReplaceFunc = (match: string, ...args: any[]) => string;
|
|
|
|
type PromiseFulfillFunc<T> = (val: T) => void;
|
|
type PromiseThenFunc<T, NextT> = (val: T) => NextT;
|
|
type PromiseRejectFunc = (err: unknown) => void;
|
|
type PromiseFunc<T> = (resolve: PromiseFulfillFunc<T>, reject: PromiseRejectFunc) => void;
|
|
|
|
type PromiseResult<T> ={ type: 'fulfilled'; value: T; } | { type: 'rejected'; reason: any; }
|
|
|
|
// wippidy-wine, this code is now mine :D
|
|
type Awaited<T> =
|
|
T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
|
|
T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
|
|
F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
|
|
Awaited<V> : // recursively unwrap the value
|
|
never : // the argument to `then` was not callable
|
|
T;
|
|
|
|
type IteratorYieldResult<TReturn> =
|
|
{ done?: false; } &
|
|
(TReturn extends undefined ? { value?: undefined; } : { value: TReturn; });
|
|
|
|
type IteratorReturnResult<TReturn> =
|
|
{ done: true } &
|
|
(TReturn extends undefined ? { value?: undefined; } : { value: TReturn; });
|
|
|
|
type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
|
|
|
|
interface Thenable<T> {
|
|
then<NextT>(onFulfilled: PromiseThenFunc<T, NextT>, onRejected?: PromiseRejectFunc): Promise<Awaited<NextT>>;
|
|
then(onFulfilled: undefined, onRejected?: PromiseRejectFunc): Promise<T>;
|
|
}
|
|
|
|
interface RegExpResultIndices extends Array<[number, number]> {
|
|
groups?: { [name: string]: [number, number]; };
|
|
}
|
|
interface RegExpResult extends Array<string> {
|
|
groups?: { [name: string]: string; };
|
|
index: number;
|
|
input: string;
|
|
indices?: RegExpResultIndices;
|
|
escape(raw: string, flags: string): RegExp;
|
|
}
|
|
|
|
interface Matcher {
|
|
[Symbol.match](target: string): RegExpResult | string[] | null;
|
|
[Symbol.matchAll](target: string): IterableIterator<RegExpResult>;
|
|
}
|
|
interface Splitter {
|
|
[Symbol.split](target: string, limit?: number, sensible?: boolean): string[];
|
|
}
|
|
interface Replacer {
|
|
[Symbol.replace](target: string, replacement: string | ReplaceFunc): string;
|
|
}
|
|
interface Searcher {
|
|
[Symbol.search](target: string, reverse?: boolean, start?: number): number;
|
|
}
|
|
|
|
type FlatArray<Arr, Depth extends number> = {
|
|
"done": Arr,
|
|
"recur": Arr extends Array<infer InnerArr>
|
|
? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
|
|
: Arr
|
|
}[Depth extends -1 ? "done" : "recur"];
|
|
|
|
interface IArguments {
|
|
[i: number]: any;
|
|
length: number;
|
|
}
|
|
|
|
interface Iterator<T, TReturn = any, TNext = undefined> {
|
|
next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
|
|
return?(value?: TReturn): IteratorResult<T, TReturn>;
|
|
throw?(e?: any): IteratorResult<T, TReturn>;
|
|
}
|
|
interface Iterable<T> {
|
|
[Symbol.iterator](): Iterator<T>;
|
|
}
|
|
interface IterableIterator<T> extends Iterator<T> {
|
|
[Symbol.iterator](): IterableIterator<T>;
|
|
}
|
|
|
|
interface AsyncIterator<T, TReturn = any, TNext = undefined> {
|
|
next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
|
|
return?(value?: TReturn | Thenable<TReturn>): Promise<IteratorResult<T, TReturn>>;
|
|
throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
|
|
}
|
|
interface AsyncIterable<T> {
|
|
[Symbol.asyncIterator](): AsyncIterator<T>;
|
|
}
|
|
interface AsyncIterableIterator<T> extends AsyncIterator<T> {
|
|
[Symbol.asyncIterator](): AsyncIterableIterator<T>;
|
|
}
|
|
|
|
interface Generator<T = unknown, TReturn = unknown, TNext = unknown> extends Iterator<T, TReturn, TNext> {
|
|
[Symbol.iterator](): Generator<T, TReturn, TNext>;
|
|
return(value: TReturn): IteratorResult<T, TReturn>;
|
|
throw(e: any): IteratorResult<T, TReturn>;
|
|
}
|
|
interface GeneratorFunction {
|
|
new (...args: any[]): Generator;
|
|
(...args: any[]): Generator;
|
|
readonly length: number;
|
|
readonly name: string;
|
|
readonly prototype: Generator;
|
|
}
|
|
|
|
interface AsyncGenerator<T = unknown, TReturn = unknown, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
|
|
return(value: TReturn | Thenable<TReturn>): Promise<IteratorResult<T, TReturn>>;
|
|
throw(e: any): Promise<IteratorResult<T, TReturn>>;
|
|
[Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
|
|
}
|
|
interface AsyncGeneratorFunction {
|
|
new (...args: any[]): AsyncGenerator;
|
|
(...args: any[]): AsyncGenerator;
|
|
readonly length: number;
|
|
readonly name: string;
|
|
readonly prototype: AsyncGenerator;
|
|
}
|
|
|
|
|
|
interface MathObject {
|
|
readonly E: number;
|
|
readonly PI: number;
|
|
readonly SQRT2: number;
|
|
readonly SQRT1_2: number;
|
|
readonly LN2: number;
|
|
readonly LN10: number;
|
|
readonly LOG2E: number;
|
|
readonly LOG10E: number;
|
|
|
|
asin(x: number): number;
|
|
acos(x: number): number;
|
|
atan(x: number): number;
|
|
atan2(y: number, x: number): number;
|
|
asinh(x: number): number;
|
|
acosh(x: number): number;
|
|
atanh(x: number): number;
|
|
sin(x: number): number;
|
|
cos(x: number): number;
|
|
tan(x: number): number;
|
|
sinh(x: number): number;
|
|
cosh(x: number): number;
|
|
tanh(x: number): number;
|
|
sqrt(x: number): number;
|
|
cbrt(x: number): number;
|
|
hypot(...vals: number[]): number;
|
|
imul(a: number, b: number): number;
|
|
exp(x: number): number;
|
|
expm1(x: number): number;
|
|
pow(x: number, y: number): number;
|
|
log(x: number): number;
|
|
log10(x: number): number;
|
|
log1p(x: number): number;
|
|
log2(x: number): number;
|
|
ceil(x: number): number;
|
|
floor(x: number): number;
|
|
round(x: number): number;
|
|
fround(x: number): number;
|
|
trunc(x: number): number;
|
|
abs(x: number): number;
|
|
max(...vals: number[]): number;
|
|
min(...vals: number[]): number;
|
|
sign(x: number): number;
|
|
random(): number;
|
|
clz32(x: number): number;
|
|
}
|
|
|
|
interface Array<T> extends IterableIterator<T> {
|
|
[i: number]: T;
|
|
|
|
length: number;
|
|
|
|
toString(): string;
|
|
// toLocaleString(): string;
|
|
join(separator?: string): string;
|
|
fill(val: T, start?: number, end?: number): T[];
|
|
pop(): T | undefined;
|
|
push(...items: T[]): number;
|
|
concat(...items: (T | T[])[]): T[];
|
|
concat(...items: (T | T[])[]): T[];
|
|
join(separator?: string): string;
|
|
reverse(): T[];
|
|
shift(): T | undefined;
|
|
slice(start?: number, end?: number): T[];
|
|
sort(compareFn?: (a: T, b: T) => number): this;
|
|
splice(start: number, deleteCount?: number | undefined, ...items: T[]): T[];
|
|
unshift(...items: T[]): number;
|
|
indexOf(searchElement: T, fromIndex?: number): number;
|
|
lastIndexOf(searchElement: T, fromIndex?: number): number;
|
|
every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
|
|
some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
|
|
forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
|
|
includes(el: any, start?: number): boolean;
|
|
|
|
map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
|
|
filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
|
|
find(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
|
|
findIndex(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): number;
|
|
findLast(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
|
|
findLastIndex(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): number;
|
|
|
|
flat<D extends number = 1>(depth?: D): FlatArray<T, D>;
|
|
flatMap(func: (val: T, i: number, arr: T[]) => T | T[], thisAarg?: any): FlatArray<T[], 1>;
|
|
sort(func?: (a: T, b: T) => number): this;
|
|
|
|
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
|
|
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
|
|
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
|
|
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
|
|
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
|
|
reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
|
|
|
|
entries(): IterableIterator<[number, T]>;
|
|
values(): IterableIterator<T>;
|
|
keys(): IterableIterator<number>;
|
|
}
|
|
interface ArrayConstructor {
|
|
new <T>(arrayLength?: number): T[];
|
|
new <T>(...items: T[]): T[];
|
|
<T>(arrayLength?: number): T[];
|
|
<T>(...items: T[]): T[];
|
|
isArray(arg: any): arg is any[];
|
|
prototype: Array<any>;
|
|
}
|
|
|
|
interface Boolean {
|
|
valueOf(): boolean;
|
|
}
|
|
interface BooleanConstructor {
|
|
(val: any): boolean;
|
|
new (val: any): Boolean;
|
|
prototype: Boolean;
|
|
}
|
|
|
|
interface Error {
|
|
name: string;
|
|
message: string;
|
|
stack: string[];
|
|
toString(): string;
|
|
}
|
|
interface ErrorConstructor {
|
|
(msg?: any): Error;
|
|
new (msg?: any): Error;
|
|
prototype: Error;
|
|
}
|
|
|
|
interface TypeErrorConstructor extends ErrorConstructor {
|
|
(msg?: any): TypeError;
|
|
new (msg?: any): TypeError;
|
|
prototype: Error;
|
|
}
|
|
interface TypeError extends Error {
|
|
name: 'TypeError';
|
|
}
|
|
|
|
interface RangeErrorConstructor extends ErrorConstructor {
|
|
(msg?: any): RangeError;
|
|
new (msg?: any): RangeError;
|
|
prototype: Error;
|
|
}
|
|
interface RangeError extends Error {
|
|
name: 'RangeError';
|
|
}
|
|
|
|
interface SyntaxErrorConstructor extends ErrorConstructor {
|
|
(msg?: any): RangeError;
|
|
new (msg?: any): RangeError;
|
|
prototype: Error;
|
|
}
|
|
interface SyntaxError extends Error {
|
|
name: 'SyntaxError';
|
|
}
|
|
|
|
interface Function {
|
|
apply(this: Function, thisArg: any, argArray?: any): any;
|
|
call(this: Function, thisArg: any, ...argArray: any[]): any;
|
|
bind(this: Function, thisArg: any, ...argArray: any[]): Function;
|
|
|
|
toString(): string;
|
|
|
|
prototype: any;
|
|
readonly length: number;
|
|
name: string;
|
|
}
|
|
interface CallableFunction extends Function {
|
|
(...args: any[]): any;
|
|
apply<ThisArg, Args extends any[], RetT>(this: (this: ThisArg, ...args: Args) => RetT, thisArg: ThisArg, argArray?: Args): RetT;
|
|
call<ThisArg, Args extends any[], RetT>(this: (this: ThisArg, ...args: Args) => RetT, thisArg: ThisArg, ...argArray: Args): RetT;
|
|
bind<ThisArg, Args extends any[], Rest extends any[], RetT>(this: (this: ThisArg, ...args: [ ...Args, ...Rest ]) => RetT, thisArg: ThisArg, ...argArray: Args): (this: void, ...args: Rest) => RetT;
|
|
}
|
|
interface NewableFunction extends Function {
|
|
new(...args: any[]): any;
|
|
apply<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, argArray?: Args): RetT;
|
|
call<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, ...argArray: Args): RetT;
|
|
bind<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, ...argArray: Args): new (...args: Args) => RetT;
|
|
}
|
|
interface FunctionConstructor extends Function {
|
|
(...args: string[]): (...args: any[]) => any;
|
|
new (...args: string[]): (...args: any[]) => any;
|
|
prototype: Function;
|
|
async<ArgsT extends any[], RetT>(
|
|
func: (await: <T>(val: T) => Awaited<T>) => (...args: ArgsT) => RetT
|
|
): (...args: ArgsT) => Promise<RetT>;
|
|
asyncGenerator<ArgsT extends any[], RetT>(
|
|
func: (await: <T>(val: T) => Awaited<T>, _yield: <T>(val: T) => void) => (...args: ArgsT) => RetT
|
|
): (...args: ArgsT) => AsyncGenerator<RetT>;
|
|
generator<ArgsT extends any[], T = unknown, RetT = unknown, TNext = unknown>(
|
|
func: (_yield: <T>(val: T) => TNext) => (...args: ArgsT) => RetT
|
|
): (...args: ArgsT) => Generator<T, RetT, TNext>;
|
|
}
|
|
|
|
interface Number {
|
|
toString(): string;
|
|
valueOf(): number;
|
|
}
|
|
interface NumberConstructor {
|
|
(val: any): number;
|
|
new (val: any): Number;
|
|
prototype: Number;
|
|
parseInt(val: unknown): number;
|
|
parseFloat(val: unknown): number;
|
|
}
|
|
|
|
interface Object {
|
|
constructor: NewableFunction;
|
|
[Symbol.typeName]: string;
|
|
|
|
valueOf(): this;
|
|
toString(): string;
|
|
hasOwnProperty(key: any): boolean;
|
|
}
|
|
interface ObjectConstructor extends Function {
|
|
(arg: string): String;
|
|
(arg: number): Number;
|
|
(arg: boolean): Boolean;
|
|
(arg?: undefined | null): {};
|
|
<T extends object>(arg: T): T;
|
|
|
|
new (arg: string): String;
|
|
new (arg: number): Number;
|
|
new (arg: boolean): Boolean;
|
|
new (arg?: undefined | null): {};
|
|
new <T extends object>(arg: T): T;
|
|
|
|
prototype: Object;
|
|
|
|
assign<T extends object>(target: T, ...src: object[]): T;
|
|
create<T extends object>(proto: T, props?: { [key: string]: PropertyDescriptor<any, T> }): T;
|
|
|
|
keys<T extends object>(obj: T, onlyString?: true): (keyof T)[];
|
|
keys<T extends object>(obj: T, onlyString: false): any[];
|
|
entries<T extends object>(obj: T, onlyString?: true): [keyof T, T[keyof T]][];
|
|
entries<T extends object>(obj: T, onlyString: false): [any, any][];
|
|
values<T extends object>(obj: T, onlyString?: true): (T[keyof T])[];
|
|
values<T extends object>(obj: T, onlyString: false): any[];
|
|
|
|
fromEntries(entries: Iterable<[any, any]>): object;
|
|
|
|
defineProperty<T, ThisT extends object>(obj: ThisT, key: any, desc: PropertyDescriptor<T, ThisT>): ThisT;
|
|
defineProperties<ThisT extends object>(obj: ThisT, desc: { [key: string]: PropertyDescriptor<any, ThisT> }): ThisT;
|
|
|
|
getOwnPropertyNames<T extends object>(obj: T): (keyof T)[];
|
|
getOwnPropertySymbols<T extends object>(obj: T): (keyof T)[];
|
|
hasOwn<T extends object, KeyT>(obj: T, key: KeyT): boolean;
|
|
|
|
getOwnPropertyDescriptor<T extends object, KeyT extends keyof T>(obj: T, key: KeyT): PropertyDescriptor<T[KeyT], T>;
|
|
getOwnPropertyDescriptors<T extends object>(obj: T): { [x in keyof T]: PropertyDescriptor<T[x], T> };
|
|
|
|
getPrototypeOf(obj: any): object | null;
|
|
setPrototypeOf<T>(obj: T, proto: object | null): T;
|
|
|
|
preventExtensions<T extends object>(obj: T): T;
|
|
seal<T extends object>(obj: T): T;
|
|
freeze<T extends object>(obj: T): T;
|
|
|
|
isExtensible(obj: object): boolean;
|
|
isSealed(obj: object): boolean;
|
|
isFrozen(obj: object): boolean;
|
|
}
|
|
|
|
interface String {
|
|
[i: number]: string;
|
|
|
|
toString(): string;
|
|
valueOf(): string;
|
|
|
|
charAt(pos: number): string;
|
|
charCodeAt(pos: number): number;
|
|
substring(start?: number, end?: number): string;
|
|
slice(start?: number, end?: number): string;
|
|
substr(start?: number, length?: number): string;
|
|
|
|
startsWith(str: string, pos?: number): string;
|
|
endsWith(str: string, pos?: number): string;
|
|
|
|
replace(pattern: string | Replacer, val: string | ReplaceFunc): string;
|
|
replaceAll(pattern: string | Replacer, val: string | ReplaceFunc): string;
|
|
|
|
match(pattern: string | Matcher): RegExpResult | string[] | null;
|
|
matchAll(pattern: string | Matcher): IterableIterator<RegExpResult>;
|
|
|
|
split(pattern: string | Splitter, limit?: number, sensible?: boolean): string;
|
|
|
|
concat(...others: string[]): string;
|
|
indexOf(term: string | Searcher, start?: number): number;
|
|
lastIndexOf(term: string | Searcher, start?: number): number;
|
|
|
|
toLowerCase(): string;
|
|
toUpperCase(): string;
|
|
|
|
trim(): string;
|
|
|
|
includes(term: string, start?: number): boolean;
|
|
|
|
length: number;
|
|
}
|
|
interface StringConstructor {
|
|
(val: any): string;
|
|
new (val: any): String;
|
|
|
|
fromCharCode(val: number): string;
|
|
|
|
prototype: String;
|
|
}
|
|
|
|
interface Symbol {
|
|
valueOf(): symbol;
|
|
}
|
|
interface SymbolConstructor {
|
|
(val?: any): symbol;
|
|
new(...args: any[]): never;
|
|
prototype: Symbol;
|
|
for(key: string): symbol;
|
|
keyFor(sym: symbol): string;
|
|
|
|
readonly typeName: unique symbol;
|
|
readonly match: unique symbol;
|
|
readonly matchAll: unique symbol;
|
|
readonly split: unique symbol;
|
|
readonly replace: unique symbol;
|
|
readonly search: unique symbol;
|
|
readonly iterator: unique symbol;
|
|
readonly asyncIterator: unique symbol;
|
|
}
|
|
|
|
interface Promise<T> extends Thenable<T> {
|
|
catch(func: PromiseRejectFunc): Promise<T>;
|
|
finally(func: () => void): Promise<T>;
|
|
}
|
|
interface PromiseConstructor {
|
|
prototype: Promise<any>;
|
|
|
|
new <T>(func: PromiseFunc<T>): Promise<Awaited<T>>;
|
|
resolve<T>(val: T): Promise<Awaited<T>>;
|
|
reject(val: any): Promise<never>;
|
|
|
|
isAwaitable(val: unknown): val is Thenable<any>;
|
|
any<T>(promises: T[]): Promise<Awaited<T>>;
|
|
race<T>(promises: (Promise<T>|T)[]): Promise<T>;
|
|
all<T extends any[]>(promises: T): Promise<{ [Key in keyof T]: Awaited<T[Key]> }>;
|
|
allSettled<T extends any[]>(...promises: T): Promise<[...{ [P in keyof T]: PromiseResult<Awaited<T[P]>>}]>;
|
|
}
|
|
|
|
declare var String: StringConstructor;
|
|
//@ts-ignore
|
|
declare const arguments: IArguments;
|
|
declare var NaN: number;
|
|
declare var Infinity: number;
|
|
|
|
declare var setTimeout: <T extends any[]>(handle: (...args: [ ...T, ...any[] ]) => void, delay?: number, ...args: T) => number;
|
|
declare var setInterval: <T extends any[]>(handle: (...args: [ ...T, ...any[] ]) => void, delay?: number, ...args: T) => number;
|
|
|
|
declare var clearTimeout: (id: number) => void;
|
|
declare var clearInterval: (id: number) => void;
|
|
|
|
declare var parseInt: typeof Number.parseInt;
|
|
declare var parseFloat: typeof Number.parseFloat;
|
|
|
|
declare function log(...vals: any[]): void;
|
|
|
|
declare var Array: ArrayConstructor;
|
|
declare var Boolean: BooleanConstructor;
|
|
declare var Promise: PromiseConstructor;
|
|
declare var Function: FunctionConstructor;
|
|
declare var Number: NumberConstructor;
|
|
declare var Object: ObjectConstructor;
|
|
declare var Symbol: SymbolConstructor;
|
|
declare var Promise: PromiseConstructor;
|
|
declare var Math: MathObject;
|
|
|
|
declare var Error: ErrorConstructor;
|
|
declare var RangeError: RangeErrorConstructor;
|
|
declare var TypeError: TypeErrorConstructor;
|
|
declare var SyntaxError: SyntaxErrorConstructor;
|
|
|
|
declare class Map<KeyT, ValueT> {
|
|
public [Symbol.iterator](): IterableIterator<[KeyT, ValueT]>;
|
|
|
|
public clear(): void;
|
|
public delete(key: KeyT): boolean;
|
|
|
|
public entries(): IterableIterator<[KeyT, ValueT]>;
|
|
public keys(): IterableIterator<KeyT>;
|
|
public values(): IterableIterator<ValueT>;
|
|
|
|
public get(key: KeyT): ValueT;
|
|
public set(key: KeyT, val: ValueT): this;
|
|
public has(key: KeyT): boolean;
|
|
|
|
public get size(): number;
|
|
|
|
public forEach(func: (key: KeyT, val: ValueT, map: Map<KeyT, ValueT>) => void, thisArg?: any): void;
|
|
|
|
public constructor();
|
|
}
|
|
declare class Set<T> {
|
|
public [Symbol.iterator](): IterableIterator<T>;
|
|
|
|
public entries(): IterableIterator<[T, T]>;
|
|
public keys(): IterableIterator<T>;
|
|
public values(): IterableIterator<T>;
|
|
|
|
public clear(): void;
|
|
|
|
public add(val: T): this;
|
|
public delete(val: T): boolean;
|
|
public has(key: T): boolean;
|
|
|
|
public get size(): number;
|
|
|
|
public forEach(func: (key: T, set: Set<T>) => void, thisArg?: any): void;
|
|
|
|
public constructor();
|
|
}
|
|
|
|
declare class RegExp implements Matcher, Splitter, Replacer, Searcher {
|
|
static escape(raw: any, flags?: string): RegExp;
|
|
|
|
prototype: RegExp;
|
|
|
|
exec(val: string): RegExpResult | null;
|
|
test(val: string): boolean;
|
|
toString(): string;
|
|
|
|
[Symbol.match](target: string): RegExpResult | string[] | null;
|
|
[Symbol.matchAll](target: string): IterableIterator<RegExpResult>;
|
|
[Symbol.split](target: string, limit?: number, sensible?: boolean): string[];
|
|
[Symbol.replace](target: string, replacement: string | ReplaceFunc): string;
|
|
[Symbol.search](target: string, reverse?: boolean, start?: number): number;
|
|
|
|
readonly dotAll: boolean;
|
|
readonly global: boolean;
|
|
readonly hasIndices: boolean;
|
|
readonly ignoreCase: boolean;
|
|
readonly multiline: boolean;
|
|
readonly sticky: boolean;
|
|
readonly unicode: boolean;
|
|
|
|
readonly source: string;
|
|
readonly flags: string;
|
|
|
|
lastIndex: number;
|
|
|
|
constructor(pattern?: string, flags?: string);
|
|
constructor(pattern?: RegExp, flags?: string);
|
|
}
|