// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.

// Based on https://github.com/nodejs/node/blob/889ad35d3d41e376870f785b0c1b669cb732013d/typings/primordials.d.ts
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// This file subclasses and stores the JS builtins that come from the VM
// so that Node.js's builtin modules do not need to later look these up from
// the global proxy, which can be mutated by users.

/// <reference no-default-lib="true" />
/// <reference lib="esnext" />

declare namespace __bootstrap {
  /**
   * Primordials are a way to safely use globals without fear of global mutation
   * Generally, this means removing `this` parameter usage and instead using
   * a regular parameter:
   *
   * @example
   *
   * ```js
   * 'thing'.startsWith('hello');
   * ```
   *
   * becomes
   *
   * ```js
   * primordials.StringPrototypeStartsWith('thing', 'hello')
   * ```
   */
  declare namespace primordials {
    type UncurryThis<T extends (this: unknown, ...args: unknown[]) => unknown> =
      (self: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
    type UncurryThisStaticApply<
      T extends (this: unknown, ...args: unknown[]) => unknown,
    > = (self: ThisParameterType<T>, args: Parameters<T>) => ReturnType<T>;
    type StaticApply<T extends (this: unknown, ...args: unknown[]) => unknown> =
      (args: Parameters<T>) => ReturnType<T>;

    export function uncurryThis<T extends (...args: unknown[]) => unknown>(
      fn: T,
    ): (self: ThisType<T>, ...args: Parameters<T>) => ReturnType<T>;
    export function applyBind<T extends (...args: unknown[]) => unknown>(
      fn: T,
    ): (self: ThisType<T>, args: Parameters<T>) => ReturnType<T>;

    // safe objects
    export function makeSafe<T extends NewableFunction>(
      unsafe: NewableFunction,
      safe: T,
    ): T;
    export const SafeMap: typeof globalThis.Map;
    export const SafeWeakMap: typeof globalThis.WeakMap;
    export const SafeSet: typeof globalThis.Set;
    export const SafeWeakSet: typeof globalThis.WeakSet;
    export const SafeFinalizationRegistry:
      typeof globalThis.FinalizationRegistry;
    export const SafeWeakRef: typeof globalThis.WeakRef;
    export const SafePromiseAll: typeof Promise.all;
    // NOTE: Uncomment the following functions when you need to use them
    // export const SafePromiseAllSettled: typeof Promise.allSettled;
    // export const SafePromiseAny: typeof Promise.any;
    // export const SafePromiseRace: typeof Promise.race;
    export const SafePromisePrototypeFinally: UncurryThis<
      Promise.prototype.finally
    >;
    export const SafeRegExp: typeof RegExp;

    // safe iterators
    export const SafeArrayIterator: new <T>(array: T[]) => IterableIterator<T>;
    export const SafeSetIterator: new <T>(set: Set<T>) => IterableIterator<T>;
    export const SafeMapIterator: new <K, V>(
      map: Map<K, V>,
    ) => IterableIterator<[K, V]>;
    export const SafeStringIterator: new (
      str: string,
    ) => IterableIterator<string>;

    // intrinsic objects
    export const indirectEval: typeof globalThis.eval;
    export const isNaN: typeof globalThis.isNaN;
    export const decodeURI: typeof globalThis.decodeURI;
    export const decodeURIComponent: typeof globalThis.decodeURIComponent;
    export const encodeURI: typeof globalThis.encodeURI;
    export const encodeURIComponent: typeof globalThis.encodeURIComponent;
    export const queueMicrotask: typeof globalThis.queueMicrotask;
    export const setQueueMicrotask: (
      queueMicrotask: typeof globalThis.queueMicrotask,
    ) => void;
    export const JSONParse: typeof JSON.parse;
    export const JSONStringify: typeof JSON.stringify;
    export const MathAbs: typeof Math.abs;
    export const MathAcos: typeof Math.acos;
    export const MathAcosh: typeof Math.acosh;
    export const MathAsin: typeof Math.asin;
    export const MathAsinh: typeof Math.asinh;
    export const MathAtan: typeof Math.atan;
    export const MathAtanh: typeof Math.atanh;
    export const MathAtan2: typeof Math.atan2;
    export const MathCeil: typeof Math.ceil;
    export const MathCbrt: typeof Math.cbrt;
    export const MathExpm1: typeof Math.expm1;
    export const MathClz32: typeof Math.clz32;
    export const MathCos: typeof Math.cos;
    export const MathCosh: typeof Math.cosh;
    export const MathExp: typeof Math.exp;
    export const MathFloor: typeof Math.floor;
    export const MathFround: typeof Math.fround;
    export const MathHypot: typeof Math.hypot;
    export const MathHypotApply: StaticApply<typeof Math.hypot>;
    export const MathImul: typeof Math.imul;
    export const MathLog: typeof Math.log;
    export const MathLog1p: typeof Math.log1p;
    export const MathLog2: typeof Math.log2;
    export const MathLog10: typeof Math.log10;
    export const MathMax: typeof Math.max;
    export const MathMaxApply: StaticApply<typeof Math.max>;
    export const MathMin: typeof Math.min;
    export const MathMinApply: StaticApply<typeof Math.min>;
    export const MathPow: typeof Math.pow;
    export const MathRandom: typeof Math.random;
    export const MathRound: typeof Math.round;
    export const MathSign: typeof Math.sign;
    export const MathSin: typeof Math.sin;
    export const MathSinh: typeof Math.sinh;
    export const MathSqrt: typeof Math.sqrt;
    export const MathTan: typeof Math.tan;
    export const MathTanh: typeof Math.tanh;
    export const MathTrunc: typeof Math.trunc;
    export const MathE: typeof Math.E;
    export const MathLN10: typeof Math.LN10;
    export const MathLN2: typeof Math.LN2;
    export const MathLOG10E: typeof Math.LOG10E;
    export const MathLOG2E: typeof Math.LOG2E;
    export const MathPI: typeof Math.PI;
    export const MathSQRT1_2: typeof Math.SQRT1_2;
    export const MathSQRT2: typeof Math.SQRT2;
    export const Proxy: typeof globalThis.Proxy;
    export const ProxyLength: typeof Proxy.length;
    export const ProxyName: typeof Proxy.name;
    export const ProxyRevocable: typeof Proxy.revocable;
    export const ReflectDefineProperty: typeof Reflect.defineProperty;
    export const ReflectDeleteProperty: typeof Reflect.deleteProperty;
    export const ReflectApply: typeof Reflect.apply;
    export const ReflectConstruct: typeof Reflect.construct;
    export const ReflectGet: typeof Reflect.get;
    export const ReflectGetOwnPropertyDescriptor:
      typeof Reflect.getOwnPropertyDescriptor;
    export const ReflectGetPrototypeOf: typeof Reflect.getPrototypeOf;
    export const ReflectHas: typeof Reflect.has;
    export const ReflectIsExtensible: typeof Reflect.isExtensible;
    export const ReflectOwnKeys: typeof Reflect.ownKeys;
    export const ReflectPreventExtensions: typeof Reflect.preventExtensions;
    export const ReflectSet: typeof Reflect.set;
    export const ReflectSetPrototypeOf: typeof Reflect.setPrototypeOf;
    export const AggregateError: typeof globalThis.AggregateError;
    export const AggregateErrorLength: typeof AggregateError.length;
    export const AggregateErrorName: typeof AggregateError.name;
    export const AggregateErrorPrototype: typeof AggregateError.prototype;
    export const Array: typeof globalThis.Array;
    export const ArrayLength: typeof Array.length;
    export const ArrayName: typeof Array.name;
    export const ArrayPrototype: typeof Array.prototype;
    export const ArrayIsArray: typeof Array.isArray;
    export const ArrayFrom: typeof Array.from;
    export const ArrayOf: typeof Array.of;
    export const ArrayOfApply: StaticApply<typeof Array.of>;
    export const ArrayPrototypeAt: UncurryThis<typeof Array.prototype.at>;
    export const ArrayPrototypeConcat: UncurryThis<
      typeof Array.prototype.concat
    >;
    export const ArrayPrototypeCopyWithin: UncurryThis<
      typeof Array.prototype.copyWithin
    >;
    export const ArrayPrototypeFill: UncurryThis<typeof Array.prototype.fill>;
    export const ArrayPrototypeFind: UncurryThis<typeof Array.prototype.find>;
    export const ArrayPrototypeFindIndex: UncurryThis<
      typeof Array.prototype.findIndex
    >;
    export const ArrayPrototypeLastIndexOf: UncurryThis<
      typeof Array.prototype.lastIndexOf
    >;
    export const ArrayPrototypePop: UncurryThis<typeof Array.prototype.pop>;
    export const ArrayPrototypePush: UncurryThis<typeof Array.prototype.push>;
    export const ArrayPrototypePushApply: UncurryThisStaticApply<
      typeof Array.prototype.push
    >;
    export const ArrayPrototypeReverse: UncurryThis<
      typeof Array.prototype.reverse
    >;
    export const ArrayPrototypeShift: UncurryThis<typeof Array.prototype.shift>;
    export const ArrayPrototypeUnshift: UncurryThis<
      typeof Array.prototype.unshift
    >;
    export const ArrayPrototypeUnshiftApply: UncurryThisStaticApply<
      typeof Array.prototype.unshift
    >;
    export const ArrayPrototypeSlice: UncurryThis<typeof Array.prototype.slice>;
    export const ArrayPrototypeSort: UncurryThis<typeof Array.prototype.sort>;
    export const ArrayPrototypeSplice: UncurryThis<
      typeof Array.prototype.splice
    >;
    export const ArrayPrototypeIncludes: UncurryThis<
      typeof Array.prototype.includes
    >;
    export const ArrayPrototypeIndexOf: UncurryThis<
      typeof Array.prototype.indexOf
    >;
    export const ArrayPrototypeJoin: UncurryThis<typeof Array.prototype.join>;
    export const ArrayPrototypeKeys: UncurryThis<typeof Array.prototype.keys>;
    export const ArrayPrototypeEntries: UncurryThis<
      typeof Array.prototype.entries
    >;
    export const ArrayPrototypeValues: UncurryThis<
      typeof Array.prototype.values
    >;
    export const ArrayPrototypeForEach: UncurryThis<
      typeof Array.prototype.forEach
    >;
    export const ArrayPrototypeFilter: UncurryThis<
      typeof Array.prototype.filter
    >;
    export const ArrayPrototypeFlat: UncurryThis<typeof Array.prototype.flat>;
    export const ArrayPrototypeFlatMap: UncurryThis<
      typeof Array.prototype.flatMap
    >;
    export const ArrayPrototypeMap: UncurryThis<typeof Array.prototype.map>;
    export const ArrayPrototypeEvery: UncurryThis<typeof Array.prototype.every>;
    export const ArrayPrototypeSome: UncurryThis<typeof Array.prototype.some>;
    export const ArrayPrototypeReduce: UncurryThis<
      typeof Array.prototype.reduce
    >;
    export const ArrayPrototypeReduceRight: UncurryThis<
      typeof Array.prototype.reduceRight
    >;
    export const ArrayPrototypeToLocaleString: UncurryThis<
      typeof Array.prototype.toLocaleString
    >;
    export const ArrayPrototypeToString: UncurryThis<
      typeof Array.prototype.toString
    >;
    export const ArrayBuffer: typeof globalThis.ArrayBuffer;
    export const ArrayBufferLength: typeof ArrayBuffer.length;
    export const ArrayBufferName: typeof ArrayBuffer.name;
    export const ArrayBufferIsView: typeof ArrayBuffer.isView;
    export const ArrayBufferPrototype: typeof ArrayBuffer.prototype;
    export const ArrayBufferPrototypeGetByteLength: (
      buffer: ArrayBuffer,
    ) => number;
    export const ArrayBufferPrototypeSlice: UncurryThis<
      typeof ArrayBuffer.prototype.slice
    >;
    export const BigInt: typeof globalThis.BigInt;
    export const BigIntLength: typeof BigInt.length;
    export const BigIntName: typeof BigInt.name;
    export const BigIntPrototype: typeof BigInt.prototype;
    export const BigIntAsUintN: typeof BigInt.asUintN;
    export const BigIntAsIntN: typeof BigInt.asIntN;
    export const BigIntPrototypeToLocaleString: UncurryThis<
      typeof BigInt.prototype.toLocaleString
    >;
    export const BigIntPrototypeToString: UncurryThis<
      typeof BigInt.prototype.toString
    >;
    export const BigIntPrototypeValueOf: UncurryThis<
      typeof BigInt.prototype.valueOf
    >;
    export const BigInt64Array: typeof globalThis.BigInt64Array;
    export const BigInt64ArrayLength: typeof BigInt64Array.length;
    export const BigInt64ArrayName: typeof BigInt64Array.name;
    export const BigInt64ArrayPrototype: typeof BigInt64Array.prototype;
    export const BigInt64ArrayBYTES_PER_ELEMENT:
      typeof BigInt64Array.BYTES_PER_ELEMENT;
    export const BigUint64Array: typeof globalThis.BigUint64Array;
    export const BigUint64ArrayLength: typeof BigUint64Array.length;
    export const BigUint64ArrayName: typeof BigUint64Array.name;
    export const BigUint64ArrayPrototype: typeof BigUint64Array.prototype;
    export const BigUint64ArrayBYTES_PER_ELEMENT:
      typeof BigUint64Array.BYTES_PER_ELEMENT;
    export const Boolean: typeof globalThis.Boolean;
    export const BooleanLength: typeof Boolean.length;
    export const BooleanName: typeof Boolean.name;
    export const BooleanPrototype: typeof Boolean.prototype;
    export const BooleanPrototypeToString: UncurryThis<
      typeof Boolean.prototype.toString
    >;
    export const BooleanPrototypeValueOf: UncurryThis<
      typeof Boolean.prototype.valueOf
    >;
    export const DataView: typeof globalThis.DataView;
    export const DataViewLength: typeof DataView.length;
    export const DataViewName: typeof DataView.name;
    export const DataViewPrototype: typeof DataView.prototype;
    export const DataViewPrototypeGetBuffer: (
      view: DataView,
    ) => ArrayBuffer | SharedArrayBuffer;
    export const DataViewPrototypeGetByteLength: (view: DataView) => number;
    export const DataViewPrototypeGetByteOffset: (view: DataView) => number;
    export const DataViewPrototypeGetInt8: UncurryThis<
      typeof DataView.prototype.getInt8
    >;
    export const DataViewPrototypeSetInt8: UncurryThis<
      typeof DataView.prototype.setInt8
    >;
    export const DataViewPrototypeGetUint8: UncurryThis<
      typeof DataView.prototype.getUint8
    >;
    export const DataViewPrototypeSetUint8: UncurryThis<
      typeof DataView.prototype.setUint8
    >;
    export const DataViewPrototypeGetInt16: UncurryThis<
      typeof DataView.prototype.getInt16
    >;
    export const DataViewPrototypeSetInt16: UncurryThis<
      typeof DataView.prototype.setInt16
    >;
    export const DataViewPrototypeGetUint16: UncurryThis<
      typeof DataView.prototype.getUint16
    >;
    export const DataViewPrototypeSetUint16: UncurryThis<
      typeof DataView.prototype.setUint16
    >;
    export const DataViewPrototypeGetInt32: UncurryThis<
      typeof DataView.prototype.getInt32
    >;
    export const DataViewPrototypeSetInt32: UncurryThis<
      typeof DataView.prototype.setInt32
    >;
    export const DataViewPrototypeGetUint32: UncurryThis<
      typeof DataView.prototype.getUint32
    >;
    export const DataViewPrototypeSetUint32: UncurryThis<
      typeof DataView.prototype.setUint32
    >;
    export const DataViewPrototypeGetFloat32: UncurryThis<
      typeof DataView.prototype.getFloat32
    >;
    export const DataViewPrototypeSetFloat32: UncurryThis<
      typeof DataView.prototype.setFloat32
    >;
    export const DataViewPrototypeGetFloat64: UncurryThis<
      typeof DataView.prototype.getFloat64
    >;
    export const DataViewPrototypeSetFloat64: UncurryThis<
      typeof DataView.prototype.setFloat64
    >;
    export const DataViewPrototypeGetBigInt64: UncurryThis<
      typeof DataView.prototype.getBigInt64
    >;
    export const DataViewPrototypeSetBigInt64: UncurryThis<
      typeof DataView.prototype.setBigInt64
    >;
    export const DataViewPrototypeGetBigUint64: UncurryThis<
      typeof DataView.prototype.getBigUint64
    >;
    export const DataViewPrototypeSetBigUint64: UncurryThis<
      typeof DataView.prototype.setBigUint64
    >;
    export const Date: typeof globalThis.Date;
    export const DateLength: typeof Date.length;
    export const DateName: typeof Date.name;
    export const DatePrototype: typeof Date.prototype;
    export const DateNow: typeof Date.now;
    export const DateParse: typeof Date.parse;
    export const DateUTC: typeof Date.UTC;
    export const DatePrototypeToString: UncurryThis<
      typeof Date.prototype.toString
    >;
    export const DatePrototypeToDateString: UncurryThis<
      typeof Date.prototype.toDateString
    >;
    export const DatePrototypeToTimeString: UncurryThis<
      typeof Date.prototype.toTimeString
    >;
    export const DatePrototypeToISOString: UncurryThis<
      typeof Date.prototype.toISOString
    >;
    export const DatePrototypeToUTCString: UncurryThis<
      typeof Date.prototype.toUTCString
    >;
    export const DatePrototypeToGMTString: UncurryThis<
      typeof Date.prototype.toGMTString
    >;
    export const DatePrototypeGetDate: UncurryThis<
      typeof Date.prototype.getDate
    >;
    export const DatePrototypeSetDate: UncurryThis<
      typeof Date.prototype.setDate
    >;
    export const DatePrototypeGetDay: UncurryThis<typeof Date.prototype.getDay>;
    export const DatePrototypeGetFullYear: UncurryThis<
      typeof Date.prototype.getFullYear
    >;
    export const DatePrototypeSetFullYear: UncurryThis<
      typeof Date.prototype.setFullYear
    >;
    export const DatePrototypeGetHours: UncurryThis<
      typeof Date.prototype.getHours
    >;
    export const DatePrototypeSetHours: UncurryThis<
      typeof Date.prototype.setHours
    >;
    export const DatePrototypeGetMilliseconds: UncurryThis<
      typeof Date.prototype.getMilliseconds
    >;
    export const DatePrototypeSetMilliseconds: UncurryThis<
      typeof Date.prototype.setMilliseconds
    >;
    export const DatePrototypeGetMinutes: UncurryThis<
      typeof Date.prototype.getMinutes
    >;
    export const DatePrototypeSetMinutes: UncurryThis<
      typeof Date.prototype.setMinutes
    >;
    export const DatePrototypeGetMonth: UncurryThis<
      typeof Date.prototype.getMonth
    >;
    export const DatePrototypeSetMonth: UncurryThis<
      typeof Date.prototype.setMonth
    >;
    export const DatePrototypeGetSeconds: UncurryThis<
      typeof Date.prototype.getSeconds
    >;
    export const DatePrototypeSetSeconds: UncurryThis<
      typeof Date.prototype.setSeconds
    >;
    export const DatePrototypeGetTime: UncurryThis<
      typeof Date.prototype.getTime
    >;
    export const DatePrototypeSetTime: UncurryThis<
      typeof Date.prototype.setTime
    >;
    export const DatePrototypeGetTimezoneOffset: UncurryThis<
      typeof Date.prototype.getTimezoneOffset
    >;
    export const DatePrototypeGetUTCDate: UncurryThis<
      typeof Date.prototype.getUTCDate
    >;
    export const DatePrototypeSetUTCDate: UncurryThis<
      typeof Date.prototype.setUTCDate
    >;
    export const DatePrototypeGetUTCDay: UncurryThis<
      typeof Date.prototype.getUTCDay
    >;
    export const DatePrototypeGetUTCFullYear: UncurryThis<
      typeof Date.prototype.getUTCFullYear
    >;
    export const DatePrototypeSetUTCFullYear: UncurryThis<
      typeof Date.prototype.setUTCFullYear
    >;
    export const DatePrototypeGetUTCHours: UncurryThis<
      typeof Date.prototype.getUTCHours
    >;
    export const DatePrototypeSetUTCHours: UncurryThis<
      typeof Date.prototype.setUTCHours
    >;
    export const DatePrototypeGetUTCMilliseconds: UncurryThis<
      typeof Date.prototype.getUTCMilliseconds
    >;
    export const DatePrototypeSetUTCMilliseconds: UncurryThis<
      typeof Date.prototype.setUTCMilliseconds
    >;
    export const DatePrototypeGetUTCMinutes: UncurryThis<
      typeof Date.prototype.getUTCMinutes
    >;
    export const DatePrototypeSetUTCMinutes: UncurryThis<
      typeof Date.prototype.setUTCMinutes
    >;
    export const DatePrototypeGetUTCMonth: UncurryThis<
      typeof Date.prototype.getUTCMonth
    >;
    export const DatePrototypeSetUTCMonth: UncurryThis<
      typeof Date.prototype.setUTCMonth
    >;
    export const DatePrototypeGetUTCSeconds: UncurryThis<
      typeof Date.prototype.getUTCSeconds
    >;
    export const DatePrototypeSetUTCSeconds: UncurryThis<
      typeof Date.prototype.setUTCSeconds
    >;
    export const DatePrototypeValueOf: UncurryThis<
      typeof Date.prototype.valueOf
    >;
    export const DatePrototypeGetYear: UncurryThis<
      typeof Date.prototype.getYear
    >;
    export const DatePrototypeSetYear: UncurryThis<
      typeof Date.prototype.setYear
    >;
    export const DatePrototypeToJSON: UncurryThis<typeof Date.prototype.toJSON>;
    export const DatePrototypeToLocaleString: UncurryThis<
      typeof Date.prototype.toLocaleString
    >;
    export const DatePrototypeToLocaleDateString: UncurryThis<
      typeof Date.prototype.toLocaleDateString
    >;
    export const DatePrototypeToLocaleTimeString: UncurryThis<
      typeof Date.prototype.toLocaleTimeString
    >;
    export const Error: typeof globalThis.Error;
    export const ErrorLength: typeof Error.length;
    export const ErrorName: typeof Error.name;
    export const ErrorPrototype: typeof Error.prototype;
    export const ErrorCaptureStackTrace: typeof Error.captureStackTrace;
    export const ErrorStackTraceLimit: typeof Error.stackTraceLimit;
    export const ErrorPrototypeToString: UncurryThis<
      typeof Error.prototype.toString
    >;
    export const EvalError: typeof globalThis.EvalError;
    export const EvalErrorLength: typeof EvalError.length;
    export const EvalErrorName: typeof EvalError.name;
    export const EvalErrorPrototype: typeof EvalError.prototype;
    export const FinalizationRegistry: typeof globalThis.FinalizationRegistry;
    export const FinalizationRegistryLength: typeof FinalizationRegistry.length;
    export const FinalizationRegistryName: typeof FinalizationRegistry.name;
    export const FinalizationRegistryPrototype:
      typeof FinalizationRegistry.prototype;
    export const FinalizationRegistryPrototypeRegister: UncurryThis<
      typeof FinalizationRegistry.prototype.register
    >;
    export const FinalizationRegistryPrototypeUnregister: UncurryThis<
      typeof FinalizationRegistry.prototype.unregister
    >;
    export const Float32Array: typeof globalThis.Float32Array;
    export const Float32ArrayLength: typeof Float32Array.length;
    export const Float32ArrayName: typeof Float32Array.name;
    export const Float32ArrayPrototype: typeof Float32Array.prototype;
    export const Float32ArrayBYTES_PER_ELEMENT:
      typeof Float32Array.BYTES_PER_ELEMENT;
    export const Float64Array: typeof globalThis.Float64Array;
    export const Float64ArrayLength: typeof Float64Array.length;
    export const Float64ArrayName: typeof Float64Array.name;
    export const Float64ArrayPrototype: typeof Float64Array.prototype;
    export const Float64ArrayBYTES_PER_ELEMENT:
      typeof Float64Array.BYTES_PER_ELEMENT;
    export const Function: typeof globalThis.Function;
    export const FunctionLength: typeof Function.length;
    export const FunctionName: typeof Function.name;
    export const FunctionPrototype: typeof Function.prototype;
    export const FunctionPrototypeApply: UncurryThis<
      typeof Function.prototype.apply
    >;
    export const FunctionPrototypeBind: UncurryThis<
      typeof Function.prototype.bind
    >;
    export const FunctionPrototypeCall: UncurryThis<
      typeof Function.prototype.call
    >;
    export const FunctionPrototypeToString: UncurryThis<
      typeof Function.prototype.toString
    >;
    export const Int16Array: typeof globalThis.Int16Array;
    export const Int16ArrayLength: typeof Int16Array.length;
    export const Int16ArrayName: typeof Int16Array.name;
    export const Int16ArrayPrototype: typeof Int16Array.prototype;
    export const Int16ArrayBYTES_PER_ELEMENT:
      typeof Int16Array.BYTES_PER_ELEMENT;
    export const Int32Array: typeof globalThis.Int32Array;
    export const Int32ArrayLength: typeof Int32Array.length;
    export const Int32ArrayName: typeof Int32Array.name;
    export const Int32ArrayPrototype: typeof Int32Array.prototype;
    export const Int32ArrayBYTES_PER_ELEMENT:
      typeof Int32Array.BYTES_PER_ELEMENT;
    export const Int8Array: typeof globalThis.Int8Array;
    export const Int8ArrayLength: typeof Int8Array.length;
    export const Int8ArrayName: typeof Int8Array.name;
    export const Int8ArrayPrototype: typeof Int8Array.prototype;
    export const Int8ArrayBYTES_PER_ELEMENT: typeof Int8Array.BYTES_PER_ELEMENT;
    export const Map: typeof globalThis.Map;
    export const MapLength: typeof Map.length;
    export const MapName: typeof Map.name;
    export const MapPrototype: typeof Map.prototype;
    export const MapPrototypeGetSize: (map: Map) => number;
    export const MapPrototypeGet: UncurryThis<typeof Map.prototype.get>;
    export const MapPrototypeSet: UncurryThis<typeof Map.prototype.set>;
    export const MapPrototypeHas: UncurryThis<typeof Map.prototype.has>;
    export const MapPrototypeDelete: UncurryThis<typeof Map.prototype.delete>;
    export const MapPrototypeClear: UncurryThis<typeof Map.prototype.clear>;
    export const MapPrototypeEntries: UncurryThis<typeof Map.prototype.entries>;
    export const MapPrototypeForEach: UncurryThis<typeof Map.prototype.forEach>;
    export const MapPrototypeKeys: UncurryThis<typeof Map.prototype.keys>;
    export const MapPrototypeValues: UncurryThis<typeof Map.prototype.values>;
    export const Number: typeof globalThis.Number;
    export const NumberLength: typeof Number.length;
    export const NumberName: typeof Number.name;
    export const NumberPrototype: typeof Number.prototype;
    export const NumberIsFinite: typeof Number.isFinite;
    export const NumberIsInteger: typeof Number.isInteger;
    export const NumberIsNaN: typeof Number.isNaN;
    export const NumberIsSafeInteger: typeof Number.isSafeInteger;
    export const NumberParseFloat: typeof Number.parseFloat;
    export const NumberParseInt: typeof Number.parseInt;
    export const NumberMAX_VALUE: typeof Number.MAX_VALUE;
    export const NumberMIN_VALUE: typeof Number.MIN_VALUE;
    export const NumberNaN: typeof Number.NaN;
    export const NumberNEGATIVE_INFINITY: typeof Number.NEGATIVE_INFINITY;
    export const NumberPOSITIVE_INFINITY: typeof Number.POSITIVE_INFINITY;
    export const NumberMAX_SAFE_INTEGER: typeof Number.MAX_SAFE_INTEGER;
    export const NumberMIN_SAFE_INTEGER: typeof Number.MIN_SAFE_INTEGER;
    export const NumberEPSILON: typeof Number.EPSILON;
    export const NumberPrototypeToExponential: UncurryThis<
      typeof Number.prototype.toExponential
    >;
    export const NumberPrototypeToFixed: UncurryThis<
      typeof Number.prototype.toFixed
    >;
    export const NumberPrototypeToPrecision: UncurryThis<
      typeof Number.prototype.toPrecision
    >;
    export const NumberPrototypeToString: UncurryThis<
      typeof Number.prototype.toString
    >;
    export const NumberPrototypeValueOf: UncurryThis<
      typeof Number.prototype.valueOf
    >;
    export const NumberPrototypeToLocaleString: UncurryThis<
      typeof Number.prototype.toLocaleString
    >;
    export const Object: typeof globalThis.Object;
    export const ObjectLength: typeof Object.length;
    export const ObjectName: typeof Object.name;
    export const ObjectPrototype: typeof Object.prototype;
    export const ObjectAssign: typeof Object.assign;
    export const ObjectGetOwnPropertyDescriptor:
      typeof Object.getOwnPropertyDescriptor;
    export const ObjectGetOwnPropertyDescriptors:
      typeof Object.getOwnPropertyDescriptors;
    export const ObjectGetOwnPropertyNames: typeof Object.getOwnPropertyNames;
    export const ObjectGetOwnPropertySymbols:
      typeof Object.getOwnPropertySymbols;
    export const ObjectIs: typeof Object.is;
    export const ObjectPreventExtensions: typeof Object.preventExtensions;
    export const ObjectSeal: typeof Object.seal;
    export const ObjectCreate: typeof Object.create;
    export const ObjectDefineProperties: typeof Object.defineProperties;
    export const ObjectDefineProperty: typeof Object.defineProperty;
    export const ObjectFreeze: typeof Object.freeze;
    export const ObjectGetPrototypeOf: typeof Object.getPrototypeOf;
    export const ObjectSetPrototypeOf: typeof Object.setPrototypeOf;
    export const ObjectIsExtensible: typeof Object.isExtensible;
    export const ObjectIsFrozen: typeof Object.isFrozen;
    export const ObjectIsSealed: typeof Object.isSealed;
    export const ObjectKeys: typeof Object.keys;
    export const ObjectEntries: typeof Object.entries;
    export const ObjectFromEntries: typeof Object.fromEntries;
    export const ObjectValues: typeof Object.values;
    export const ObjectPrototype__defineGetter__: UncurryThis<
      typeof Object.prototype.__defineGetter__
    >;
    export const ObjectPrototype__defineSetter__: UncurryThis<
      typeof Object.prototype.__defineSetter__
    >;
    export const ObjectPrototypeHasOwnProperty: UncurryThis<
      typeof Object.prototype.hasOwnProperty
    >;
    export const ObjectPrototype__lookupGetter__: UncurryThis<
      typeof Object.prototype.__lookupGetter__
    >;
    export const ObjectPrototype__lookupSetter__: UncurryThis<
      typeof Object.prototype.__lookupSetter__
    >;
    export const ObjectPrototypeIsPrototypeOf: UncurryThis<
      typeof Object.prototype.isPrototypeOf
    >;
    export const ObjectPrototypePropertyIsEnumerable: UncurryThis<
      typeof Object.prototype.propertyIsEnumerable
    >;
    export const ObjectPrototypeToString: UncurryThis<
      typeof Object.prototype.toString
    >;
    export const ObjectPrototypeValueOf: UncurryThis<
      typeof Object.prototype.valueOf
    >;
    export const ObjectPrototypeToLocaleString: UncurryThis<
      typeof Object.prototype.toLocaleString
    >;
    export const RangeError: typeof globalThis.RangeError;
    export const RangeErrorLength: typeof RangeError.length;
    export const RangeErrorName: typeof RangeError.name;
    export const RangeErrorPrototype: typeof RangeError.prototype;
    export const ReferenceError: typeof globalThis.ReferenceError;
    export const ReferenceErrorLength: typeof ReferenceError.length;
    export const ReferenceErrorName: typeof ReferenceError.name;
    export const ReferenceErrorPrototype: typeof ReferenceError.prototype;
    export const RegExp: typeof globalThis.RegExp;
    export const RegExpLength: typeof RegExp.length;
    export const RegExpName: typeof RegExp.name;
    export const RegExpPrototype: typeof RegExp.prototype;
    export const RegExpPrototypeExec: UncurryThis<typeof RegExp.prototype.exec>;
    export const RegExpPrototypeCompile: UncurryThis<
      typeof RegExp.prototype.compile
    >;
    export const RegExpPrototypeToString: UncurryThis<
      typeof RegExp.prototype.toString
    >;
    export const RegExpPrototypeTest: UncurryThis<typeof RegExp.prototype.test>;
    export const Set: typeof globalThis.Set;
    export const SetLength: typeof Set.length;
    export const SetName: typeof Set.name;
    export const SetPrototype: typeof Set.prototype;
    export const SetPrototypeGetSize: (set: Set) => number;
    export const SetPrototypeHas: UncurryThis<typeof Set.prototype.has>;
    export const SetPrototypeAdd: UncurryThis<typeof Set.prototype.add>;
    export const SetPrototypeDelete: UncurryThis<typeof Set.prototype.delete>;
    export const SetPrototypeClear: UncurryThis<typeof Set.prototype.clear>;
    export const SetPrototypeEntries: UncurryThis<typeof Set.prototype.entries>;
    export const SetPrototypeForEach: UncurryThis<typeof Set.prototype.forEach>;
    export const SetPrototypeValues: UncurryThis<typeof Set.prototype.values>;
    export const SetPrototypeKeys: UncurryThis<typeof Set.prototype.keys>;
    export const String: typeof globalThis.String;
    export const StringLength: typeof String.length;
    export const StringName: typeof String.name;
    export const StringPrototype: typeof String.prototype;
    export const StringFromCharCode: typeof String.fromCharCode;
    export const StringFromCodePoint: typeof String.fromCodePoint;
    export const StringRaw: typeof String.raw;
    export const StringPrototypeAnchor: UncurryThis<
      typeof String.prototype.anchor
    >;
    export const StringPrototypeBig: UncurryThis<typeof String.prototype.big>;
    export const StringPrototypeBlink: UncurryThis<
      typeof String.prototype.blink
    >;
    export const StringPrototypeBold: UncurryThis<typeof String.prototype.bold>;
    export const StringPrototypeCharAt: UncurryThis<
      typeof String.prototype.charAt
    >;
    export const StringPrototypeCharCodeAt: UncurryThis<
      typeof String.prototype.charCodeAt
    >;
    export const StringPrototypeCodePointAt: UncurryThis<
      typeof String.prototype.codePointAt
    >;
    export const StringPrototypeConcat: UncurryThis<
      typeof String.prototype.concat
    >;
    export const StringPrototypeConcatApply: UncurryThisStaticApply<
      typeof String.prototype.concat
    >;
    export const StringPrototypeEndsWith: UncurryThis<
      typeof String.prototype.endsWith
    >;
    export const StringPrototypeFontcolor: UncurryThis<
      typeof String.prototype.fontcolor
    >;
    export const StringPrototypeFontsize: UncurryThis<
      typeof String.prototype.fontsize
    >;
    export const StringPrototypeFixed: UncurryThis<
      typeof String.prototype.fixed
    >;
    export const StringPrototypeIncludes: UncurryThis<
      typeof String.prototype.includes
    >;
    export const StringPrototypeIndexOf: UncurryThis<
      typeof String.prototype.indexOf
    >;
    export const StringPrototypeItalics: UncurryThis<
      typeof String.prototype.italics
    >;
    export const StringPrototypeLastIndexOf: UncurryThis<
      typeof String.prototype.lastIndexOf
    >;
    export const StringPrototypeLink: UncurryThis<typeof String.prototype.link>;
    export const StringPrototypeLocaleCompare: UncurryThis<
      typeof String.prototype.localeCompare
    >;
    export const StringPrototypeMatch: UncurryThis<
      typeof String.prototype.match
    >;
    export const StringPrototypeMatchAll: UncurryThis<
      typeof String.prototype.matchAll
    >;
    export const StringPrototypeNormalize: UncurryThis<
      typeof String.prototype.normalize
    >;
    export const StringPrototypePadEnd: UncurryThis<
      typeof String.prototype.padEnd
    >;
    export const StringPrototypePadStart: UncurryThis<
      typeof String.prototype.padStart
    >;
    export const StringPrototypeRepeat: UncurryThis<
      typeof String.prototype.repeat
    >;
    export const StringPrototypeReplace: UncurryThis<
      typeof String.prototype.replace
    >;
    export const StringPrototypeSearch: UncurryThis<
      typeof String.prototype.search
    >;
    export const StringPrototypeSlice: UncurryThis<
      typeof String.prototype.slice
    >;
    export const StringPrototypeSmall: UncurryThis<
      typeof String.prototype.small
    >;
    export const StringPrototypeSplit: UncurryThis<
      typeof String.prototype.split
    >;
    export const StringPrototypeStrike: UncurryThis<
      typeof String.prototype.strike
    >;
    export const StringPrototypeSub: UncurryThis<typeof String.prototype.sub>;
    export const StringPrototypeSubstr: UncurryThis<
      typeof String.prototype.substr
    >;
    export const StringPrototypeSubstring: UncurryThis<
      typeof String.prototype.substring
    >;
    export const StringPrototypeSup: UncurryThis<typeof String.prototype.sup>;
    export const StringPrototypeStartsWith: UncurryThis<
      typeof String.prototype.startsWith
    >;
    export const StringPrototypeToString: UncurryThis<
      typeof String.prototype.toString
    >;
    export const StringPrototypeTrim: UncurryThis<typeof String.prototype.trim>;
    export const StringPrototypeTrimStart: UncurryThis<
      typeof String.prototype.trimStart
    >;
    export const StringPrototypeTrimLeft: UncurryThis<
      typeof String.prototype.trimLeft
    >;
    export const StringPrototypeTrimEnd: UncurryThis<
      typeof String.prototype.trimEnd
    >;
    export const StringPrototypeTrimRight: UncurryThis<
      typeof String.prototype.trimRight
    >;
    export const StringPrototypeToLocaleLowerCase: UncurryThis<
      typeof String.prototype.toLocaleLowerCase
    >;
    export const StringPrototypeToLocaleUpperCase: UncurryThis<
      typeof String.prototype.toLocaleUpperCase
    >;
    export const StringPrototypeToLowerCase: UncurryThis<
      typeof String.prototype.toLowerCase
    >;
    export const StringPrototypeToUpperCase: UncurryThis<
      typeof String.prototype.toUpperCase
    >;
    export const StringPrototypeValueOf: UncurryThis<
      typeof String.prototype.valueOf
    >;
    export const StringPrototypeReplaceAll: UncurryThis<
      typeof String.prototype.replaceAll
    >;
    export const Symbol: typeof globalThis.Symbol;
    export const SymbolLength: typeof Symbol.length;
    export const SymbolName: typeof Symbol.name;
    export const SymbolPrototype: typeof Symbol.prototype;
    export const SymbolPrototypeGetDescription: (symbol: symbol) => string;
    export const SymbolFor: typeof Symbol.for;
    export const SymbolKeyFor: typeof Symbol.keyFor;
    export const SymbolAsyncIterator: typeof Symbol.asyncIterator;
    export const SymbolHasInstance: typeof Symbol.hasInstance;
    export const SymbolIsConcatSpreadable: typeof Symbol.isConcatSpreadable;
    export const SymbolIterator: typeof Symbol.iterator;
    export const SymbolMatch: typeof Symbol.match;
    export const SymbolMatchAll: typeof Symbol.matchAll;
    export const SymbolReplace: typeof Symbol.replace;
    export const SymbolSearch: typeof Symbol.search;
    export const SymbolSpecies: typeof Symbol.species;
    export const SymbolSplit: typeof Symbol.split;
    export const SymbolToPrimitive: typeof Symbol.toPrimitive;
    export const SymbolToStringTag: typeof Symbol.toStringTag;
    export const SymbolUnscopables: typeof Symbol.unscopables;
    export const SymbolPrototypeToString: UncurryThis<
      typeof Symbol.prototype.toString
    >;
    export const SymbolPrototypeValueOf: UncurryThis<
      typeof Symbol.prototype.valueOf
    >;
    export const SyntaxError: typeof globalThis.SyntaxError;
    export const SyntaxErrorLength: typeof SyntaxError.length;
    export const SyntaxErrorName: typeof SyntaxError.name;
    export const SyntaxErrorPrototype: typeof SyntaxError.prototype;
    export const TypeError: typeof globalThis.TypeError;
    export const TypeErrorLength: typeof TypeError.length;
    export const TypeErrorName: typeof TypeError.name;
    export const TypeErrorPrototype: typeof TypeError.prototype;
    export const URIError: typeof globalThis.URIError;
    export const URIErrorLength: typeof URIError.length;
    export const URIErrorName: typeof URIError.name;
    export const URIErrorPrototype: typeof URIError.prototype;
    export const Uint16Array: typeof globalThis.Uint16Array;
    export const Uint16ArrayLength: typeof Uint16Array.length;
    export const Uint16ArrayName: typeof Uint16Array.name;
    export const Uint16ArrayPrototype: typeof Uint16Array.prototype;
    export const Uint16ArrayBYTES_PER_ELEMENT:
      typeof Uint16Array.BYTES_PER_ELEMENT;
    export const Uint32Array: typeof globalThis.Uint32Array;
    export const Uint32ArrayLength: typeof Uint32Array.length;
    export const Uint32ArrayName: typeof Uint32Array.name;
    export const Uint32ArrayPrototype: typeof Uint32Array.prototype;
    export const Uint32ArrayBYTES_PER_ELEMENT:
      typeof Uint32Array.BYTES_PER_ELEMENT;
    export const Uint8Array: typeof globalThis.Uint8Array;
    export const Uint8ArrayLength: typeof Uint8Array.length;
    export const Uint8ArrayName: typeof Uint8Array.name;
    export const Uint8ArrayPrototype: typeof Uint8Array.prototype;
    export const Uint8ArrayBYTES_PER_ELEMENT:
      typeof Uint8Array.BYTES_PER_ELEMENT;
    export const Uint8ClampedArray: typeof globalThis.Uint8ClampedArray;
    export const Uint8ClampedArrayLength: typeof Uint8ClampedArray.length;
    export const Uint8ClampedArrayName: typeof Uint8ClampedArray.name;
    export const Uint8ClampedArrayPrototype: typeof Uint8ClampedArray.prototype;
    export const Uint8ClampedArrayBYTES_PER_ELEMENT:
      typeof Uint8ClampedArray.BYTES_PER_ELEMENT;
    export const WeakMap: typeof globalThis.WeakMap;
    export const WeakMapLength: typeof WeakMap.length;
    export const WeakMapName: typeof WeakMap.name;
    export const WeakMapPrototype: typeof WeakMap.prototype;
    export const WeakMapPrototypeDelete: UncurryThis<
      typeof WeakMap.prototype.delete
    >;
    export const WeakMapPrototypeGet: UncurryThis<typeof WeakMap.prototype.get>;
    export const WeakMapPrototypeSet: UncurryThis<typeof WeakMap.prototype.set>;
    export const WeakMapPrototypeHas: UncurryThis<typeof WeakMap.prototype.has>;
    export const WeakRef: typeof globalThis.WeakRef;
    export const WeakRefLength: typeof WeakRef.length;
    export const WeakRefName: typeof WeakRef.name;
    export const WeakRefPrototype: typeof WeakRef.prototype;
    export const WeakRefPrototypeDeref: UncurryThis<
      typeof WeakRef.prototype.deref
    >;
    export const WeakSet: typeof globalThis.WeakSet;
    export const WeakSetLength: typeof WeakSet.length;
    export const WeakSetName: typeof WeakSet.name;
    export const WeakSetPrototype: typeof WeakSet.prototype;
    export const WeakSetPrototypeDelete: UncurryThis<
      typeof WeakSet.prototype.delete
    >;
    export const WeakSetPrototypeHas: UncurryThis<typeof WeakSet.prototype.has>;
    export const WeakSetPrototypeAdd: UncurryThis<typeof WeakSet.prototype.add>;
    export const Promise: typeof globalThis.Promise;
    export const PromiseLength: typeof Promise.length;
    export const PromiseName: typeof Promise.name;
    export const PromisePrototype: typeof Promise.prototype;
    export const PromiseAll: typeof Promise.all;
    export const PromiseRace: typeof Promise.race;
    export const PromiseResolve: typeof Promise.resolve;
    export const PromiseReject: typeof Promise.reject;
    export const PromiseAllSettled: typeof Promise.allSettled;
    export const PromiseAny: typeof Promise.any;
    export const PromisePrototypeThen: UncurryThis<
      typeof Promise.prototype.then
    >;
    export const PromisePrototypeCatch: UncurryThis<
      typeof Promise.prototype.catch
    >;
    export const PromisePrototypeFinally: UncurryThis<
      typeof Promise.prototype.finally
    >;

    // abstract intrinsic objects
    export const ArrayIteratorPrototypeNext: <T>(
      iterator: IterableIterator<T>,
    ) => IteratorResult<T>;
    export const SetIteratorPrototypeNext: <T>(
      iterator: IterableIterator<T>,
    ) => IteratorResult<T>;
    export const MapIteratorPrototypeNext: <T>(
      iterator: IterableIterator<T>,
    ) => IteratorResult<T>;
    export const StringIteratorPrototypeNext: <T>(
      iterator: IterableIterator<T>,
    ) => IteratorResult<T>;
    export const GeneratorPrototypeNext: <T>(
      generator: Generator<T>,
    ) => IteratorResult<T>;
    export const AsyncGeneratorPrototypeNext: <T>(
      asyncGenerator: AsyncGenerator<T>,
    ) => Promise<IteratorResult<T>>;
    export const TypedArrayFrom: (
      constructor: Uint8ArrayConstructor,
      arrayLike: ArrayLike<number>,
    ) => Uint8Array;
    export const TypedArrayPrototypeGetBuffer: (
      array: Uint8Array,
    ) => ArrayBuffer | SharedArrayBuffer;
    export const TypedArrayPrototypeGetByteLength: (
      array: Uint8Array,
    ) => number;
    export const TypedArrayPrototypeGetByteOffset: (
      array: Uint8Array,
    ) => number;
    export const TypedArrayPrototypeGetLength: (array: Uint8Array) => number;
    export const TypedArrayPrototypeGetSymbolToStringTag: (
      v: unknown,
    ) => string | undefined;
    export const TypedArrayPrototypeCopyWithin: UncurryThis<
      typeof Uint8Array.prototype.copyWithin
    >;
    export const TypedArrayPrototypeEvery: UncurryThis<
      typeof Uint8Array.prototype.every
    >;
    export const TypedArrayPrototypeFill: UncurryThis<
      typeof Uint8Array.prototype.fill
    >;
    export const TypedArrayPrototypeFilter: UncurryThis<
      typeof Uint8Array.prototype.filter
    >;
    export const TypedArrayPrototypeFind: UncurryThis<
      typeof Uint8Array.prototype.find
    >;
    export const TypedArrayPrototypeFindIndex: UncurryThis<
      typeof Uint8Array.prototype.findIndex
    >;
    export const TypedArrayPrototypeForEach: UncurryThis<
      typeof Uint8Array.prototype.forEach
    >;
    export const TypedArrayPrototypeIndexOf: UncurryThis<
      typeof Uint8Array.prototype.indexOf
    >;
    export const TypedArrayPrototypeJoin: UncurryThis<
      typeof Uint8Array.prototype.join
    >;
    export const TypedArrayPrototypeLastIndexOf: UncurryThis<
      typeof Uint8Array.prototype.lastIndexOf
    >;
    export const TypedArrayPrototypeMap: UncurryThis<
      typeof Uint8Array.prototype.map
    >;
    export const TypedArrayPrototypeReduce: UncurryThis<
      typeof Uint8Array.prototype.reduce
    >;
    export const TypedArrayPrototypeReduceRight: UncurryThis<
      typeof Uint8Array.prototype.reduceRight
    >;
    export const TypedArrayPrototypeReverse: UncurryThis<
      typeof Uint8Array.prototype.reverse
    >;
    export const TypedArrayPrototypeSet: UncurryThis<
      typeof Uint8Array.prototype.set
    >;
    export const TypedArrayPrototypeSlice: UncurryThis<
      typeof Uint8Array.prototype.slice
    >;
    export const TypedArrayPrototypeSome: UncurryThis<
      typeof Uint8Array.prototype.some
    >;
    export const TypedArrayPrototypeSort: UncurryThis<
      typeof Uint8Array.prototype.sort
    >;
    export const TypedArrayPrototypeSubarray: UncurryThis<
      typeof Uint8Array.prototype.subarray
    >;
    export const TypedArrayPrototypeToLocaleString: UncurryThis<
      typeof Uint8Array.prototype.toLocaleString
    >;
    export const TypedArrayPrototypeToString: UncurryThis<
      typeof Uint8Array.prototype.toString
    >;
    export const TypedArrayPrototypeValueOf: UncurryThis<
      typeof Uint8Array.prototype.valueOf
    >;
  }
}