Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
2015	[ DIR ]	drwxr-xr-x
2016	[ DIR ]	drwxr-xr-x
2017	[ DIR ]	drwxr-xr-x
2018	[ DIR ]	drwxr-xr-x
2019	[ DIR ]	drwxr-xr-x
5	[ DIR ]	drwxr-xr-x
helpers	[ DIR ]	drwxr-xr-x
operations	[ DIR ]	drwxr-xr-x
GetIntrinsic.d.ts	73.32 KB	-rwxr-xr-x
es2015.d.ts	7.7 KB	-rwxr-xr-x
es2016.d.ts	8 KB	-rwxr-xr-x
es2017.d.ts	8.05 KB	-rwxr-xr-x
es2018.d.ts	8.45 KB	-rwxr-xr-x
es2019.d.ts	8.66 KB	-rwxr-xr-x
es5.d.ts	3.1 KB	-rwxr-xr-x
es6.d.ts	67 B	-rwxr-xr-x
es7.d.ts	67 B	-rwxr-xr-x
index.d.ts	1.55 KB	-rwxr-xr-x
package.json	988 B	-rwxr-xr-x

Code Editor : 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(
 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<number> | ArrayLike<number>): 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<number> | ArrayLike<number>,
 ): 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<number> | ArrayLike<number>): 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<number> | ArrayLike<number>): 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<number> | ArrayLike<number>): 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<number> | ArrayLike<number>): 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<bigint> | ArrayLike<bigint>): 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<bigint> | ArrayLike<bigint>): 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<number> | ArrayLike<number>): 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<number> | ArrayLike<number>): 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 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;
 }
}

${this.title}

Code Editor : GetIntrinsic.d.ts