/** * Returns the ECMAScript intrinsic for the name. * * @param name The ECMAScript intrinsic name * @param allowMissing Whether the intrinsic can be missing in this environment * * @throws {SyntaxError} If the ECMAScript intrinsic doesn't exist * @throws {TypeError} If the ECMAScript intrinsic exists, but not in this environment and `allowMissing` is `false`. */ declare function GetIntrinsic( name: K, allowMissing?: false, ): GetIntrinsic.Intrinsics[K]; declare function GetIntrinsic( name: K, allowMissing: true, ): GetIntrinsic.Intrinsics[K] | undefined; declare function GetIntrinsic( name: K, allowMissing?: boolean, ): GetIntrinsic.Intrinsics[K] | undefined; declare function GetIntrinsic(name: string, allowMissing?: boolean): unknown; export = GetIntrinsic; type numeric = number | bigint; interface TypedArray extends Readonly { /** The length of the array. */ readonly length: number; [index: number]: T; } interface TypedArrayConstructor { readonly prototype: TypedArrayPrototype; new(...args: unknown[]): TypedArrayPrototype; /** * Returns a new typed array from a set of elements. * @param items A set of elements to include in the new typed array object. */ of(this: new(length: number) => Int8Array, ...items: number[]): Int8Array; of(this: new(length: number) => Uint8Array, ...items: number[]): Uint8Array; of(this: new(length: number) => Uint8ClampedArray, ...items: number[]): Uint8ClampedArray; of(this: new(length: number) => Int16Array, ...items: number[]): Int16Array; of(this: new(length: number) => Uint16Array, ...items: number[]): Uint16Array; of(this: new(length: number) => Int32Array, ...items: number[]): Int32Array; of(this: new(length: number) => Uint32Array, ...items: number[]): Uint32Array; of(this: new(length: number) => BigInt64Array, ...items: bigint[]): BigInt64Array; of(this: new(length: number) => BigUint64Array, ...items: bigint[]): BigUint64Array; of(this: new(length: number) => Float32Array, ...items: number[]): Float32Array; of(this: new(length: number) => Float64Array, ...items: number[]): Float64Array; /** * Creates a new typed array from an array-like or iterable object. * @param source An array-like or iterable object to convert to a typed array. * @param mapfn A mapping function to call on every element of the source object. * @param thisArg Value of 'this' used to invoke the mapfn. */ from(this: new(length: number) => Int8Array, source: Iterable | ArrayLike): Int8Array; from( this: new(length: number) => Int8Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Int8Array; from(this: new(length: number) => Uint8Array, source: Iterable | ArrayLike): Uint8Array; from( this: new(length: number) => Uint8Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Uint8Array; from( this: new(length: number) => Uint8ClampedArray, source: Iterable | ArrayLike, ): Uint8ClampedArray; from( this: new(length: number) => Uint8ClampedArray, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Uint8ClampedArray; from(this: new(length: number) => Int16Array, source: Iterable | ArrayLike): Int16Array; from( this: new(length: number) => Int16Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Int16Array; from(this: new(length: number) => Uint16Array, source: Iterable | ArrayLike): Uint16Array; from( this: new(length: number) => Uint16Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Uint16Array; from(this: new(length: number) => Int32Array, source: Iterable | ArrayLike): Int32Array; from( this: new(length: number) => Int32Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Int32Array; from(this: new(length: number) => Uint32Array, source: Iterable | ArrayLike): Uint32Array; from( this: new(length: number) => Uint32Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Uint32Array; from(this: new(length: number) => BigInt64Array, source: Iterable | ArrayLike): BigInt64Array; from( this: new(length: number) => BigInt64Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: unknown, ): BigInt64Array; from(this: new(length: number) => BigUint64Array, source: Iterable | ArrayLike): BigUint64Array; from( this: new(length: number) => BigUint64Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: unknown, ): BigUint64Array; from(this: new(length: number) => Float32Array, source: Iterable | ArrayLike): Float32Array; from( this: new(length: number) => Float32Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Float32Array; from(this: new(length: number) => Float64Array, source: Iterable | ArrayLike): Float64Array; from( this: new(length: number) => Float64Array, source: Iterable | ArrayLike, mapfn: (v: U, k: number) => number, thisArg?: unknown, ): Float64Array; } interface TypedArrayPrototype { /** The ArrayBuffer instance referenced by the array. */ readonly buffer: ArrayBufferLike; /** The length in bytes of the array. */ readonly byteLength: number; /** The offset in bytes of the array. */ readonly byteOffset: number; /** * Returns the this object after copying a section of the array identified by start and end * to the same array starting at position target * @param target If target is negative, it is treated as length+target where length is the * length of the array. * @param start If start is negative, it is treated as length+start. If end is negative, it * is treated as length+end. * @param end If not specified, length of the this object is used as its default value. */ copyWithin(this: THIS, target: number, start: number, end?: number): THIS; /** Yields index, value pairs for every entry in the array. */ entries(this: TypedArray): IterableIterator<[number, T]>; /** * Determines whether all the members of an array satisfy the specified test. * @param callbackfn A function that accepts up to three arguments. The every method calls * the callbackfn function for each element in the array until the callbackfn returns false, * or until the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ every>( this: THIS, predicate: (value: T, index: number, array: THIS) => unknown, thisArg?: unknown, ): boolean; /** * Returns the this object after filling the section identified by start and end with value * @param value value to fill array section with * @param start index to start filling the array at. If start is negative, it is treated as * length+start where length is the length of the array. * @param end index to stop filling the array at. If end is negative, it is treated as * length+end. */ fill>(this: THIS, value: T, start?: number, end?: number): THIS; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param callbackfn A function that accepts up to three arguments. The filter method calls * the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ filter>( this: THIS, predicate: (value: T, index: number, array: THIS) => unknown, thisArg?: unknown, ): THIS; /** * Returns the value of the first element in the array where predicate is true, and undefined * otherwise. * @param predicate find calls predicate once for each element of the array, in ascending * order, until it finds one where predicate returns true. If such an element is found, find * immediately returns that element value. Otherwise, find returns undefined. * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ find>( this: THIS, predicate: (value: T, index: number, array: THIS) => unknown, thisArg?: unknown, ): T | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 * otherwise. * @param predicate find calls predicate once for each element of the array, in ascending * order, until it finds one where predicate returns true. If such an element is found, * findIndex immediately returns that element index. Otherwise, findIndex returns -1. * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ findIndex>( this: THIS, predicate: (value: T, index: number, array: THIS) => unknown, thisArg?: unknown, ): number; /** * Performs the specified action for each element in an array. * @param callbackfn A function that accepts up to three arguments. forEach calls the * callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ forEach>( this: THIS, callbackfn: (value: T, index: number, array: THIS) => void, thisArg?: unknown, ): void; /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. * @param fromIndex The position in this array at which to begin searching for searchElement. */ includes(this: TypedArray, searchElement: T, fromIndex?: number): boolean; /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the * search starts at index 0. */ indexOf(this: TypedArray, searchElement: T, fromIndex?: number): boolean; /** * Adds all the elements of an array separated by the specified separator string. * @param separator A string used to separate one element of an array from the next in the * resulting String. If omitted, the array elements are separated with a comma. */ join(this: TypedArray, separator?: string): string; /** Yields each index in the array. */ keys(this: TypedArray): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. * @param searchElement The value to locate in the array. * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the * search starts at index 0. */ lastIndexOf(this: TypedArray, searchElement: T, fromIndex?: number): boolean; /** The length of the array. */ readonly length: number; /** * Calls a defined callback function on each element of an array, and returns an array that * contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the * callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ map( this: THIS, mapper: (value: T, index: number, array: THIS) => T, thisArg?: unknown, ): THIS; /** * Calls the specified callback function for all the elements in an array. The return value of * the callback function is the accumulated result, and is provided as an argument in the next * call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduce method calls the * callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ reduce>( this: THIS, reducer: (previousValue: T, currentValue: T, currentIndex: number, array: THIS) => T, ): T; reduce>( this: THIS, reducer: (previousValue: U, currentValue: T, currentIndex: number, array: THIS) => U, initialValue: U, ): U; /** * Calls the specified callback function for all the elements in an array, in descending order. * The return value of the callback function is the accumulated result, and is provided as an * argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls * the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ reduceRight>( this: THIS, reducer: (previousValue: T, currentValue: T, currentIndex: number, array: THIS) => T, ): T; reduceRight>( this: THIS, reducer: (previousValue: U, currentValue: T, currentIndex: number, array: THIS) => U, initialValue: U, ): U; /** Reverses the elements in the array. */ reverse(this: THIS): THIS; /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. * @param offset The index in the current array at which the values are to be written. */ set(this: TypedArray, array: ArrayLike, offset?: number): void; /** * Returns a section of an array. * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. */ slice(this: THIS, start?: number, end?: number): THIS; /** * Determines whether the specified callback function returns true for any element of an array. * @param callbackfn A function that accepts up to three arguments. The some method calls the * callbackfn function for each element in the array until the callbackfn returns true, or until * the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ some>( this: THIS, predicate: (value: T, index: number, array: THIS) => unknown, thisArg?: unknown, ): boolean; /** * Sorts the array. * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order. */ sort>(this: THIS, comparator?: (a: T, b: T) => number): THIS; /** * Gets a new subview of the ArrayBuffer store for this array, referencing the elements * at begin, inclusive, up to end, exclusive. * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ subarray(this: THIS, begin?: number, end?: number): THIS; /** Converts the array to a string by using the current locale. */ toLocaleString(this: TypedArray, locales?: string | string[], options?: Intl.NumberFormatOptions): string; /** Returns a string representation of the array. */ toString(): string; /** Yields each value in the array. */ values(this: TypedArray): IterableIterator; /** Yields each value in the array. */ [Symbol.iterator](this: TypedArray): IterableIterator; readonly [Symbol.toStringTag]: string | undefined; } // ------------------------ >8 ------------------------ // autogenerated by scripts/collect-intrinsics.ts // do not edit! 2020-07-08T00:53:03.057Z /* eslint-disable @typescript-eslint/no-wrapper-object-types */ declare namespace GetIntrinsic { interface Intrinsics { "%Array%": ArrayConstructor; "%ArrayBuffer%": ArrayBufferConstructor; "%ArrayBufferPrototype%": ArrayBuffer; "%ArrayIteratorPrototype%": IterableIterator; "%ArrayPrototype%": typeof Array.prototype; "%ArrayProto_entries%": typeof Array.prototype.entries; "%ArrayProto_forEach%": typeof Array.prototype.forEach; "%ArrayProto_keys%": typeof Array.prototype.keys; "%ArrayProto_values%": typeof Array.prototype.values; "%AsyncFromSyncIteratorPrototype%": AsyncGenerator; "%AsyncFunction%": FunctionConstructor; "%AsyncFunctionPrototype%": typeof Function.prototype; "%AsyncGenerator%": AsyncGeneratorFunction; "%AsyncGeneratorFunction%": AsyncGeneratorFunctionConstructor; "%AsyncGeneratorPrototype%": AsyncGenerator; "%AsyncIteratorPrototype%": AsyncIterable; "%Atomics%": Atomics; "%Boolean%": BooleanConstructor; "%BooleanPrototype%": typeof Boolean.prototype; "%DataView%": DataViewConstructor; "%DataViewPrototype%": DataView; "%Date%": DateConstructor; "%DatePrototype%": Date; "%decodeURI%": typeof decodeURI; "%decodeURIComponent%": typeof decodeURIComponent; "%encodeURI%": typeof encodeURI; "%encodeURIComponent%": typeof encodeURIComponent; "%Error%": ErrorConstructor; "%ErrorPrototype%": Error; "%eval%": typeof eval; "%EvalError%": EvalErrorConstructor; "%EvalErrorPrototype%": EvalError; "%Float32Array%": Float32ArrayConstructor; "%Float32ArrayPrototype%": Float32Array; "%Float64Array%": Float64ArrayConstructor; "%Float64ArrayPrototype%": Float64Array; "%Function%": FunctionConstructor; "%FunctionPrototype%": typeof Function.prototype; "%Generator%": GeneratorFunction; "%GeneratorFunction%": GeneratorFunctionConstructor; "%GeneratorPrototype%": Generator; "%Int8Array%": Int8ArrayConstructor; "%Int8ArrayPrototype%": Int8Array; "%Int16Array%": Int16ArrayConstructor; "%Int16ArrayPrototype%": Int16Array; "%Int32Array%": Int32ArrayConstructor; "%Int32ArrayPrototype%": Int32Array; "%isFinite%": typeof isFinite; "%isNaN%": typeof isNaN; "%IteratorPrototype%": Iterable; "%JSON%": JSON; "%JSONParse%": typeof JSON.parse; "%Map%": MapConstructor; "%MapIteratorPrototype%": IterableIterator; "%MapPrototype%": typeof Map.prototype; "%Math%": Math; "%Number%": NumberConstructor; "%NumberPrototype%": typeof Number.prototype; "%Object%": ObjectConstructor; "%ObjectPrototype%": typeof Object.prototype; "%ObjProto_toString%": typeof Object.prototype.toString; "%ObjProto_valueOf%": typeof Object.prototype.valueOf; "%parseFloat%": typeof parseFloat; "%parseInt%": typeof parseInt; "%Promise%": PromiseConstructor; "%PromisePrototype%": typeof Promise.prototype; "%PromiseProto_then%": typeof Promise.prototype.then; "%Promise_all%": typeof Promise.all; "%Promise_reject%": typeof Promise.reject; "%Promise_resolve%": typeof Promise.resolve; "%Proxy%": ProxyConstructor; "%RangeError%": RangeErrorConstructor; "%RangeErrorPrototype%": RangeError; "%ReferenceError%": ReferenceErrorConstructor; "%ReferenceErrorPrototype%": ReferenceError; "%Reflect%": typeof Reflect; "%RegExp%": RegExpConstructor; "%RegExpPrototype%": RegExp; "%Set%": SetConstructor; "%SetIteratorPrototype%": IterableIterator; "%SetPrototype%": typeof Set.prototype; "%SharedArrayBuffer%": SharedArrayBufferConstructor; "%SharedArrayBufferPrototype%": SharedArrayBuffer; "%String%": StringConstructor; "%StringIteratorPrototype%": IterableIterator; "%StringPrototype%": typeof String.prototype; "%Symbol%": SymbolConstructor; "%SymbolPrototype%": typeof Symbol.prototype; "%SyntaxError%": SyntaxErrorConstructor; "%SyntaxErrorPrototype%": SyntaxError; "%ThrowTypeError%": () => never; "%TypedArray%": TypedArrayConstructor; "%TypedArrayPrototype%": TypedArrayPrototype; "%TypeError%": TypeErrorConstructor; "%TypeErrorPrototype%": TypeError; "%Uint8Array%": Uint8ArrayConstructor; "%Uint8ArrayPrototype%": Uint8Array; "%Uint8ClampedArray%": Uint8ClampedArrayConstructor; "%Uint8ClampedArrayPrototype%": Uint8ClampedArray; "%Uint16Array%": Uint16ArrayConstructor; "%Uint16ArrayPrototype%": Uint16Array; "%Uint32Array%": Uint32ArrayConstructor; "%Uint32ArrayPrototype%": Uint32Array; "%URIError%": URIErrorConstructor; "%URIErrorPrototype%": URIError; "%WeakMap%": WeakMapConstructor; "%WeakMapPrototype%": typeof WeakMap.prototype; "%WeakSet%": WeakSetConstructor; "%WeakSetPrototype%": typeof WeakSet.prototype; } interface Intrinsics { "%Array.prototype%": typeof Array.prototype; "%Array.prototype.length%": typeof Array.prototype.length; "%Array.prototype.concat%": typeof Array.prototype.concat; "%Array.prototype.copyWithin%": typeof Array.prototype.copyWithin; "%Array.prototype.fill%": typeof Array.prototype.fill; "%Array.prototype.find%": typeof Array.prototype.find; "%Array.prototype.findIndex%": typeof Array.prototype.findIndex; "%Array.prototype.lastIndexOf%": typeof Array.prototype.lastIndexOf; "%Array.prototype.pop%": typeof Array.prototype.pop; "%Array.prototype.push%": typeof Array.prototype.push; "%Array.prototype.reverse%": typeof Array.prototype.reverse; "%Array.prototype.shift%": typeof Array.prototype.shift; "%Array.prototype.unshift%": typeof Array.prototype.unshift; "%Array.prototype.slice%": typeof Array.prototype.slice; "%Array.prototype.sort%": typeof Array.prototype.sort; "%Array.prototype.splice%": typeof Array.prototype.splice; "%Array.prototype.includes%": typeof Array.prototype.includes; "%Array.prototype.indexOf%": typeof Array.prototype.indexOf; "%Array.prototype.join%": typeof Array.prototype.join; "%Array.prototype.keys%": typeof Array.prototype.keys; "%Array.prototype.entries%": typeof Array.prototype.entries; "%Array.prototype.values%": typeof Array.prototype.values; "%Array.prototype.forEach%": typeof Array.prototype.forEach; "%Array.prototype.filter%": typeof Array.prototype.filter; "%Array.prototype.flat%": typeof Array.prototype.flat; "%Array.prototype.flatMap%": typeof Array.prototype.flatMap; "%Array.prototype.map%": typeof Array.prototype.map; "%Array.prototype.every%": typeof Array.prototype.every; "%Array.prototype.some%": typeof Array.prototype.some; "%Array.prototype.reduce%": typeof Array.prototype.reduce; "%Array.prototype.reduceRight%": typeof Array.prototype.reduceRight; "%Array.prototype.toLocaleString%": typeof Array.prototype.toLocaleString; "%Array.prototype.toString%": typeof Array.prototype.toString; "%Array.isArray%": typeof Array.isArray; "%Array.from%": typeof Array.from; "%Array.of%": typeof Array.of; "%ArrayBuffer.prototype%": ArrayBuffer; "%ArrayBuffer.prototype.byteLength%": (this: ArrayBuffer) => typeof ArrayBuffer.prototype.byteLength; "%ArrayBuffer.prototype.slice%": typeof ArrayBuffer.prototype.slice; "%ArrayBuffer.isView%": typeof ArrayBuffer.isView; "%ArrayBufferPrototype.byteLength%": (this: ArrayBuffer) => typeof ArrayBuffer.prototype.byteLength; "%ArrayBufferPrototype.slice%": typeof ArrayBuffer.prototype.slice; "%ArrayIteratorPrototype.next%": IterableIterator["next"]; "%ArrayPrototype.length%": typeof Array.prototype.length; "%ArrayPrototype.concat%": typeof Array.prototype.concat; "%ArrayPrototype.copyWithin%": typeof Array.prototype.copyWithin; "%ArrayPrototype.fill%": typeof Array.prototype.fill; "%ArrayPrototype.find%": typeof Array.prototype.find; "%ArrayPrototype.findIndex%": typeof Array.prototype.findIndex; "%ArrayPrototype.lastIndexOf%": typeof Array.prototype.lastIndexOf; "%ArrayPrototype.pop%": typeof Array.prototype.pop; "%ArrayPrototype.push%": typeof Array.prototype.push; "%ArrayPrototype.reverse%": typeof Array.prototype.reverse; "%ArrayPrototype.shift%": typeof Array.prototype.shift; "%ArrayPrototype.unshift%": typeof Array.prototype.unshift; "%ArrayPrototype.slice%": typeof Array.prototype.slice; "%ArrayPrototype.sort%": typeof Array.prototype.sort; "%ArrayPrototype.splice%": typeof Array.prototype.splice; "%ArrayPrototype.includes%": typeof Array.prototype.includes; "%ArrayPrototype.indexOf%": typeof Array.prototype.indexOf; "%ArrayPrototype.join%": typeof Array.prototype.join; "%ArrayPrototype.keys%": typeof Array.prototype.keys; "%ArrayPrototype.entries%": typeof Array.prototype.entries; "%ArrayPrototype.values%": typeof Array.prototype.values; "%ArrayPrototype.forEach%": typeof Array.prototype.forEach; "%ArrayPrototype.filter%": typeof Array.prototype.filter; "%ArrayPrototype.flat%": typeof Array.prototype.flat; "%ArrayPrototype.flatMap%": typeof Array.prototype.flatMap; "%ArrayPrototype.map%": typeof Array.prototype.map; "%ArrayPrototype.every%": typeof Array.prototype.every; "%ArrayPrototype.some%": typeof Array.prototype.some; "%ArrayPrototype.reduce%": typeof Array.prototype.reduce; "%ArrayPrototype.reduceRight%": typeof Array.prototype.reduceRight; "%ArrayPrototype.toLocaleString%": typeof Array.prototype.toLocaleString; "%ArrayPrototype.toString%": typeof Array.prototype.toString; "%AsyncFromSyncIteratorPrototype.next%": AsyncGenerator["next"]; "%AsyncFromSyncIteratorPrototype.return%": AsyncGenerator["return"]; "%AsyncFromSyncIteratorPrototype.throw%": AsyncGenerator["throw"]; "%AsyncFunction.prototype%": typeof Function.prototype; "%AsyncGenerator.prototype%": AsyncGenerator; "%AsyncGenerator.prototype.next%": AsyncGenerator["next"]; "%AsyncGenerator.prototype.return%": AsyncGenerator["return"]; "%AsyncGenerator.prototype.throw%": AsyncGenerator["throw"]; "%AsyncGeneratorFunction.prototype%": AsyncGeneratorFunction; "%AsyncGeneratorFunction.prototype.prototype%": AsyncGenerator; "%AsyncGeneratorFunction.prototype.prototype.next%": AsyncGenerator["next"]; "%AsyncGeneratorFunction.prototype.prototype.return%": AsyncGenerator["return"]; "%AsyncGeneratorFunction.prototype.prototype.throw%": AsyncGenerator["throw"]; "%AsyncGeneratorPrototype.next%": AsyncGenerator["next"]; "%AsyncGeneratorPrototype.return%": AsyncGenerator["return"]; "%AsyncGeneratorPrototype.throw%": AsyncGenerator["throw"]; "%Atomics.load%": typeof Atomics.load; "%Atomics.store%": typeof Atomics.store; "%Atomics.add%": typeof Atomics.add; "%Atomics.sub%": typeof Atomics.sub; "%Atomics.and%": typeof Atomics.and; "%Atomics.or%": typeof Atomics.or; "%Atomics.xor%": typeof Atomics.xor; "%Atomics.exchange%": typeof Atomics.exchange; "%Atomics.compareExchange%": typeof Atomics.compareExchange; "%Atomics.isLockFree%": typeof Atomics.isLockFree; "%Atomics.wait%": typeof Atomics.wait; "%Atomics.notify%": typeof Atomics.notify; "%Boolean.prototype%": typeof Boolean.prototype; "%Boolean.prototype.toString%": typeof Boolean.prototype.toString; "%Boolean.prototype.valueOf%": typeof Boolean.prototype.valueOf; "%BooleanPrototype.toString%": typeof Boolean.prototype.toString; "%BooleanPrototype.valueOf%": typeof Boolean.prototype.valueOf; "%DataView.prototype%": DataView; "%DataView.prototype.buffer%": (this: DataView) => typeof DataView.prototype.buffer; "%DataView.prototype.byteLength%": (this: DataView) => typeof DataView.prototype.byteLength; "%DataView.prototype.byteOffset%": (this: DataView) => typeof DataView.prototype.byteOffset; "%DataView.prototype.getInt8%": typeof DataView.prototype.getInt8; "%DataView.prototype.setInt8%": typeof DataView.prototype.setInt8; "%DataView.prototype.getUint8%": typeof DataView.prototype.getUint8; "%DataView.prototype.setUint8%": typeof DataView.prototype.setUint8; "%DataView.prototype.getInt16%": typeof DataView.prototype.getInt16; "%DataView.prototype.setInt16%": typeof DataView.prototype.setInt16; "%DataView.prototype.getUint16%": typeof DataView.prototype.getUint16; "%DataView.prototype.setUint16%": typeof DataView.prototype.setUint16; "%DataView.prototype.getInt32%": typeof DataView.prototype.getInt32; "%DataView.prototype.setInt32%": typeof DataView.prototype.setInt32; "%DataView.prototype.getUint32%": typeof DataView.prototype.getUint32; "%DataView.prototype.setUint32%": typeof DataView.prototype.setUint32; "%DataView.prototype.getFloat32%": typeof DataView.prototype.getFloat32; "%DataView.prototype.setFloat32%": typeof DataView.prototype.setFloat32; "%DataView.prototype.getFloat64%": typeof DataView.prototype.getFloat64; "%DataView.prototype.setFloat64%": typeof DataView.prototype.setFloat64; "%DataView.prototype.getBigInt64%": typeof DataView.prototype.getBigInt64; "%DataView.prototype.setBigInt64%": typeof DataView.prototype.setBigInt64; "%DataView.prototype.getBigUint64%": typeof DataView.prototype.getBigUint64; "%DataView.prototype.setBigUint64%": typeof DataView.prototype.setBigUint64; "%DataViewPrototype.buffer%": (this: DataView) => typeof DataView.prototype.buffer; "%DataViewPrototype.byteLength%": (this: DataView) => typeof DataView.prototype.byteLength; "%DataViewPrototype.byteOffset%": (this: DataView) => typeof DataView.prototype.byteOffset; "%DataViewPrototype.getInt8%": typeof DataView.prototype.getInt8; "%DataViewPrototype.setInt8%": typeof DataView.prototype.setInt8; "%DataViewPrototype.getUint8%": typeof DataView.prototype.getUint8; "%DataViewPrototype.setUint8%": typeof DataView.prototype.setUint8; "%DataViewPrototype.getInt16%": typeof DataView.prototype.getInt16; "%DataViewPrototype.setInt16%": typeof DataView.prototype.setInt16; "%DataViewPrototype.getUint16%": typeof DataView.prototype.getUint16; "%DataViewPrototype.setUint16%": typeof DataView.prototype.setUint16; "%DataViewPrototype.getInt32%": typeof DataView.prototype.getInt32; "%DataViewPrototype.setInt32%": typeof DataView.prototype.setInt32; "%DataViewPrototype.getUint32%": typeof DataView.prototype.getUint32; "%DataViewPrototype.setUint32%": typeof DataView.prototype.setUint32; "%DataViewPrototype.getFloat32%": typeof DataView.prototype.getFloat32; "%DataViewPrototype.setFloat32%": typeof DataView.prototype.setFloat32; "%DataViewPrototype.getFloat64%": typeof DataView.prototype.getFloat64; "%DataViewPrototype.setFloat64%": typeof DataView.prototype.setFloat64; "%DataViewPrototype.getBigInt64%": typeof DataView.prototype.getBigInt64; "%DataViewPrototype.setBigInt64%": typeof DataView.prototype.setBigInt64; "%DataViewPrototype.getBigUint64%": typeof DataView.prototype.getBigUint64; "%DataViewPrototype.setBigUint64%": typeof DataView.prototype.setBigUint64; "%Date.prototype%": Date; "%Date.prototype.toString%": typeof Date.prototype.toString; "%Date.prototype.toDateString%": typeof Date.prototype.toDateString; "%Date.prototype.toTimeString%": typeof Date.prototype.toTimeString; "%Date.prototype.toISOString%": typeof Date.prototype.toISOString; "%Date.prototype.toUTCString%": typeof Date.prototype.toUTCString; "%Date.prototype.getDate%": typeof Date.prototype.getDate; "%Date.prototype.setDate%": typeof Date.prototype.setDate; "%Date.prototype.getDay%": typeof Date.prototype.getDay; "%Date.prototype.getFullYear%": typeof Date.prototype.getFullYear; "%Date.prototype.setFullYear%": typeof Date.prototype.setFullYear; "%Date.prototype.getHours%": typeof Date.prototype.getHours; "%Date.prototype.setHours%": typeof Date.prototype.setHours; "%Date.prototype.getMilliseconds%": typeof Date.prototype.getMilliseconds; "%Date.prototype.setMilliseconds%": typeof Date.prototype.setMilliseconds; "%Date.prototype.getMinutes%": typeof Date.prototype.getMinutes; "%Date.prototype.setMinutes%": typeof Date.prototype.setMinutes; "%Date.prototype.getMonth%": typeof Date.prototype.getMonth; "%Date.prototype.setMonth%": typeof Date.prototype.setMonth; "%Date.prototype.getSeconds%": typeof Date.prototype.getSeconds; "%Date.prototype.setSeconds%": typeof Date.prototype.setSeconds; "%Date.prototype.getTime%": typeof Date.prototype.getTime; "%Date.prototype.setTime%": typeof Date.prototype.setTime; "%Date.prototype.getTimezoneOffset%": typeof Date.prototype.getTimezoneOffset; "%Date.prototype.getUTCDate%": typeof Date.prototype.getUTCDate; "%Date.prototype.setUTCDate%": typeof Date.prototype.setUTCDate; "%Date.prototype.getUTCDay%": typeof Date.prototype.getUTCDay; "%Date.prototype.getUTCFullYear%": typeof Date.prototype.getUTCFullYear; "%Date.prototype.setUTCFullYear%": typeof Date.prototype.setUTCFullYear; "%Date.prototype.getUTCHours%": typeof Date.prototype.getUTCHours; "%Date.prototype.setUTCHours%": typeof Date.prototype.setUTCHours; "%Date.prototype.getUTCMilliseconds%": typeof Date.prototype.getUTCMilliseconds; "%Date.prototype.setUTCMilliseconds%": typeof Date.prototype.setUTCMilliseconds; "%Date.prototype.getUTCMinutes%": typeof Date.prototype.getUTCMinutes; "%Date.prototype.setUTCMinutes%": typeof Date.prototype.setUTCMinutes; "%Date.prototype.getUTCMonth%": typeof Date.prototype.getUTCMonth; "%Date.prototype.setUTCMonth%": typeof Date.prototype.setUTCMonth; "%Date.prototype.getUTCSeconds%": typeof Date.prototype.getUTCSeconds; "%Date.prototype.setUTCSeconds%": typeof Date.prototype.setUTCSeconds; "%Date.prototype.valueOf%": typeof Date.prototype.valueOf; "%Date.prototype.toJSON%": typeof Date.prototype.toJSON; "%Date.prototype.toLocaleString%": typeof Date.prototype.toLocaleString; "%Date.prototype.toLocaleDateString%": typeof Date.prototype.toLocaleDateString; "%Date.prototype.toLocaleTimeString%": typeof Date.prototype.toLocaleTimeString; "%Date.now%": typeof Date.now; "%Date.parse%": typeof Date.parse; "%Date.UTC%": typeof Date.UTC; "%DatePrototype.toString%": typeof Date.prototype.toString; "%DatePrototype.toDateString%": typeof Date.prototype.toDateString; "%DatePrototype.toTimeString%": typeof Date.prototype.toTimeString; "%DatePrototype.toISOString%": typeof Date.prototype.toISOString; "%DatePrototype.toUTCString%": typeof Date.prototype.toUTCString; "%DatePrototype.getDate%": typeof Date.prototype.getDate; "%DatePrototype.setDate%": typeof Date.prototype.setDate; "%DatePrototype.getDay%": typeof Date.prototype.getDay; "%DatePrototype.getFullYear%": typeof Date.prototype.getFullYear; "%DatePrototype.setFullYear%": typeof Date.prototype.setFullYear; "%DatePrototype.getHours%": typeof Date.prototype.getHours; "%DatePrototype.setHours%": typeof Date.prototype.setHours; "%DatePrototype.getMilliseconds%": typeof Date.prototype.getMilliseconds; "%DatePrototype.setMilliseconds%": typeof Date.prototype.setMilliseconds; "%DatePrototype.getMinutes%": typeof Date.prototype.getMinutes; "%DatePrototype.setMinutes%": typeof Date.prototype.setMinutes; "%DatePrototype.getMonth%": typeof Date.prototype.getMonth; "%DatePrototype.setMonth%": typeof Date.prototype.setMonth; "%DatePrototype.getSeconds%": typeof Date.prototype.getSeconds; "%DatePrototype.setSeconds%": typeof Date.prototype.setSeconds; "%DatePrototype.getTime%": typeof Date.prototype.getTime; "%DatePrototype.setTime%": typeof Date.prototype.setTime; "%DatePrototype.getTimezoneOffset%": typeof Date.prototype.getTimezoneOffset; "%DatePrototype.getUTCDate%": typeof Date.prototype.getUTCDate; "%DatePrototype.setUTCDate%": typeof Date.prototype.setUTCDate; "%DatePrototype.getUTCDay%": typeof Date.prototype.getUTCDay; "%DatePrototype.getUTCFullYear%": typeof Date.prototype.getUTCFullYear; "%DatePrototype.setUTCFullYear%": typeof Date.prototype.setUTCFullYear; "%DatePrototype.getUTCHours%": typeof Date.prototype.getUTCHours; "%DatePrototype.setUTCHours%": typeof Date.prototype.setUTCHours; "%DatePrototype.getUTCMilliseconds%": typeof Date.prototype.getUTCMilliseconds; "%DatePrototype.setUTCMilliseconds%": typeof Date.prototype.setUTCMilliseconds; "%DatePrototype.getUTCMinutes%": typeof Date.prototype.getUTCMinutes; "%DatePrototype.setUTCMinutes%": typeof Date.prototype.setUTCMinutes; "%DatePrototype.getUTCMonth%": typeof Date.prototype.getUTCMonth; "%DatePrototype.setUTCMonth%": typeof Date.prototype.setUTCMonth; "%DatePrototype.getUTCSeconds%": typeof Date.prototype.getUTCSeconds; "%DatePrototype.setUTCSeconds%": typeof Date.prototype.setUTCSeconds; "%DatePrototype.valueOf%": typeof Date.prototype.valueOf; "%DatePrototype.toJSON%": typeof Date.prototype.toJSON; "%DatePrototype.toLocaleString%": typeof Date.prototype.toLocaleString; "%DatePrototype.toLocaleDateString%": typeof Date.prototype.toLocaleDateString; "%DatePrototype.toLocaleTimeString%": typeof Date.prototype.toLocaleTimeString; "%Error.prototype%": Error; "%Error.prototype.name%": typeof Error.prototype.name; "%Error.prototype.message%": typeof Error.prototype.message; "%Error.prototype.toString%": typeof Error.prototype.toString; "%ErrorPrototype.name%": typeof Error.prototype.name; "%ErrorPrototype.message%": typeof Error.prototype.message; "%ErrorPrototype.toString%": typeof Error.prototype.toString; "%EvalError.prototype%": EvalError; "%EvalError.prototype.name%": typeof EvalError.prototype.name; "%EvalError.prototype.message%": typeof EvalError.prototype.message; "%EvalErrorPrototype.name%": typeof EvalError.prototype.name; "%EvalErrorPrototype.message%": typeof EvalError.prototype.message; "%Float32Array.prototype%": Float32Array; "%Float32Array.prototype.BYTES_PER_ELEMENT%": typeof Float32Array.prototype.BYTES_PER_ELEMENT; "%Float32Array.BYTES_PER_ELEMENT%": typeof Float32Array.BYTES_PER_ELEMENT; "%Float32ArrayPrototype.BYTES_PER_ELEMENT%": typeof Float32Array.prototype.BYTES_PER_ELEMENT; "%Float64Array.prototype%": Float64Array; "%Float64Array.prototype.BYTES_PER_ELEMENT%": typeof Float64Array.prototype.BYTES_PER_ELEMENT; "%Float64Array.BYTES_PER_ELEMENT%": typeof Float64Array.BYTES_PER_ELEMENT; "%Float64ArrayPrototype.BYTES_PER_ELEMENT%": typeof Float64Array.prototype.BYTES_PER_ELEMENT; "%Function.prototype%": typeof Function.prototype; "%Function.prototype.apply%": typeof Function.prototype.apply; "%Function.prototype.bind%": typeof Function.prototype.bind; "%Function.prototype.call%": typeof Function.prototype.call; "%Function.prototype.toString%": typeof Function.prototype.toString; "%FunctionPrototype.apply%": typeof Function.prototype.apply; "%FunctionPrototype.bind%": typeof Function.prototype.bind; "%FunctionPrototype.call%": typeof Function.prototype.call; "%FunctionPrototype.toString%": typeof Function.prototype.toString; "%Generator.prototype%": Generator; "%Generator.prototype.next%": Generator["next"]; "%Generator.prototype.return%": Generator["return"]; "%Generator.prototype.throw%": Generator["throw"]; "%GeneratorFunction.prototype%": GeneratorFunction; "%GeneratorFunction.prototype.prototype%": Generator; "%GeneratorFunction.prototype.prototype.next%": Generator["next"]; "%GeneratorFunction.prototype.prototype.return%": Generator["return"]; "%GeneratorFunction.prototype.prototype.throw%": Generator["throw"]; "%GeneratorPrototype.next%": Generator["next"]; "%GeneratorPrototype.return%": Generator["return"]; "%GeneratorPrototype.throw%": Generator["throw"]; "%Int8Array.prototype%": Int8Array; "%Int8Array.prototype.BYTES_PER_ELEMENT%": typeof Int8Array.prototype.BYTES_PER_ELEMENT; "%Int8Array.BYTES_PER_ELEMENT%": typeof Int8Array.BYTES_PER_ELEMENT; "%Int8ArrayPrototype.BYTES_PER_ELEMENT%": typeof Int8Array.prototype.BYTES_PER_ELEMENT; "%Int16Array.prototype%": Int16Array; "%Int16Array.prototype.BYTES_PER_ELEMENT%": typeof Int16Array.prototype.BYTES_PER_ELEMENT; "%Int16Array.BYTES_PER_ELEMENT%": typeof Int16Array.BYTES_PER_ELEMENT; "%Int16ArrayPrototype.BYTES_PER_ELEMENT%": typeof Int16Array.prototype.BYTES_PER_ELEMENT; "%Int32Array.prototype%": Int32Array; "%Int32Array.prototype.BYTES_PER_ELEMENT%": typeof Int32Array.prototype.BYTES_PER_ELEMENT; "%Int32Array.BYTES_PER_ELEMENT%": typeof Int32Array.BYTES_PER_ELEMENT; "%Int32ArrayPrototype.BYTES_PER_ELEMENT%": typeof Int32Array.prototype.BYTES_PER_ELEMENT; "%JSON.parse%": typeof JSON.parse; "%JSON.stringify%": typeof JSON.stringify; "%Map.prototype%": typeof Map.prototype; "%Map.prototype.get%": typeof Map.prototype.get; "%Map.prototype.set%": typeof Map.prototype.set; "%Map.prototype.has%": typeof Map.prototype.has; "%Map.prototype.delete%": typeof Map.prototype.delete; "%Map.prototype.clear%": typeof Map.prototype.clear; "%Map.prototype.entries%": typeof Map.prototype.entries; "%Map.prototype.forEach%": typeof Map.prototype.forEach; "%Map.prototype.keys%": typeof Map.prototype.keys; "%Map.prototype.size%": (this: Map) => typeof Map.prototype.size; "%Map.prototype.values%": typeof Map.prototype.values; "%MapIteratorPrototype.next%": IterableIterator["next"]; "%MapPrototype.get%": typeof Map.prototype.get; "%MapPrototype.set%": typeof Map.prototype.set; "%MapPrototype.has%": typeof Map.prototype.has; "%MapPrototype.delete%": typeof Map.prototype.delete; "%MapPrototype.clear%": typeof Map.prototype.clear; "%MapPrototype.entries%": typeof Map.prototype.entries; "%MapPrototype.forEach%": typeof Map.prototype.forEach; "%MapPrototype.keys%": typeof Map.prototype.keys; "%MapPrototype.size%": (this: Map) => typeof Map.prototype.size; "%MapPrototype.values%": typeof Map.prototype.values; "%Math.abs%": typeof Math.abs; "%Math.acos%": typeof Math.acos; "%Math.acosh%": typeof Math.acosh; "%Math.asin%": typeof Math.asin; "%Math.asinh%": typeof Math.asinh; "%Math.atan%": typeof Math.atan; "%Math.atanh%": typeof Math.atanh; "%Math.atan2%": typeof Math.atan2; "%Math.ceil%": typeof Math.ceil; "%Math.cbrt%": typeof Math.cbrt; "%Math.expm1%": typeof Math.expm1; "%Math.clz32%": typeof Math.clz32; "%Math.cos%": typeof Math.cos; "%Math.cosh%": typeof Math.cosh; "%Math.exp%": typeof Math.exp; "%Math.floor%": typeof Math.floor; "%Math.fround%": typeof Math.fround; "%Math.hypot%": typeof Math.hypot; "%Math.imul%": typeof Math.imul; "%Math.log%": typeof Math.log; "%Math.log1p%": typeof Math.log1p; "%Math.log2%": typeof Math.log2; "%Math.log10%": typeof Math.log10; "%Math.max%": typeof Math.max; "%Math.min%": typeof Math.min; "%Math.pow%": typeof Math.pow; "%Math.random%": typeof Math.random; "%Math.round%": typeof Math.round; "%Math.sign%": typeof Math.sign; "%Math.sin%": typeof Math.sin; "%Math.sinh%": typeof Math.sinh; "%Math.sqrt%": typeof Math.sqrt; "%Math.tan%": typeof Math.tan; "%Math.tanh%": typeof Math.tanh; "%Math.trunc%": typeof Math.trunc; "%Math.E%": typeof Math.E; "%Math.LN10%": typeof Math.LN10; "%Math.LN2%": typeof Math.LN2; "%Math.LOG10E%": typeof Math.LOG10E; "%Math.LOG2E%": typeof Math.LOG2E; "%Math.PI%": typeof Math.PI; "%Math.SQRT1_2%": typeof Math.SQRT1_2; "%Math.SQRT2%": typeof Math.SQRT2; "%Number.prototype%": typeof Number.prototype; "%Number.prototype.toExponential%": typeof Number.prototype.toExponential; "%Number.prototype.toFixed%": typeof Number.prototype.toFixed; "%Number.prototype.toPrecision%": typeof Number.prototype.toPrecision; "%Number.prototype.toString%": typeof Number.prototype.toString; "%Number.prototype.valueOf%": typeof Number.prototype.valueOf; "%Number.prototype.toLocaleString%": typeof Number.prototype.toLocaleString; "%Number.isFinite%": typeof Number.isFinite; "%Number.isInteger%": typeof Number.isInteger; "%Number.isNaN%": typeof Number.isNaN; "%Number.isSafeInteger%": typeof Number.isSafeInteger; "%Number.parseFloat%": typeof Number.parseFloat; "%Number.parseInt%": typeof Number.parseInt; "%Number.MAX_VALUE%": typeof Number.MAX_VALUE; "%Number.MIN_VALUE%": typeof Number.MIN_VALUE; "%Number.NaN%": typeof Number.NaN; "%Number.NEGATIVE_INFINITY%": typeof Number.NEGATIVE_INFINITY; "%Number.POSITIVE_INFINITY%": typeof Number.POSITIVE_INFINITY; "%Number.MAX_SAFE_INTEGER%": typeof Number.MAX_SAFE_INTEGER; "%Number.MIN_SAFE_INTEGER%": typeof Number.MIN_SAFE_INTEGER; "%Number.EPSILON%": typeof Number.EPSILON; "%NumberPrototype.toExponential%": typeof Number.prototype.toExponential; "%NumberPrototype.toFixed%": typeof Number.prototype.toFixed; "%NumberPrototype.toPrecision%": typeof Number.prototype.toPrecision; "%NumberPrototype.toString%": typeof Number.prototype.toString; "%NumberPrototype.valueOf%": typeof Number.prototype.valueOf; "%NumberPrototype.toLocaleString%": typeof Number.prototype.toLocaleString; "%Object.prototype%": typeof Object.prototype; "%Object.prototype.hasOwnProperty%": typeof Object.prototype.hasOwnProperty; "%Object.prototype.isPrototypeOf%": typeof Object.prototype.isPrototypeOf; "%Object.prototype.propertyIsEnumerable%": typeof Object.prototype.propertyIsEnumerable; "%Object.prototype.toString%": typeof Object.prototype.toString; "%Object.prototype.valueOf%": typeof Object.prototype.valueOf; "%Object.prototype.toLocaleString%": typeof Object.prototype.toLocaleString; "%Object.assign%": typeof Object.assign; "%Object.getOwnPropertyDescriptor%": typeof Object.getOwnPropertyDescriptor; "%Object.getOwnPropertyDescriptors%": typeof Object.getOwnPropertyDescriptors; "%Object.getOwnPropertyNames%": typeof Object.getOwnPropertyNames; "%Object.getOwnPropertySymbols%": typeof Object.getOwnPropertySymbols; "%Object.is%": typeof Object.is; "%Object.preventExtensions%": typeof Object.preventExtensions; "%Object.seal%": typeof Object.seal; "%Object.create%": typeof Object.create; "%Object.defineProperties%": typeof Object.defineProperties; "%Object.defineProperty%": typeof Object.defineProperty; "%Object.freeze%": typeof Object.freeze; "%Object.getPrototypeOf%": typeof Object.getPrototypeOf; "%Object.setPrototypeOf%": typeof Object.setPrototypeOf; "%Object.isExtensible%": typeof Object.isExtensible; "%Object.isFrozen%": typeof Object.isFrozen; "%Object.isSealed%": typeof Object.isSealed; "%Object.keys%": typeof Object.keys; "%Object.entries%": typeof Object.entries; "%Object.fromEntries%": typeof Object.fromEntries; "%Object.values%": typeof Object.values; "%ObjectPrototype.hasOwnProperty%": typeof Object.prototype.hasOwnProperty; "%ObjectPrototype.isPrototypeOf%": typeof Object.prototype.isPrototypeOf; "%ObjectPrototype.propertyIsEnumerable%": typeof Object.prototype.propertyIsEnumerable; "%ObjectPrototype.toString%": typeof Object.prototype.toString; "%ObjectPrototype.valueOf%": typeof Object.prototype.valueOf; "%ObjectPrototype.toLocaleString%": typeof Object.prototype.toLocaleString; "%Promise.prototype%": typeof Promise.prototype; "%Promise.prototype.then%": typeof Promise.prototype.then; "%Promise.prototype.catch%": typeof Promise.prototype.catch; "%Promise.prototype.finally%": typeof Promise.prototype.finally; "%Promise.all%": typeof Promise.all; "%Promise.race%": typeof Promise.race; "%Promise.resolve%": typeof Promise.resolve; "%Promise.reject%": typeof Promise.reject; "%Promise.allSettled%": typeof Promise.allSettled; "%PromisePrototype.then%": typeof Promise.prototype.then; "%PromisePrototype.catch%": typeof Promise.prototype.catch; "%PromisePrototype.finally%": typeof Promise.prototype.finally; "%Proxy.revocable%": typeof Proxy.revocable; "%RangeError.prototype%": RangeError; "%RangeError.prototype.name%": typeof RangeError.prototype.name; "%RangeError.prototype.message%": typeof RangeError.prototype.message; "%RangeErrorPrototype.name%": typeof RangeError.prototype.name; "%RangeErrorPrototype.message%": typeof RangeError.prototype.message; "%ReferenceError.prototype%": ReferenceError; "%ReferenceError.prototype.name%": typeof ReferenceError.prototype.name; "%ReferenceError.prototype.message%": typeof ReferenceError.prototype.message; "%ReferenceErrorPrototype.name%": typeof ReferenceError.prototype.name; "%ReferenceErrorPrototype.message%": typeof ReferenceError.prototype.message; "%Reflect.defineProperty%": typeof Reflect.defineProperty; "%Reflect.deleteProperty%": typeof Reflect.deleteProperty; "%Reflect.apply%": typeof Reflect.apply; "%Reflect.construct%": typeof Reflect.construct; "%Reflect.get%": typeof Reflect.get; "%Reflect.getOwnPropertyDescriptor%": typeof Reflect.getOwnPropertyDescriptor; "%Reflect.getPrototypeOf%": typeof Reflect.getPrototypeOf; "%Reflect.has%": typeof Reflect.has; "%Reflect.isExtensible%": typeof Reflect.isExtensible; "%Reflect.ownKeys%": typeof Reflect.ownKeys; "%Reflect.preventExtensions%": typeof Reflect.preventExtensions; "%Reflect.set%": typeof Reflect.set; "%Reflect.setPrototypeOf%": typeof Reflect.setPrototypeOf; "%RegExp.prototype%": RegExp; "%RegExp.prototype.exec%": typeof RegExp.prototype.exec; "%RegExp.prototype.dotAll%": (this: RegExp) => typeof RegExp.prototype.dotAll; "%RegExp.prototype.flags%": (this: RegExp) => typeof RegExp.prototype.flags; "%RegExp.prototype.global%": (this: RegExp) => typeof RegExp.prototype.global; "%RegExp.prototype.ignoreCase%": (this: RegExp) => typeof RegExp.prototype.ignoreCase; "%RegExp.prototype.multiline%": (this: RegExp) => typeof RegExp.prototype.multiline; "%RegExp.prototype.source%": (this: RegExp) => typeof RegExp.prototype.source; "%RegExp.prototype.sticky%": (this: RegExp) => typeof RegExp.prototype.sticky; "%RegExp.prototype.unicode%": (this: RegExp) => typeof RegExp.prototype.unicode; "%RegExp.prototype.compile%": typeof RegExp.prototype.compile; "%RegExp.prototype.toString%": typeof RegExp.prototype.toString; "%RegExp.prototype.test%": typeof RegExp.prototype.test; "%RegExpPrototype.exec%": typeof RegExp.prototype.exec; "%RegExpPrototype.dotAll%": (this: RegExp) => typeof RegExp.prototype.dotAll; "%RegExpPrototype.flags%": (this: RegExp) => typeof RegExp.prototype.flags; "%RegExpPrototype.global%": (this: RegExp) => typeof RegExp.prototype.global; "%RegExpPrototype.ignoreCase%": (this: RegExp) => typeof RegExp.prototype.ignoreCase; "%RegExpPrototype.multiline%": (this: RegExp) => typeof RegExp.prototype.multiline; "%RegExpPrototype.source%": (this: RegExp) => typeof RegExp.prototype.source; "%RegExpPrototype.sticky%": (this: RegExp) => typeof RegExp.prototype.sticky; "%RegExpPrototype.unicode%": (this: RegExp) => typeof RegExp.prototype.unicode; "%RegExpPrototype.compile%": typeof RegExp.prototype.compile; "%RegExpPrototype.toString%": typeof RegExp.prototype.toString; "%RegExpPrototype.test%": typeof RegExp.prototype.test; "%Set.prototype%": typeof Set.prototype; "%Set.prototype.has%": typeof Set.prototype.has; "%Set.prototype.add%": typeof Set.prototype.add; "%Set.prototype.delete%": typeof Set.prototype.delete; "%Set.prototype.clear%": typeof Set.prototype.clear; "%Set.prototype.entries%": typeof Set.prototype.entries; "%Set.prototype.forEach%": typeof Set.prototype.forEach; "%Set.prototype.size%": (this: Set) => typeof Set.prototype.size; "%Set.prototype.values%": typeof Set.prototype.values; "%Set.prototype.keys%": typeof Set.prototype.keys; "%SetIteratorPrototype.next%": IterableIterator["next"]; "%SetPrototype.has%": typeof Set.prototype.has; "%SetPrototype.add%": typeof Set.prototype.add; "%SetPrototype.delete%": typeof Set.prototype.delete; "%SetPrototype.clear%": typeof Set.prototype.clear; "%SetPrototype.entries%": typeof Set.prototype.entries; "%SetPrototype.forEach%": typeof Set.prototype.forEach; "%SetPrototype.size%": (this: Set) => typeof Set.prototype.size; "%SetPrototype.values%": typeof Set.prototype.values; "%SetPrototype.keys%": typeof Set.prototype.keys; "%SharedArrayBuffer.prototype%": SharedArrayBuffer; "%SharedArrayBuffer.prototype.byteLength%": ( this: SharedArrayBuffer, ) => typeof SharedArrayBuffer.prototype.byteLength; "%SharedArrayBuffer.prototype.slice%": typeof SharedArrayBuffer.prototype.slice; "%SharedArrayBufferPrototype.byteLength%": ( this: SharedArrayBuffer, ) => typeof SharedArrayBuffer.prototype.byteLength; "%SharedArrayBufferPrototype.slice%": typeof SharedArrayBuffer.prototype.slice; "%String.prototype%": typeof String.prototype; "%String.prototype.length%": typeof String.prototype.length; "%String.prototype.anchor%": typeof String.prototype.anchor; "%String.prototype.big%": typeof String.prototype.big; "%String.prototype.blink%": typeof String.prototype.blink; "%String.prototype.bold%": typeof String.prototype.bold; "%String.prototype.charAt%": typeof String.prototype.charAt; "%String.prototype.charCodeAt%": typeof String.prototype.charCodeAt; "%String.prototype.codePointAt%": typeof String.prototype.codePointAt; "%String.prototype.concat%": typeof String.prototype.concat; "%String.prototype.endsWith%": typeof String.prototype.endsWith; "%String.prototype.fontcolor%": typeof String.prototype.fontcolor; "%String.prototype.fontsize%": typeof String.prototype.fontsize; "%String.prototype.fixed%": typeof String.prototype.fixed; "%String.prototype.includes%": typeof String.prototype.includes; "%String.prototype.indexOf%": typeof String.prototype.indexOf; "%String.prototype.italics%": typeof String.prototype.italics; "%String.prototype.lastIndexOf%": typeof String.prototype.lastIndexOf; "%String.prototype.link%": typeof String.prototype.link; "%String.prototype.localeCompare%": typeof String.prototype.localeCompare; "%String.prototype.match%": typeof String.prototype.match; "%String.prototype.matchAll%": typeof String.prototype.matchAll; "%String.prototype.normalize%": typeof String.prototype.normalize; "%String.prototype.padEnd%": typeof String.prototype.padEnd; "%String.prototype.padStart%": typeof String.prototype.padStart; "%String.prototype.repeat%": typeof String.prototype.repeat; "%String.prototype.replace%": typeof String.prototype.replace; "%String.prototype.search%": typeof String.prototype.search; "%String.prototype.slice%": typeof String.prototype.slice; "%String.prototype.small%": typeof String.prototype.small; "%String.prototype.split%": typeof String.prototype.split; "%String.prototype.strike%": typeof String.prototype.strike; "%String.prototype.sub%": typeof String.prototype.sub; "%String.prototype.substr%": typeof String.prototype.substr; "%String.prototype.substring%": typeof String.prototype.substring; "%String.prototype.sup%": typeof String.prototype.sup; "%String.prototype.startsWith%": typeof String.prototype.startsWith; "%String.prototype.toString%": typeof String.prototype.toString; "%String.prototype.trim%": typeof String.prototype.trim; "%String.prototype.trimStart%": typeof String.prototype.trimStart; "%String.prototype.trimLeft%": typeof String.prototype.trimLeft; "%String.prototype.trimEnd%": typeof String.prototype.trimEnd; "%String.prototype.trimRight%": typeof String.prototype.trimRight; "%String.prototype.toLocaleLowerCase%": typeof String.prototype.toLocaleLowerCase; "%String.prototype.toLocaleUpperCase%": typeof String.prototype.toLocaleUpperCase; "%String.prototype.toLowerCase%": typeof String.prototype.toLowerCase; "%String.prototype.toUpperCase%": typeof String.prototype.toUpperCase; "%String.prototype.valueOf%": typeof String.prototype.valueOf; "%String.fromCharCode%": typeof String.fromCharCode; "%String.fromCodePoint%": typeof String.fromCodePoint; "%String.raw%": typeof String.raw; "%StringIteratorPrototype.next%": IterableIterator["next"]; "%StringPrototype.length%": typeof String.prototype.length; "%StringPrototype.anchor%": typeof String.prototype.anchor; "%StringPrototype.big%": typeof String.prototype.big; "%StringPrototype.blink%": typeof String.prototype.blink; "%StringPrototype.bold%": typeof String.prototype.bold; "%StringPrototype.charAt%": typeof String.prototype.charAt; "%StringPrototype.charCodeAt%": typeof String.prototype.charCodeAt; "%StringPrototype.codePointAt%": typeof String.prototype.codePointAt; "%StringPrototype.concat%": typeof String.prototype.concat; "%StringPrototype.endsWith%": typeof String.prototype.endsWith; "%StringPrototype.fontcolor%": typeof String.prototype.fontcolor; "%StringPrototype.fontsize%": typeof String.prototype.fontsize; "%StringPrototype.fixed%": typeof String.prototype.fixed; "%StringPrototype.includes%": typeof String.prototype.includes; "%StringPrototype.indexOf%": typeof String.prototype.indexOf; "%StringPrototype.italics%": typeof String.prototype.italics; "%StringPrototype.lastIndexOf%": typeof String.prototype.lastIndexOf; "%StringPrototype.link%": typeof String.prototype.link; "%StringPrototype.localeCompare%": typeof String.prototype.localeCompare; "%StringPrototype.match%": typeof String.prototype.match; "%StringPrototype.matchAll%": typeof String.prototype.matchAll; "%StringPrototype.normalize%": typeof String.prototype.normalize; "%StringPrototype.padEnd%": typeof String.prototype.padEnd; "%StringPrototype.padStart%": typeof String.prototype.padStart; "%StringPrototype.repeat%": typeof String.prototype.repeat; "%StringPrototype.replace%": typeof String.prototype.replace; "%StringPrototype.search%": typeof String.prototype.search; "%StringPrototype.slice%": typeof String.prototype.slice; "%StringPrototype.small%": typeof String.prototype.small; "%StringPrototype.split%": typeof String.prototype.split; "%StringPrototype.strike%": typeof String.prototype.strike; "%StringPrototype.sub%": typeof String.prototype.sub; "%StringPrototype.substr%": typeof String.prototype.substr; "%StringPrototype.substring%": typeof String.prototype.substring; "%StringPrototype.sup%": typeof String.prototype.sup; "%StringPrototype.startsWith%": typeof String.prototype.startsWith; "%StringPrototype.toString%": typeof String.prototype.toString; "%StringPrototype.trim%": typeof String.prototype.trim; "%StringPrototype.trimStart%": typeof String.prototype.trimStart; "%StringPrototype.trimLeft%": typeof String.prototype.trimLeft; "%StringPrototype.trimEnd%": typeof String.prototype.trimEnd; "%StringPrototype.trimRight%": typeof String.prototype.trimRight; "%StringPrototype.toLocaleLowerCase%": typeof String.prototype.toLocaleLowerCase; "%StringPrototype.toLocaleUpperCase%": typeof String.prototype.toLocaleUpperCase; "%StringPrototype.toLowerCase%": typeof String.prototype.toLowerCase; "%StringPrototype.toUpperCase%": typeof String.prototype.toUpperCase; "%StringPrototype.valueOf%": typeof String.prototype.valueOf; "%Symbol.prototype%": typeof Symbol.prototype; "%Symbol.prototype.toString%": typeof Symbol.prototype.toString; "%Symbol.prototype.valueOf%": typeof Symbol.prototype.valueOf; "%Symbol.prototype.description%": (this: symbol | Symbol) => typeof Symbol.prototype.description; "%Symbol.for%": typeof Symbol.for; "%Symbol.keyFor%": typeof Symbol.keyFor; "%Symbol.asyncIterator%": typeof Symbol.asyncIterator; "%Symbol.hasInstance%": typeof Symbol.hasInstance; "%Symbol.isConcatSpreadable%": typeof Symbol.isConcatSpreadable; "%Symbol.iterator%": typeof Symbol.iterator; "%Symbol.match%": typeof Symbol.match; "%Symbol.matchAll%": typeof Symbol.matchAll; "%Symbol.replace%": typeof Symbol.replace; "%Symbol.search%": typeof Symbol.search; "%Symbol.species%": typeof Symbol.species; "%Symbol.split%": typeof Symbol.split; "%Symbol.toPrimitive%": typeof Symbol.toPrimitive; "%Symbol.toStringTag%": typeof Symbol.toStringTag; "%Symbol.unscopables%": typeof Symbol.unscopables; "%SymbolPrototype.toString%": typeof Symbol.prototype.toString; "%SymbolPrototype.valueOf%": typeof Symbol.prototype.valueOf; "%SymbolPrototype.description%": (this: symbol | Symbol) => typeof Symbol.prototype.description; "%SyntaxError.prototype%": SyntaxError; "%SyntaxError.prototype.name%": typeof SyntaxError.prototype.name; "%SyntaxError.prototype.message%": typeof SyntaxError.prototype.message; "%SyntaxErrorPrototype.name%": typeof SyntaxError.prototype.name; "%SyntaxErrorPrototype.message%": typeof SyntaxError.prototype.message; "%TypedArray.prototype%": TypedArrayPrototype; "%TypedArray.prototype.buffer%": (this: TypedArray) => TypedArrayPrototype["buffer"]; "%TypedArray.prototype.byteLength%": (this: TypedArray) => TypedArrayPrototype["byteLength"]; "%TypedArray.prototype.byteOffset%": (this: TypedArray) => TypedArrayPrototype["byteOffset"]; "%TypedArray.prototype.length%": (this: TypedArray) => TypedArrayPrototype["length"]; "%TypedArray.prototype.entries%": TypedArrayPrototype["entries"]; "%TypedArray.prototype.keys%": TypedArrayPrototype["keys"]; "%TypedArray.prototype.values%": TypedArrayPrototype["values"]; "%TypedArray.prototype.copyWithin%": TypedArrayPrototype["copyWithin"]; "%TypedArray.prototype.every%": TypedArrayPrototype["every"]; "%TypedArray.prototype.fill%": TypedArrayPrototype["fill"]; "%TypedArray.prototype.filter%": TypedArrayPrototype["filter"]; "%TypedArray.prototype.find%": TypedArrayPrototype["find"]; "%TypedArray.prototype.findIndex%": TypedArrayPrototype["findIndex"]; "%TypedArray.prototype.forEach%": TypedArrayPrototype["forEach"]; "%TypedArray.prototype.includes%": TypedArrayPrototype["includes"]; "%TypedArray.prototype.indexOf%": TypedArrayPrototype["indexOf"]; "%TypedArray.prototype.join%": TypedArrayPrototype["join"]; "%TypedArray.prototype.lastIndexOf%": TypedArrayPrototype["lastIndexOf"]; "%TypedArray.prototype.map%": TypedArrayPrototype["map"]; "%TypedArray.prototype.reverse%": TypedArrayPrototype["reverse"]; "%TypedArray.prototype.reduce%": TypedArrayPrototype["reduce"]; "%TypedArray.prototype.reduceRight%": TypedArrayPrototype["reduceRight"]; "%TypedArray.prototype.set%": TypedArrayPrototype["set"]; "%TypedArray.prototype.slice%": TypedArrayPrototype["slice"]; "%TypedArray.prototype.some%": TypedArrayPrototype["some"]; "%TypedArray.prototype.sort%": TypedArrayPrototype["sort"]; "%TypedArray.prototype.subarray%": TypedArrayPrototype["subarray"]; "%TypedArray.prototype.toLocaleString%": TypedArrayPrototype["toLocaleString"]; "%TypedArray.prototype.toString%": TypedArrayPrototype["toString"]; "%TypedArray.of%": TypedArrayConstructor["of"]; "%TypedArray.from%": TypedArrayConstructor["from"]; "%TypedArrayPrototype.buffer%": (this: TypedArray) => TypedArrayPrototype["buffer"]; "%TypedArrayPrototype.byteLength%": (this: TypedArray) => TypedArrayPrototype["byteLength"]; "%TypedArrayPrototype.byteOffset%": (this: TypedArray) => TypedArrayPrototype["byteOffset"]; "%TypedArrayPrototype.length%": (this: TypedArray) => TypedArrayPrototype["length"]; "%TypedArrayPrototype.entries%": TypedArrayPrototype["entries"]; "%TypedArrayPrototype.keys%": TypedArrayPrototype["keys"]; "%TypedArrayPrototype.values%": TypedArrayPrototype["values"]; "%TypedArrayPrototype.copyWithin%": TypedArrayPrototype["copyWithin"]; "%TypedArrayPrototype.every%": TypedArrayPrototype["every"]; "%TypedArrayPrototype.fill%": TypedArrayPrototype["fill"]; "%TypedArrayPrototype.filter%": TypedArrayPrototype["filter"]; "%TypedArrayPrototype.find%": TypedArrayPrototype["find"]; "%TypedArrayPrototype.findIndex%": TypedArrayPrototype["findIndex"]; "%TypedArrayPrototype.forEach%": TypedArrayPrototype["forEach"]; "%TypedArrayPrototype.includes%": TypedArrayPrototype["includes"]; "%TypedArrayPrototype.indexOf%": TypedArrayPrototype["indexOf"]; "%TypedArrayPrototype.join%": TypedArrayPrototype["join"]; "%TypedArrayPrototype.lastIndexOf%": TypedArrayPrototype["lastIndexOf"]; "%TypedArrayPrototype.map%": TypedArrayPrototype["map"]; "%TypedArrayPrototype.reverse%": TypedArrayPrototype["reverse"]; "%TypedArrayPrototype.reduce%": TypedArrayPrototype["reduce"]; "%TypedArrayPrototype.reduceRight%": TypedArrayPrototype["reduceRight"]; "%TypedArrayPrototype.set%": TypedArrayPrototype["set"]; "%TypedArrayPrototype.slice%": TypedArrayPrototype["slice"]; "%TypedArrayPrototype.some%": TypedArrayPrototype["some"]; "%TypedArrayPrototype.sort%": TypedArrayPrototype["sort"]; "%TypedArrayPrototype.subarray%": TypedArrayPrototype["subarray"]; "%TypedArrayPrototype.toLocaleString%": TypedArrayPrototype["toLocaleString"]; "%TypedArrayPrototype.toString%": TypedArrayPrototype["toString"]; "%TypeError.prototype%": TypeError; "%TypeError.prototype.name%": typeof TypeError.prototype.name; "%TypeError.prototype.message%": typeof TypeError.prototype.message; "%TypeErrorPrototype.name%": typeof TypeError.prototype.name; "%TypeErrorPrototype.message%": typeof TypeError.prototype.message; "%Uint8Array.prototype%": Uint8Array; "%Uint8Array.prototype.BYTES_PER_ELEMENT%": typeof Uint8Array.prototype.BYTES_PER_ELEMENT; "%Uint8Array.BYTES_PER_ELEMENT%": typeof Uint8Array.BYTES_PER_ELEMENT; "%Uint8ArrayPrototype.BYTES_PER_ELEMENT%": typeof Uint8Array.prototype.BYTES_PER_ELEMENT; "%Uint8ClampedArray.prototype%": Uint8ClampedArray; "%Uint8ClampedArray.prototype.BYTES_PER_ELEMENT%": typeof Uint8ClampedArray.prototype.BYTES_PER_ELEMENT; "%Uint8ClampedArray.BYTES_PER_ELEMENT%": typeof Uint8ClampedArray.BYTES_PER_ELEMENT; "%Uint8ClampedArrayPrototype.BYTES_PER_ELEMENT%": typeof Uint8ClampedArray.prototype.BYTES_PER_ELEMENT; "%Uint16Array.prototype%": Uint16Array; "%Uint16Array.prototype.BYTES_PER_ELEMENT%": typeof Uint16Array.prototype.BYTES_PER_ELEMENT; "%Uint16Array.BYTES_PER_ELEMENT%": typeof Uint16Array.BYTES_PER_ELEMENT; "%Uint16ArrayPrototype.BYTES_PER_ELEMENT%": typeof Uint16Array.prototype.BYTES_PER_ELEMENT; "%Uint32Array.prototype%": Uint32Array; "%Uint32Array.prototype.BYTES_PER_ELEMENT%": typeof Uint32Array.prototype.BYTES_PER_ELEMENT; "%Uint32Array.BYTES_PER_ELEMENT%": typeof Uint32Array.BYTES_PER_ELEMENT; "%Uint32ArrayPrototype.BYTES_PER_ELEMENT%": typeof Uint32Array.prototype.BYTES_PER_ELEMENT; "%URIError.prototype%": URIError; "%URIError.prototype.name%": typeof URIError.prototype.name; "%URIError.prototype.message%": typeof URIError.prototype.message; "%URIErrorPrototype.name%": typeof URIError.prototype.name; "%URIErrorPrototype.message%": typeof URIError.prototype.message; "%WeakMap.prototype%": typeof WeakMap.prototype; "%WeakMap.prototype.delete%": typeof WeakMap.prototype.delete; "%WeakMap.prototype.get%": typeof WeakMap.prototype.get; "%WeakMap.prototype.set%": typeof WeakMap.prototype.set; "%WeakMap.prototype.has%": typeof WeakMap.prototype.has; "%WeakMapPrototype.delete%": typeof WeakMap.prototype.delete; "%WeakMapPrototype.get%": typeof WeakMap.prototype.get; "%WeakMapPrototype.set%": typeof WeakMap.prototype.set; "%WeakMapPrototype.has%": typeof WeakMap.prototype.has; "%WeakSet.prototype%": typeof WeakSet.prototype; "%WeakSet.prototype.delete%": typeof WeakSet.prototype.delete; "%WeakSet.prototype.has%": typeof WeakSet.prototype.has; "%WeakSet.prototype.add%": typeof WeakSet.prototype.add; "%WeakSetPrototype.delete%": typeof WeakSet.prototype.delete; "%WeakSetPrototype.has%": typeof WeakSet.prototype.has; "%WeakSetPrototype.add%": typeof WeakSet.prototype.add; } }