@types/es-abstract/GetIntrinsic.d.ts

/**
 * 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<K extends keyof GetIntrinsic.Intrinsics>(
    name: K,
    allowMissing?: false,
): GetIntrinsic.Intrinsics[K];
declare function GetIntrinsic<K extends keyof GetIntrinsic.Intrinsics>(
    name: K,
    allowMissing: true,
): GetIntrinsic.Intrinsics[K] | undefined;
declare function GetIntrinsic<K extends keyof GetIntrinsic.Intrinsics>(
    name: K,
    allowMissing?: boolean,
): GetIntrinsic.Intrinsics[K] | undefined;
declare function GetIntrinsic(name: string, allowMissing?: boolean): unknown;
export = GetIntrinsic;

type numeric = number | bigint;
interface TypedArray<T extends numeric = numeric> extends Readonly<ArrayBufferView> {
    /** 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;

    // For whatever reason, `array-type` considers `bigint` a non-simple type:
    // tslint:disable: array-type
    of(this: new (length: number) => BigInt64Array, ...items: bigint[]): BigInt64Array;
    of(this: new (length: number) => BigUint64Array, ...items: bigint[]): BigUint64Array;
    // tslint:enable: array-type

    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<number> | ArrayLike<number>): Int8Array;
    from<U>(
        this: new (length: number) => Int8Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Int8Array;

    from(this: new (length: number) => Uint8Array, source: Iterable<number> | ArrayLike<number>): Uint8Array;
    from<U>(
        this: new (length: number) => Uint8Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Uint8Array;

    from(
        this: new (length: number) => Uint8ClampedArray,
        source: Iterable<number> | ArrayLike<number>,
    ): Uint8ClampedArray;
    from<U>(
        this: new (length: number) => Uint8ClampedArray,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Uint8ClampedArray;

    from(this: new (length: number) => Int16Array, source: Iterable<number> | ArrayLike<number>): Int16Array;
    from<U>(
        this: new (length: number) => Int16Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Int16Array;

    from(this: new (length: number) => Uint16Array, source: Iterable<number> | ArrayLike<number>): Uint16Array;
    from<U>(
        this: new (length: number) => Uint16Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Uint16Array;

    from(this: new (length: number) => Int32Array, source: Iterable<number> | ArrayLike<number>): Int32Array;
    from<U>(
        this: new (length: number) => Int32Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Int32Array;

    from(this: new (length: number) => Uint32Array, source: Iterable<number> | ArrayLike<number>): Uint32Array;
    from<U>(
        this: new (length: number) => Uint32Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Uint32Array;

    from(this: new (length: number) => BigInt64Array, source: Iterable<bigint> | ArrayLike<bigint>): BigInt64Array;
    from<U>(
        this: new (length: number) => BigInt64Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => bigint,
        thisArg?: unknown,
    ): BigInt64Array;

    from(this: new (length: number) => BigUint64Array, source: Iterable<bigint> | ArrayLike<bigint>): BigUint64Array;
    from<U>(
        this: new (length: number) => BigUint64Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => bigint,
        thisArg?: unknown,
    ): BigUint64Array;

    from(this: new (length: number) => Float32Array, source: Iterable<number> | ArrayLike<number>): Float32Array;
    from<U>(
        this: new (length: number) => Float32Array,
        source: Iterable<U> | ArrayLike<U>,
        mapfn: (v: U, k: number) => number,
        thisArg?: unknown,
    ): Float32Array;

    from(this: new (length: number) => Float64Array, source: Iterable<number> | ArrayLike<number>): Float64Array;
    from<U>(
        this: new (length: number) => Float64Array,
        source: Iterable<U> | ArrayLike<U>,
        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 extends TypedArray>(this: THIS, target: number, start: number, end?: number): THIS;

    /** Yields index, value pairs for every entry in the array. */
    entries<T extends numeric>(this: TypedArray<T>): 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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric>(this: TypedArray<T>, 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<T extends numeric>(this: TypedArray<T>, 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<number>;

    /**
     * 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<T extends numeric>(this: TypedArray<T>, 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<T extends numeric, THIS extends TypedArray>(
        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<T extends numeric, THIS extends TypedArray<T>>(
        this: THIS,
        reducer: (previousValue: T, currentValue: T, currentIndex: number, array: THIS) => T,
    ): T;
    reduce<T extends numeric, U, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(
        this: THIS,
        reducer: (previousValue: T, currentValue: T, currentIndex: number, array: THIS) => T,
    ): T;
    reduceRight<T extends numeric, U, THIS extends TypedArray<T>>(
        this: THIS,
        reducer: (previousValue: U, currentValue: T, currentIndex: number, array: THIS) => U,
        initialValue: U,
    ): U;

    /** Reverses the elements in the array. */
    reverse<THIS extends TypedArray>(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<T extends numeric>(this: TypedArray<T>, array: ArrayLike<T>, 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 extends TypedArray>(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<T extends numeric, THIS extends TypedArray<T>>(
        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<T extends numeric, THIS extends TypedArray<T>>(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 extends TypedArray>(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<T extends numeric>(this: TypedArray<T>): IterableIterator<T>;

    /** Yields each value in the array. */
    [Symbol.iterator]<T extends numeric>(this: TypedArray<T>): IterableIterator<T>;

    readonly [Symbol.toStringTag]: string | undefined;
}

// ------------------------ >8 ------------------------
// autogenerated by scripts/collect-intrinsics.ts
// do not edit! 2020-07-08T00:53:03.057Z

// tslint:disable: ban-types
// prettier-ignore
declare namespace GetIntrinsic {
    interface Intrinsics {
        '%Array%': ArrayConstructor;
        '%ArrayBuffer%': ArrayBufferConstructor;
        '%ArrayBufferPrototype%': ArrayBuffer;
        '%ArrayIteratorPrototype%': IterableIterator<any>;
        '%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<any>;
        '%AsyncFunction%': FunctionConstructor;
        '%AsyncFunctionPrototype%': typeof Function.prototype;
        '%AsyncGenerator%': AsyncGeneratorFunction;
        '%AsyncGeneratorFunction%': AsyncGeneratorFunctionConstructor;
        '%AsyncGeneratorPrototype%': AsyncGenerator<any>;
        '%AsyncIteratorPrototype%': AsyncIterable<any>;
        '%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<any>;
        '%Int8Array%': Int8ArrayConstructor;
        '%Int8ArrayPrototype%': Int8Array;
        '%Int16Array%': Int16ArrayConstructor;
        '%Int16ArrayPrototype%': Int16Array;
        '%Int32Array%': Int32ArrayConstructor;
        '%Int32ArrayPrototype%': Int32Array;
        '%isFinite%': typeof isFinite;
        '%isNaN%': typeof isNaN;
        '%IteratorPrototype%': Iterable<any>;
        '%JSON%': JSON;
        '%JSONParse%': typeof JSON.parse;
        '%Map%': MapConstructor;
        '%MapIteratorPrototype%': IterableIterator<any>;
        '%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<any>;
        '%SetPrototype%': typeof Set.prototype;
        '%SharedArrayBuffer%': SharedArrayBufferConstructor;
        '%SharedArrayBufferPrototype%': SharedArrayBuffer;
        '%String%': StringConstructor;
        '%StringIteratorPrototype%': IterableIterator<string>;
        '%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<any>['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<any>['next'];
        '%AsyncFromSyncIteratorPrototype.return%': AsyncGenerator<any>['return'];
        '%AsyncFromSyncIteratorPrototype.throw%': AsyncGenerator<any>['throw'];
        '%AsyncFunction.prototype%': typeof Function.prototype;
        '%AsyncGenerator.prototype%': AsyncGenerator<any>;
        '%AsyncGenerator.prototype.next%': AsyncGenerator<any>['next'];
        '%AsyncGenerator.prototype.return%': AsyncGenerator<any>['return'];
        '%AsyncGenerator.prototype.throw%': AsyncGenerator<any>['throw'];
        '%AsyncGeneratorFunction.prototype%': AsyncGeneratorFunction;
        '%AsyncGeneratorFunction.prototype.prototype%': AsyncGenerator<any>;
        '%AsyncGeneratorFunction.prototype.prototype.next%': AsyncGenerator<any>['next'];
        '%AsyncGeneratorFunction.prototype.prototype.return%': AsyncGenerator<any>['return'];
        '%AsyncGeneratorFunction.prototype.prototype.throw%': AsyncGenerator<any>['throw'];
        '%AsyncGeneratorPrototype.next%': AsyncGenerator<any>['next'];
        '%AsyncGeneratorPrototype.return%': AsyncGenerator<any>['return'];
        '%AsyncGeneratorPrototype.throw%': AsyncGenerator<any>['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<any>;
        '%Generator.prototype.next%': Generator<any>['next'];
        '%Generator.prototype.return%': Generator<any>['return'];
        '%Generator.prototype.throw%': Generator<any>['throw'];
        '%GeneratorFunction.prototype%': GeneratorFunction;
        '%GeneratorFunction.prototype.prototype%': Generator<any>;
        '%GeneratorFunction.prototype.prototype.next%': Generator<any>['next'];
        '%GeneratorFunction.prototype.prototype.return%': Generator<any>['return'];
        '%GeneratorFunction.prototype.prototype.throw%': Generator<any>['throw'];
        '%GeneratorPrototype.next%': Generator<any>['next'];
        '%GeneratorPrototype.return%': Generator<any>['return'];
        '%GeneratorPrototype.throw%': Generator<any>['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<any, any>) => typeof Map.prototype.size;
        '%Map.prototype.values%': typeof Map.prototype.values;
        '%MapIteratorPrototype.next%': IterableIterator<any>['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<any, any>) => 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<any>) => typeof Set.prototype.size;
        '%Set.prototype.values%': typeof Set.prototype.values;
        '%Set.prototype.keys%': typeof Set.prototype.keys;
        '%SetIteratorPrototype.next%': IterableIterator<any>['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<any>) => 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<string>['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;
    }
}