Upload Kmake

typings/globals.d.ts

@@ -0,0 +1,76 @@
+import { AsyncWrapBinding } from './internalBinding/async_wrap';
+import { BlobBinding } from './internalBinding/blob';
+import { ConfigBinding } from './internalBinding/config';
+import { ConstantsBinding } from './internalBinding/constants';
+import { DebugBinding } from './internalBinding/debug';
+import { HttpParserBinding } from './internalBinding/http_parser';
+import { InspectorBinding } from './internalBinding/inspector';
+import { FsBinding } from './internalBinding/fs';
+import { FsDirBinding } from './internalBinding/fs_dir';
+import { MessagingBinding } from './internalBinding/messaging';
+import { OptionsBinding } from './internalBinding/options';
+import { OSBinding } from './internalBinding/os';
+import { ProcessBinding } from './internalBinding/process';
+import { SerdesBinding } from './internalBinding/serdes';
+import { SymbolsBinding } from './internalBinding/symbols';
+import { TimersBinding } from './internalBinding/timers';
+import { TypesBinding } from './internalBinding/types';
+import { URLBinding } from './internalBinding/url';
+import { URLPatternBinding } from "./internalBinding/url_pattern";
+import { UtilBinding } from './internalBinding/util';
+import { WASIBinding } from './internalBinding/wasi';
+import { WorkerBinding } from './internalBinding/worker';
+import { ModulesBinding } from './internalBinding/modules';
+import { ZlibBinding } from './internalBinding/zlib';
+
+interface InternalBindingMap {
+  async_wrap: AsyncWrapBinding;
+  blob: BlobBinding;
+  config: ConfigBinding;
+  constants: ConstantsBinding;
+  debug: DebugBinding;
+  fs: FsBinding;
+  fs_dir: FsDirBinding;
+  http_parser: HttpParserBinding;
+  inspector: InspectorBinding;
+  messaging: MessagingBinding;
+  modules: ModulesBinding;
+  options: OptionsBinding;
+  os: OSBinding;
+  process: ProcessBinding;
+  serdes: SerdesBinding;
+  symbols: SymbolsBinding;
+  timers: TimersBinding;
+  types: TypesBinding;
+  url: URLBinding;
+  url_pattern: URLPatternBinding;
+  util: UtilBinding;
+  wasi: WASIBinding;
+  worker: WorkerBinding;
+  zlib: ZlibBinding;
+}
+
+type InternalBindingKeys = keyof InternalBindingMap;
+
+declare function internalBinding<T extends InternalBindingKeys>(binding: T): InternalBindingMap[T]
+
+declare global {
+  type TypedArray =
+    | Uint8Array
+    | Uint8ClampedArray
+    | Uint16Array
+    | Uint32Array
+    | Int8Array
+    | Int16Array
+    | Int32Array
+    | Float32Array
+    | Float64Array
+    | BigUint64Array
+    | BigInt64Array;
+
+  namespace NodeJS {
+    interface Global {
+      internalBinding<T extends InternalBindingKeys>(binding: T): InternalBindingMap[T]
+    }
+  }
+}

typings/internalBinding/async_wrap.d.ts

@@ -0,0 +1,131 @@
+import { owner_symbol } from './symbols';
+
+declare namespace InternalAsyncWrapBinding {
+  interface Resource {
+    [owner_symbol]?: PublicResource;
+  }
+  type PublicResource = object;
+
+  type EmitHook = (asyncId: number) => void;
+
+  type PromiseHook = (promise: Promise<unknown>, parent: Promise<unknown>) => void;
+
+  interface Providers {
+    NONE: 0;
+    DIRHANDLE: 1;
+    DNSCHANNEL: 2;
+    ELDHISTOGRAM: 3;
+    FILEHANDLE: 4;
+    FILEHANDLECLOSEREQ: 5;
+    FIXEDSIZEBLOBCOPY: 6;
+    FSEVENTWRAP: 7;
+    FSREQCALLBACK: 8;
+    FSREQPROMISE: 9;
+    GETADDRINFOREQWRAP: 10;
+    GETNAMEINFOREQWRAP: 11;
+    HEAPSNAPSHOT: 12;
+    HTTP2SESSION: 13;
+    HTTP2STREAM: 14;
+    HTTP2PING: 15;
+    HTTP2SETTINGS: 16;
+    HTTPINCOMINGMESSAGE: 17;
+    HTTPCLIENTREQUEST: 18;
+    JSSTREAM: 19;
+    JSUDPWRAP: 20;
+    MESSAGEPORT: 21;
+    PIPECONNECTWRAP: 22;
+    PIPESERVERWRAP: 23;
+    PIPEWRAP: 24;
+    PROCESSWRAP: 25;
+    PROMISE: 26;
+    QUERYWRAP: 27;
+    SHUTDOWNWRAP: 28;
+    SIGNALWRAP: 29;
+    STATWATCHER: 30;
+    STREAMPIPE: 31;
+    TCPCONNECTWRAP: 32;
+    TCPSERVERWRAP: 33;
+    TCPWRAP: 34;
+    TTYWRAP: 35;
+    UDPSENDWRAP: 36;
+    UDPWRAP: 37;
+    SIGINTWATCHDOG: 38;
+    WORKER: 39;
+    WORKERHEAPSNAPSHOT: 40;
+    WRITEWRAP: 41;
+    ZLIB: 42;
+    CHECKPRIMEREQUEST: 43;
+    PBKDF2REQUEST: 44;
+    KEYPAIRGENREQUEST: 45;
+    KEYGENREQUEST: 46;
+    KEYEXPORTREQUEST: 47;
+    CIPHERREQUEST: 48;
+    DERIVEBITSREQUEST: 49;
+    HASHREQUEST: 50;
+    RANDOMBYTESREQUEST: 51;
+    RANDOMPRIMEREQUEST: 52;
+    SCRYPTREQUEST: 53;
+    SIGNREQUEST: 54;
+    TLSWRAP: 55;
+    VERIFYREQUEST: 56;
+  }
+}
+
+export interface AsyncWrapBinding {
+  setupHooks(): {
+    init: (
+      asyncId: number,
+      type: keyof InternalAsyncWrapBinding.Providers,
+      triggerAsyncId: number,
+      resource: InternalAsyncWrapBinding.Resource,
+    ) => void;
+    before: InternalAsyncWrapBinding.EmitHook;
+    after: InternalAsyncWrapBinding.EmitHook;
+    destroy: InternalAsyncWrapBinding.EmitHook;
+    promise_resolve: InternalAsyncWrapBinding.EmitHook;
+  };
+  setCallbackTrampoline(
+    callback: (
+      asyncId: number,
+      resource: InternalAsyncWrapBinding.Resource,
+      cb: (
+        cb: (...args: any[]) => boolean | undefined,
+        ...args: any[]
+      ) => boolean | undefined,
+      ...args: any[]
+    ) => boolean | undefined
+  ): void;
+  pushAsyncContext(asyncId: number, triggerAsyncId: number): void;
+  popAsyncContext(asyncId: number): boolean;
+  executionAsyncResource(index: number): InternalAsyncWrapBinding.PublicResource | null;
+  clearAsyncIdStack(): void;
+  queueDestroyAsyncId(asyncId: number): void;
+  setPromiseHooks(
+    initHook: ((promise: Promise<unknown>, parent?: Promise<unknown>) => void) | undefined,
+    promiseBeforeHook: InternalAsyncWrapBinding.PromiseHook | undefined,
+    promiseAfterHook: InternalAsyncWrapBinding.PromiseHook | undefined,
+    promiseResolveHook: InternalAsyncWrapBinding.PromiseHook | undefined
+  ): void;
+  registerDestroyHook(resource: object, asyncId: number, destroyed?: { destroyed: boolean }): void;
+  async_hook_fields: Uint32Array;
+  async_id_fields: Float64Array;
+  async_ids_stack: Float64Array;
+  execution_async_resources: InternalAsyncWrapBinding.Resource[];
+  constants: {
+    kInit: 0;
+    kBefore: 1;
+    kAfter: 2;
+    kDestroy: 3;
+    kPromiseResolve: 4;
+    kTotals: 5;
+    kCheck: 6;
+    kStackLength: 7;
+    kUsesExecutionAsyncResource: 8;
+
+    kExecutionAsyncId: 0;
+    kTriggerAsyncId: 1;
+    kAsyncIdCounter: 2;
+    kDefaultTriggerAsyncId: 3;
+  };
+  Providers: InternalAsyncWrapBinding.Providers;
+}

typings/internalBinding/blob.d.ts

@@ -0,0 +1,11 @@
+declare namespace InternalBlobBinding {
+  interface BlobHandle {
+    slice(start: number, end: number): BlobHandle;
+  }
+}
+
+export interface BlobBinding {
+  createBlob(sources: Array<Uint8Array | InternalBlobBinding.BlobHandle>, length: number): InternalBlobBinding.BlobHandle;
+  getDataObject(id: string): [handle: InternalBlobBinding.BlobHandle | undefined, length: number, type: string] | undefined;
+  storeDataObject(id: string, handle: InternalBlobBinding.BlobHandle, size: number, type: string): void;
+}

typings/internalBinding/config.d.ts

@@ -0,0 +1,12 @@
+export interface ConfigBinding {
+  isDebugBuild: boolean;
+  hasOpenSSL: boolean;
+  fipsMode: boolean;
+  hasIntl: boolean;
+  hasTracing: boolean;
+  hasNodeOptions: boolean;
+  hasInspector: boolean;
+  noBrowserGlobals: boolean;
+  bits: number;
+  hasDtrace: boolean;
+}

typings/internalBinding/constants.d.ts

@@ -0,0 +1,394 @@
+export interface ConstantsBinding {
+  os: {
+    UV_UDP_REUSEADDR: 4;
+    dlopen: {
+      RTLD_LAZY: 1;
+      RTLD_NOW: 2;
+      RTLD_GLOBAL: 8;
+      RTLD_LOCAL: 4;
+    };
+    errno: {
+      E2BIG: 7;
+      EACCES: 13;
+      EADDRINUSE: 48;
+      EADDRNOTAVAIL: 49;
+      EAFNOSUPPORT: 47;
+      EAGAIN: 35;
+      EALREADY: 37;
+      EBADF: 9;
+      EBADMSG: 94;
+      EBUSY: 16;
+      ECANCELED: 89;
+      ECHILD: 10;
+      ECONNABORTED: 53;
+      ECONNREFUSED: 61;
+      ECONNRESET: 54;
+      EDEADLK: 11;
+      EDESTADDRREQ: 39;
+      EDOM: 33;
+      EDQUOT: 69;
+      EEXIST: 17;
+      EFAULT: 14;
+      EFBIG: 27;
+      EHOSTUNREACH: 65;
+      EIDRM: 90;
+      EILSEQ: 92;
+      EINPROGRESS: 36;
+      EINTR: 4;
+      EINVAL: 22;
+      EIO: 5;
+      EISCONN: 56;
+      EISDIR: 21;
+      ELOOP: 62;
+      EMFILE: 24;
+      EMLINK: 31;
+      EMSGSIZE: 40;
+      EMULTIHOP: 95;
+      ENAMETOOLONG: 63;
+      ENETDOWN: 50;
+      ENETRESET: 52;
+      ENETUNREACH: 51;
+      ENFILE: 23;
+      ENOBUFS: 55;
+      ENODATA: 96;
+      ENODEV: 19;
+      ENOENT: 2;
+      ENOEXEC: 8;
+      ENOLCK: 77;
+      ENOLINK: 97;
+      ENOMEM: 12;
+      ENOMSG: 91;
+      ENOPROTOOPT: 42;
+      ENOSPC: 28;
+      ENOSR: 98;
+      ENOSTR: 99;
+      ENOSYS: 78;
+      ENOTCONN: 57;
+      ENOTDIR: 20;
+      ENOTEMPTY: 66;
+      ENOTSOCK: 38;
+      ENOTSUP: 45;
+      ENOTTY: 25;
+      ENXIO: 6;
+      EOPNOTSUPP: 102;
+      EOVERFLOW: 84;
+      EPERM: 1;
+      EPIPE: 32;
+      EPROTO: 100;
+      EPROTONOSUPPORT: 43;
+      EPROTOTYPE: 41;
+      ERANGE: 34;
+      EROFS: 30;
+      ESPIPE: 29;
+      ESRCH: 3;
+      ESTALE: 70;
+      ETIME: 101;
+      ETIMEDOUT: 60;
+      ETXTBSY: 26;
+      EWOULDBLOCK: 35;
+      EXDEV: 18;
+    };
+    signals: {
+      SIGHUP: 1;
+      SIGINT: 2;
+      SIGQUIT: 3;
+      SIGILL: 4;
+      SIGTRAP: 5;
+      SIGABRT: 6;
+      SIGIOT: 6;
+      SIGBUS: 10;
+      SIGFPE: 8;
+      SIGKILL: 9;
+      SIGUSR1: 30;
+      SIGSEGV: 11;
+      SIGUSR2: 31;
+      SIGPIPE: 13;
+      SIGALRM: 14;
+      SIGTERM: 15;
+      SIGCHLD: 20;
+      SIGCONT: 19;
+      SIGSTOP: 17;
+      SIGTSTP: 18;
+      SIGTTIN: 21;
+      SIGTTOU: 22;
+      SIGURG: 16;
+      SIGXCPU: 24;
+      SIGXFSZ: 25;
+      SIGVTALRM: 26;
+      SIGPROF: 27;
+      SIGWINCH: 28;
+      SIGIO: 23;
+      SIGINFO: 29;
+      SIGSYS: 12;
+    };
+    priority: {
+      PRIORITY_LOW: 19;
+      PRIORITY_BELOW_NORMAL: 10;
+      PRIORITY_NORMAL: 0;
+      PRIORITY_ABOVE_NORMAL: -7;
+      PRIORITY_HIGH: -14;
+      PRIORITY_HIGHEST: -20;
+    };
+  };
+  sqlite: {
+    SQLITE_CHANGESET_OMIT: 0;
+    SQLITE_CHANGESET_REPLACE: 1;
+    SQLITE_CHANGESET_ABORT: 2;
+  };
+  fs: {
+    UV_FS_SYMLINK_DIR: 1;
+    UV_FS_SYMLINK_JUNCTION: 2;
+    O_RDONLY: 0;
+    O_WRONLY: 1;
+    O_RDWR: 2;
+    UV_DIRENT_UNKNOWN: 0;
+    UV_DIRENT_FILE: 1;
+    UV_DIRENT_DIR: 2;
+    UV_DIRENT_LINK: 3;
+    UV_DIRENT_FIFO: 4;
+    UV_DIRENT_SOCKET: 5;
+    UV_DIRENT_CHAR: 6;
+    UV_DIRENT_BLOCK: 7;
+    S_IFMT: 61440;
+    S_IFREG: 32768;
+    S_IFDIR: 16384;
+    S_IFCHR: 8192;
+    S_IFBLK: 24576;
+    S_IFIFO: 4096;
+    S_IFLNK: 40960;
+    S_IFSOCK: 49152;
+    O_CREAT: 512;
+    O_EXCL: 2048;
+    UV_FS_O_FILEMAP: 0;
+    O_NOCTTY: 131072;
+    O_TRUNC: 1024;
+    O_APPEND: 8;
+    O_DIRECTORY: 1048576;
+    O_NOFOLLOW: 256;
+    O_SYNC: 128;
+    O_DSYNC: 4194304;
+    O_SYMLINK: 2097152;
+    O_NONBLOCK: 4;
+    S_IRWXU: 448;
+    S_IRUSR: 256;
+    S_IWUSR: 128;
+    S_IXUSR: 64;
+    S_IRWXG: 56;
+    S_IRGRP: 32;
+    S_IWGRP: 16;
+    S_IXGRP: 8;
+    S_IRWXO: 7;
+    S_IROTH: 4;
+    S_IWOTH: 2;
+    S_IXOTH: 1;
+    F_OK: 0;
+    R_OK: 4;
+    W_OK: 2;
+    X_OK: 1;
+    UV_FS_COPYFILE_EXCL: 1;
+    COPYFILE_EXCL: 1;
+    UV_FS_COPYFILE_FICLONE: 2;
+    COPYFILE_FICLONE: 2;
+    UV_FS_COPYFILE_FICLONE_FORCE: 4;
+    COPYFILE_FICLONE_FORCE: 4;
+  };
+  crypto: {
+    OPENSSL_VERSION_NUMBER: 269488319;
+    SSL_OP_ALL: 2147485780;
+    SSL_OP_ALLOW_NO_DHE_KEX: 1024;
+    SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144;
+    SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304;
+    SSL_OP_CISCO_ANYCONNECT: 32768;
+    SSL_OP_COOKIE_EXCHANGE: 8192;
+    SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648;
+    SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048;
+    SSL_OP_LEGACY_SERVER_CONNECT: 4;
+    SSL_OP_NO_COMPRESSION: 131072;
+    SSL_OP_NO_ENCRYPT_THEN_MAC: 524288;
+    SSL_OP_NO_QUERY_MTU: 4096;
+    SSL_OP_NO_RENEGOTIATION: 1073741824;
+    SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536;
+    SSL_OP_NO_SSLv2: 0;
+    SSL_OP_NO_SSLv3: 33554432;
+    SSL_OP_NO_TICKET: 16384;
+    SSL_OP_NO_TLSv1: 67108864;
+    SSL_OP_NO_TLSv1_1: 268435456;
+    SSL_OP_NO_TLSv1_2: 134217728;
+    SSL_OP_NO_TLSv1_3: 536870912;
+    SSL_OP_PRIORITIZE_CHACHA: 2097152;
+    SSL_OP_TLS_ROLLBACK_BUG: 8388608;
+    ENGINE_METHOD_RSA: 1;
+    ENGINE_METHOD_DSA: 2;
+    ENGINE_METHOD_DH: 4;
+    ENGINE_METHOD_RAND: 8;
+    ENGINE_METHOD_EC: 2048;
+    ENGINE_METHOD_CIPHERS: 64;
+    ENGINE_METHOD_DIGESTS: 128;
+    ENGINE_METHOD_PKEY_METHS: 512;
+    ENGINE_METHOD_PKEY_ASN1_METHS: 1024;
+    ENGINE_METHOD_ALL: 65535;
+    ENGINE_METHOD_NONE: 0;
+    DH_CHECK_P_NOT_SAFE_PRIME: 2;
+    DH_CHECK_P_NOT_PRIME: 1;
+    DH_UNABLE_TO_CHECK_GENERATOR: 4;
+    DH_NOT_SUITABLE_GENERATOR: 8;
+    RSA_PKCS1_PADDING: 1;
+    RSA_SSLV23_PADDING: 2;
+    RSA_NO_PADDING: 3;
+    RSA_PKCS1_OAEP_PADDING: 4;
+    RSA_X931_PADDING: 5;
+    RSA_PKCS1_PSS_PADDING: 6;
+    RSA_PSS_SALTLEN_DIGEST: -1;
+    RSA_PSS_SALTLEN_MAX_SIGN: -2;
+    RSA_PSS_SALTLEN_AUTO: -2;
+    defaultCoreCipherList: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA';
+    TLS1_VERSION: 769;
+    TLS1_1_VERSION: 770;
+    TLS1_2_VERSION: 771;
+    TLS1_3_VERSION: 772;
+    POINT_CONVERSION_COMPRESSED: 2;
+    POINT_CONVERSION_UNCOMPRESSED: 4;
+    POINT_CONVERSION_HYBRID: 6;
+  };
+  zlib: {
+    Z_NO_FLUSH: 0;
+    Z_PARTIAL_FLUSH: 1;
+    Z_SYNC_FLUSH: 2;
+    Z_FULL_FLUSH: 3;
+    Z_FINISH: 4;
+    Z_BLOCK: 5;
+    Z_OK: 0;
+    Z_STREAM_END: 1;
+    Z_NEED_DICT: 2;
+    Z_ERRNO: -1;
+    Z_STREAM_ERROR: -2;
+    Z_DATA_ERROR: -3;
+    Z_MEM_ERROR: -4;
+    Z_BUF_ERROR: -5;
+    Z_VERSION_ERROR: -6;
+    Z_NO_COMPRESSION: 0;
+    Z_BEST_SPEED: 1;
+    Z_BEST_COMPRESSION: 9;
+    Z_DEFAULT_COMPRESSION: -1;
+    Z_FILTERED: 1;
+    Z_HUFFMAN_ONLY: 2;
+    Z_RLE: 3;
+    Z_FIXED: 4;
+    Z_DEFAULT_STRATEGY: 0;
+    ZLIB_VERNUM: 4784;
+    DEFLATE: 1;
+    INFLATE: 2;
+    GZIP: 3;
+    GUNZIP: 4;
+    DEFLATERAW: 5;
+    INFLATERAW: 6;
+    UNZIP: 7;
+    BROTLI_DECODE: 8;
+    BROTLI_ENCODE: 9;
+    Z_MIN_WINDOWBITS: 8;
+    Z_MAX_WINDOWBITS: 15;
+    Z_DEFAULT_WINDOWBITS: 15;
+    Z_MIN_CHUNK: 64;
+    Z_MAX_CHUNK: number;
+    Z_DEFAULT_CHUNK: 16384;
+    Z_MIN_MEMLEVEL: 1;
+    Z_MAX_MEMLEVEL: 9;
+    Z_DEFAULT_MEMLEVEL: 8;
+    Z_MIN_LEVEL: -1;
+    Z_MAX_LEVEL: 9;
+    Z_DEFAULT_LEVEL: -1;
+    BROTLI_OPERATION_PROCESS: 0;
+    BROTLI_OPERATION_FLUSH: 1;
+    BROTLI_OPERATION_FINISH: 2;
+    BROTLI_OPERATION_EMIT_METADATA: 3;
+    BROTLI_PARAM_MODE: 0;
+    BROTLI_MODE_GENERIC: 0;
+    BROTLI_MODE_TEXT: 1;
+    BROTLI_MODE_FONT: 2;
+    BROTLI_DEFAULT_MODE: 0;
+    BROTLI_PARAM_QUALITY: 1;
+    BROTLI_MIN_QUALITY: 0;
+    BROTLI_MAX_QUALITY: 11;
+    BROTLI_DEFAULT_QUALITY: 11;
+    BROTLI_PARAM_LGWIN: 2;
+    BROTLI_MIN_WINDOW_BITS: 10;
+    BROTLI_MAX_WINDOW_BITS: 24;
+    BROTLI_LARGE_MAX_WINDOW_BITS: 30;
+    BROTLI_DEFAULT_WINDOW: 22;
+    BROTLI_PARAM_LGBLOCK: 3;
+    BROTLI_MIN_INPUT_BLOCK_BITS: 16;
+    BROTLI_MAX_INPUT_BLOCK_BITS: 24;
+    BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4;
+    BROTLI_PARAM_SIZE_HINT: 5;
+    BROTLI_PARAM_LARGE_WINDOW: 6;
+    BROTLI_PARAM_NPOSTFIX: 7;
+    BROTLI_PARAM_NDIRECT: 8;
+    BROTLI_DECODER_RESULT_ERROR: 0;
+    BROTLI_DECODER_RESULT_SUCCESS: 1;
+    BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2;
+    BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3;
+    BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0;
+    BROTLI_DECODER_PARAM_LARGE_WINDOW: 1;
+    BROTLI_DECODER_NO_ERROR: 0;
+    BROTLI_DECODER_SUCCESS: 1;
+    BROTLI_DECODER_NEEDS_MORE_INPUT: 2;
+    BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3;
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1;
+    BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2;
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3;
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4;
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5;
+    BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6;
+    BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7;
+    BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8;
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9;
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10;
+    BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11;
+    BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12;
+    BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13;
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14;
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15;
+    BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16;
+    BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19;
+    BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20;
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21;
+    BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22;
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25;
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26;
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27;
+    BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30;
+    BROTLI_DECODER_ERROR_UNREACHABLE: -31;
+  };
+  trace: {
+    TRACE_EVENT_PHASE_BEGIN: 66;
+    TRACE_EVENT_PHASE_END: 69;
+    TRACE_EVENT_PHASE_COMPLETE: 88;
+    TRACE_EVENT_PHASE_INSTANT: 73;
+    TRACE_EVENT_PHASE_ASYNC_BEGIN: 83;
+    TRACE_EVENT_PHASE_ASYNC_STEP_INTO: 84;
+    TRACE_EVENT_PHASE_ASYNC_STEP_PAST: 112;
+    TRACE_EVENT_PHASE_ASYNC_END: 70;
+    TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: 98;
+    TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: 101;
+    TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: 110;
+    TRACE_EVENT_PHASE_FLOW_BEGIN: 115;
+    TRACE_EVENT_PHASE_FLOW_STEP: 116;
+    TRACE_EVENT_PHASE_FLOW_END: 102;
+    TRACE_EVENT_PHASE_METADATA: 77;
+    TRACE_EVENT_PHASE_COUNTER: 67;
+    TRACE_EVENT_PHASE_SAMPLE: 80;
+    TRACE_EVENT_PHASE_CREATE_OBJECT: 78;
+    TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: 79;
+    TRACE_EVENT_PHASE_DELETE_OBJECT: 68;
+    TRACE_EVENT_PHASE_MEMORY_DUMP: 118;
+    TRACE_EVENT_PHASE_MARK: 82;
+    TRACE_EVENT_PHASE_CLOCK_SYNC: 99;
+    TRACE_EVENT_PHASE_ENTER_CONTEXT: 40;
+    TRACE_EVENT_PHASE_LEAVE_CONTEXT: 41;
+    TRACE_EVENT_PHASE_LINK_IDS: 61;
+  };
+  internal: {
+    EXTENSIONLESS_FORMAT_JAVASCRIPT: 0;
+    EXTENSIONLESS_FORMAT_WASM: 1;
+  };
+}

typings/internalBinding/debug.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `internalBinding('debug')` binding provides access to internal debugging
+ * utilities. They are only available when Node.js is built with the `--debug`
+ * or `--debug-node` compile-time flags.
+ */
+export interface DebugBinding {
+  getV8FastApiCallCount(name: string): number;
+  isEven(value: number): boolean;
+  isOdd(value: number): boolean;
+}

typings/internalBinding/fs.d.ts

@@ -0,0 +1,302 @@
+import { ConstantsBinding } from './constants';
+
+interface ReadFileContext {
+  fd: number | undefined;
+  isUserFd: boolean | undefined;
+  size: number;
+  callback: (err?: Error, data?: string | Uint8Array) => unknown;
+  buffers: Uint8Array[];
+  buffer: Uint8Array;
+  pos: number;
+  encoding: string;
+  err: Error | null;
+  signal: unknown /* AbortSignal | undefined */;
+}
+
+declare namespace InternalFSBinding {
+  class FSReqCallback<ResultType = unknown> {
+    constructor(bigint?: boolean);
+    oncomplete: ((error: Error) => void) | ((error: null, result: ResultType) => void);
+    context: ReadFileContext;
+  }
+
+  interface FSSyncContext {
+    fd?: number;
+    path?: string;
+    dest?: string;
+    errno?: string;
+    message?: string;
+    syscall?: string;
+    error?: Error;
+  }
+
+  type Buffer = Uint8Array;
+  type Stream = object;
+  type StringOrBuffer = string | Buffer;
+
+  const kUsePromises: unique symbol;
+
+  class FileHandle {
+    constructor(fd: number, offset: number, length: number);
+    fd: number;
+    getAsyncId(): number;
+    close(): Promise<void>;
+    onread: () => void;
+    stream: Stream;
+  }
+
+  class StatWatcher {
+    constructor(useBigint: boolean);
+    initialized: boolean;
+    start(path: string, interval: number): number;
+    getAsyncId(): number;
+    close(): void;
+    ref(): void;
+    unref(): void;
+    onchange: (status: number, eventType: string, filename: string | Buffer) => void;
+  }
+
+  function access(path: StringOrBuffer, mode: number, req: FSReqCallback): void;
+  function access(path: StringOrBuffer, mode: number): void;
+  function access(path: StringOrBuffer, mode: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function chmod(path: string, mode: number, req: FSReqCallback): void;
+  function chmod(path: string, mode: number): void;
+  function chmod(path: string, mode: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function chown(path: string, uid: number, gid: number, req: FSReqCallback): void;
+  function chown(path: string, uid: number, gid: number, req: undefined, ctx: FSSyncContext): void;
+  function chown(path: string, uid: number, gid: number, usePromises: typeof kUsePromises): Promise<void>;
+  function chown(path: string, uid: number, gid: number): void;
+
+  function close(fd: number, req: FSReqCallback): void;
+  function close(fd: number): void;
+
+  function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, req: FSReqCallback): void;
+  function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, req: undefined, ctx: FSSyncContext): void;
+  function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function cpSyncCheckPaths(src: StringOrBuffer, dest: StringOrBuffer, dereference: boolean, recursive: boolean): void;
+  function cpSyncOverrideFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, preserveTimestamps: boolean): void;
+  function cpSyncCopyDir(src: StringOrBuffer, dest: StringOrBuffer, force: boolean, errorOnExist: boolean, verbatimSymlinks: boolean, dereference: boolean): void;
+
+  function fchmod(fd: number, mode: number, req: FSReqCallback): void;
+  function fchmod(fd: number, mode: number): void;
+  function fchmod(fd: number, mode: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function fchown(fd: number, uid: number, gid: number, req: FSReqCallback): void;
+  function fchown(fd: number, uid: number, gid: number): void;
+  function fchown(fd: number, uid: number, gid: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function fdatasync(fd: number, req: FSReqCallback): void;
+  function fdatasync(fd: number, req: undefined, ctx: FSSyncContext): void;
+  function fdatasync(fd: number, usePromises: typeof kUsePromises): Promise<void>;
+  function fdatasync(fd: number): void;
+
+  function fstat(fd: number, useBigint: boolean, req: FSReqCallback<Float64Array | BigUint64Array>): void;
+  function fstat(fd: number, useBigint: true, req: FSReqCallback<BigUint64Array>): void;
+  function fstat(fd: number, useBigint: false, req: FSReqCallback<Float64Array>): void;
+  function fstat(fd: number, useBigint: boolean, req: undefined, shouldNotThrow: boolean): Float64Array | BigUint64Array;
+  function fstat(fd: number, useBigint: true, req: undefined, shouldNotThrow: boolean): BigUint64Array;
+  function fstat(fd: number, useBigint: false, req: undefined, shouldNotThrow: boolean): Float64Array;
+  function fstat(fd: number, useBigint: boolean, usePromises: typeof kUsePromises): Promise<Float64Array | BigUint64Array>;
+  function fstat(fd: number, useBigint: true, usePromises: typeof kUsePromises): Promise<BigUint64Array>;
+  function fstat(fd: number, useBigint: false, usePromises: typeof kUsePromises): Promise<Float64Array>;
+
+  function fsync(fd: number, req: FSReqCallback): void;
+  function fsync(fd: number, usePromises: typeof kUsePromises): Promise<void>;
+  function fsync(fd: number): void;
+
+  function ftruncate(fd: number, len: number, req: FSReqCallback): void;
+  function ftruncate(fd: number, len: number, req: undefined, ctx: FSSyncContext): void;
+  function ftruncate(fd: number, len: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function futimes(fd: number, atime: number, mtime: number, req: FSReqCallback): void;
+  function futimes(fd: number, atime: number, mtime: number): void;
+  function futimes(fd: number, atime: number, mtime: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function internalModuleStat(receiver: unknown, path: string): number;
+
+  function lchown(path: string, uid: number, gid: number, req: FSReqCallback): void;
+  function lchown(path: string, uid: number, gid: number, req: undefined, ctx: FSSyncContext): void;
+  function lchown(path: string, uid: number, gid: number, usePromises: typeof kUsePromises): Promise<void>;
+  function lchown(path: string, uid: number, gid: number): void;
+
+  function link(existingPath: string, newPath: string, req: FSReqCallback): void;
+  function link(existingPath: string, newPath: string, req: undefined, ctx: FSSyncContext): void;
+  function link(existingPath: string, newPath: string, usePromises: typeof kUsePromises): Promise<void>;
+  function link(existingPath: string, newPath: string): void;
+
+  function lstat(path: StringOrBuffer, useBigint: boolean, req: FSReqCallback<Float64Array | BigUint64Array>): void;
+  function lstat(path: StringOrBuffer, useBigint: true, req: FSReqCallback<BigUint64Array>): void;
+  function lstat(path: StringOrBuffer, useBigint: false, req: FSReqCallback<Float64Array>): void;
+  function lstat(path: StringOrBuffer, useBigint: boolean, req: undefined, throwIfNoEntry: boolean): Float64Array | BigUint64Array;
+  function lstat(path: StringOrBuffer, useBigint: true, req: undefined, throwIfNoEntry: boolean): BigUint64Array;
+  function lstat(path: StringOrBuffer, useBigint: false, req: undefined, throwIfNoEntry: boolean): Float64Array;
+  function lstat(path: StringOrBuffer, useBigint: boolean, usePromises: typeof kUsePromises): Promise<Float64Array | BigUint64Array>;
+  function lstat(path: StringOrBuffer, useBigint: true, usePromises: typeof kUsePromises): Promise<BigUint64Array>;
+  function lstat(path: StringOrBuffer, useBigint: false, usePromises: typeof kUsePromises): Promise<Float64Array>;
+
+  function lutimes(path: string, atime: number, mtime: number, req: FSReqCallback): void;
+  function lutimes(path: string, atime: number, mtime: number): void;
+  function lutimes(path: string, atime: number, mtime: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function mkdtemp(prefix: string, encoding: unknown, req: FSReqCallback<string>): void;
+  function mkdtemp(prefix: string, encoding: unknown, req: undefined, ctx: FSSyncContext): string;
+  function mkdtemp(prefix: string, encoding: unknown, usePromises: typeof kUsePromises): Promise<string>;
+  function mkdtemp(prefix: string, encoding: unknown): string;
+
+  function mkdir(path: string, mode: number, recursive: boolean, req: FSReqCallback<void | string>): void;
+  function mkdir(path: string, mode: number, recursive: true, req: FSReqCallback<string>): void;
+  function mkdir(path: string, mode: number, recursive: false, req: FSReqCallback<void>): void;
+  function mkdir(path: string, mode: number, recursive: boolean): void | string;
+  function mkdir(path: string, mode: number, recursive: true): string;
+  function mkdir(path: string, mode: number, recursive: false): void;
+  function mkdir(path: string, mode: number, recursive: boolean, usePromises: typeof kUsePromises): Promise<void | string>;
+  function mkdir(path: string, mode: number, recursive: true, usePromises: typeof kUsePromises): Promise<string>;
+  function mkdir(path: string, mode: number, recursive: false, usePromises: typeof kUsePromises): Promise<void>;
+
+  function open(path: StringOrBuffer, flags: number, mode: number, req: FSReqCallback<number>): void;
+  function open(path: StringOrBuffer, flags: number, mode: number): number;
+
+  function openFileHandle(path: StringOrBuffer, flags: number, mode: number, usePromises: typeof kUsePromises): Promise<FileHandle>;
+
+  function read(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number, req: FSReqCallback<number>): void;
+  function read(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number, usePromises: typeof kUsePromises): Promise<number>;
+  function read(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number): number;
+
+  function readBuffers(fd: number, buffers: ArrayBufferView[], position: number, req: FSReqCallback<number>): void;
+  function readBuffers(fd: number, buffers: ArrayBufferView[], position: number, req: undefined, ctx: FSSyncContext): number;
+  function readBuffers(fd: number, buffers: ArrayBufferView[], position: number, usePromises: typeof kUsePromises): Promise<number>;
+
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: boolean, req: FSReqCallback<string[] | [string[], number[]]>): void;
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: true, req: FSReqCallback<[string[], number[]]>): void;
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: false, req: FSReqCallback<string[]>): void;
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: boolean, req: undefined, ctx: FSSyncContext): string[] | [string[], number[]];
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: true): [string[], number[]];
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: false): string[];
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: boolean, usePromises: typeof kUsePromises): Promise<string[] | [string[], number[]]>;
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: true, usePromises: typeof kUsePromises): Promise<[string[], number[]]>;
+  function readdir(path: StringOrBuffer, encoding: unknown, withFileTypes: false, usePromises: typeof kUsePromises): Promise<string[]>;
+
+  function readFileUtf8(path: StringOrBuffer, flags: number): string;
+
+  function readlink(path: StringOrBuffer, encoding: unknown, req: FSReqCallback<string | Buffer>): void;
+  function readlink(path: StringOrBuffer, encoding: unknown, req: undefined, ctx: FSSyncContext): string | Buffer;
+  function readlink(path: StringOrBuffer, encoding: unknown, usePromises: typeof kUsePromises): Promise<string | Buffer>;
+  function readlink(path: StringOrBuffer, encoding: unknown): StringOrBuffer;
+
+  function realpath(path: StringOrBuffer, encoding: unknown, req: FSReqCallback<string | Buffer>): void;
+  function realpath(path: StringOrBuffer, encoding: unknown, req: undefined, ctx: FSSyncContext): string | Buffer;
+  function realpath(path: StringOrBuffer, encoding: unknown, usePromises: typeof kUsePromises): Promise<string | Buffer>;
+  function realpath(path: StringOrBuffer, encoding: unknown): StringOrBuffer;
+
+  function rename(oldPath: string, newPath: string, req: FSReqCallback): void;
+  function rename(oldPath: string, newPath: string, req: undefined, ctx: FSSyncContext): void;
+  function rename(oldPath: string, newPath: string, usePromises: typeof kUsePromises): Promise<void>;
+  function rename(oldPath: string, newPath: string): void;
+
+  function rmdir(path: string, req: FSReqCallback): void;
+  function rmdir(path: string): void;
+  function rmdir(path: string, usePromises: typeof kUsePromises): Promise<void>;
+
+  function rmSync(path: StringOrBuffer, maxRetries: number, recursive: boolean, retryDelay: number): void;
+
+  function stat(path: StringOrBuffer, useBigint: boolean, req: FSReqCallback<Float64Array | BigUint64Array>): void;
+  function stat(path: StringOrBuffer, useBigint: true, req: FSReqCallback<BigUint64Array>): void;
+  function stat(path: StringOrBuffer, useBigint: false, req: FSReqCallback<Float64Array>): void;
+  function stat(path: StringOrBuffer, useBigint: boolean, req: undefined, ctx: FSSyncContext): Float64Array | BigUint64Array;
+  function stat(path: StringOrBuffer, useBigint: true, req: undefined, ctx: FSSyncContext): BigUint64Array;
+  function stat(path: StringOrBuffer, useBigint: false, req: undefined, ctx: FSSyncContext): Float64Array;
+  function stat(path: StringOrBuffer, useBigint: boolean, usePromises: typeof kUsePromises): Promise<Float64Array | BigUint64Array>;
+  function stat(path: StringOrBuffer, useBigint: true, usePromises: typeof kUsePromises): Promise<BigUint64Array>;
+  function stat(path: StringOrBuffer, useBigint: false, usePromises: typeof kUsePromises): Promise<Float64Array>;
+
+  function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, req: FSReqCallback): void;
+  function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, req: undefined, ctx: FSSyncContext): void;
+  function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, usePromises: typeof kUsePromises): Promise<void>;
+  function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number): void;
+
+  function unlink(path: string, req: FSReqCallback): void;
+  function unlink(path: string): void;
+  function unlink(path: string, usePromises: typeof kUsePromises): Promise<void>;
+
+  function utimes(path: string, atime: number, mtime: number, req: FSReqCallback): void;
+  function utimes(path: string, atime: number, mtime: number): void;
+  function utimes(path: string, atime: number, mtime: number, usePromises: typeof kUsePromises): Promise<void>;
+
+  function writeBuffer(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number | null, req: FSReqCallback<number>): void;
+  function writeBuffer(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number | null, req: undefined, ctx: FSSyncContext): number;
+  function writeBuffer(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number | null, usePromises: typeof kUsePromises): Promise<number>;
+
+  function writeBuffers(fd: number, buffers: ArrayBufferView[], position: number, req: FSReqCallback<number>): void;
+  function writeBuffers(fd: number, buffers: ArrayBufferView[], position: number, req: undefined, ctx: FSSyncContext): number;
+  function writeBuffers(fd: number, buffers: ArrayBufferView[], position: number, usePromises: typeof kUsePromises): Promise<number>;
+
+  function writeString(fd: number, value: string, pos: unknown, encoding: unknown, req: FSReqCallback<number>): void;
+  function writeString(fd: number, value: string, pos: unknown, encoding: unknown, req: undefined, ctx: FSSyncContext): number;
+  function writeString(fd: number, value: string, pos: unknown, encoding: unknown, usePromises: typeof kUsePromises): Promise<number>;
+
+  function getFormatOfExtensionlessFile(url: string): ConstantsBinding['internal'];
+
+  function writeFileUtf8(path: string, data: string, flag: number, mode: number): void;
+  function writeFileUtf8(fd: number, data: string, flag: number, mode: number): void;
+}
+
+export interface FsBinding {
+  FSReqCallback: typeof InternalFSBinding.FSReqCallback;
+
+  FileHandle: typeof InternalFSBinding.FileHandle;
+
+  kUsePromises: typeof InternalFSBinding.kUsePromises;
+
+  statValues: Float64Array;
+  bigintStatValues: BigUint64Array;
+
+  kFsStatsFieldsNumber: number;
+  StatWatcher: typeof InternalFSBinding.StatWatcher;
+
+  access: typeof InternalFSBinding.access;
+  chmod: typeof InternalFSBinding.chmod;
+  chown: typeof InternalFSBinding.chown;
+  close: typeof InternalFSBinding.close;
+  copyFile: typeof InternalFSBinding.copyFile;
+  cpSyncCheckPaths: typeof InternalFSBinding.cpSyncCheckPaths;
+  cpSyncOverrideFile: typeof InternalFSBinding.cpSyncOverrideFile;
+  cpSyncCopyDir: typeof InternalFSBinding.cpSyncCopyDir;
+  fchmod: typeof InternalFSBinding.fchmod;
+  fchown: typeof InternalFSBinding.fchown;
+  fdatasync: typeof InternalFSBinding.fdatasync;
+  fstat: typeof InternalFSBinding.fstat;
+  fsync: typeof InternalFSBinding.fsync;
+  ftruncate: typeof InternalFSBinding.ftruncate;
+  futimes: typeof InternalFSBinding.futimes;
+  internalModuleStat: typeof InternalFSBinding.internalModuleStat;
+  lchown: typeof InternalFSBinding.lchown;
+  link: typeof InternalFSBinding.link;
+  lstat: typeof InternalFSBinding.lstat;
+  lutimes: typeof InternalFSBinding.lutimes;
+  mkdtemp: typeof InternalFSBinding.mkdtemp;
+  mkdir: typeof InternalFSBinding.mkdir;
+  open: typeof InternalFSBinding.open;
+  openFileHandle: typeof InternalFSBinding.openFileHandle;
+  read: typeof InternalFSBinding.read;
+  readBuffers: typeof InternalFSBinding.readBuffers;
+  readdir: typeof InternalFSBinding.readdir;
+  readFileUtf8: typeof InternalFSBinding.readFileUtf8;
+  readlink: typeof InternalFSBinding.readlink;
+  realpath: typeof InternalFSBinding.realpath;
+  rename: typeof InternalFSBinding.rename;
+  rmdir: typeof InternalFSBinding.rmdir;
+  rmSync: typeof InternalFSBinding.rmSync;
+  stat: typeof InternalFSBinding.stat;
+  symlink: typeof InternalFSBinding.symlink;
+  unlink: typeof InternalFSBinding.unlink;
+  utimes: typeof InternalFSBinding.utimes;
+  writeBuffer: typeof InternalFSBinding.writeBuffer;
+  writeBuffers: typeof InternalFSBinding.writeBuffers;
+  writeFileUtf8: typeof InternalFSBinding.writeFileUtf8;
+  writeString: typeof InternalFSBinding.writeString;
+
+  getFormatOfExtensionlessFile: typeof InternalFSBinding.getFormatOfExtensionlessFile;
+}

typings/internalBinding/fs_dir.d.ts

@@ -0,0 +1,23 @@
+import { InternalFSBinding } from './fs';
+
+declare namespace InternalFSDirBinding {
+  import FSReqCallback = InternalFSBinding.FSReqCallback;
+  type Buffer = Uint8Array;
+  type StringOrBuffer = string | Buffer;
+
+  class DirHandle {
+    read(encoding: string, bufferSize: number, callback: FSReqCallback): string[] | undefined;
+    read(encoding: string, bufferSize: number): string[] | undefined;
+    close(callback: FSReqCallback): void;
+    close(): void;
+  }
+
+  function opendir(path: StringOrBuffer, encoding: string, req: FSReqCallback): DirHandle;
+  function opendir(path: StringOrBuffer, encoding: string): DirHandle;
+  function opendirSync(path: StringOrBuffer): DirHandle;
+}
+
+export interface FsDirBinding {
+  opendir: typeof InternalFSDirBinding.opendir;
+  opendirSync: typeof InternalFSDirBinding.opendirSync;
+}

typings/internalBinding/http_parser.d.ts

@@ -0,0 +1,45 @@
+declare namespace InternalHttpParserBinding {
+  type Buffer = Uint8Array;
+  type Stream = object;
+
+  class HTTPParser {
+    static REQUEST: 1;
+    static RESPONSE: 2;
+
+    static kOnMessageBegin: 0;
+    static kOnHeaders: 1;
+    static kOnHeadersComplete: 2;
+    static kOnBody: 3;
+    static kOnMessageComplete: 4;
+    static kOnExecute: 5;
+    static kOnTimeout: 6;
+
+    static kLenientNone: number;
+    static kLenientHeaders: number;
+    static kLenientChunkedLength: number;
+    static kLenientKeepAlive: number;
+    static kLenientAll: number;
+
+    close(): void;
+    free(): void;
+    execute(buffer: Buffer): Error | Buffer;
+    finish(): Error | Buffer;
+    initialize(
+      type: number,
+      resource: object,
+      maxHeaderSize?: number,
+      lenient?: number,
+      headersTimeout?: number,
+    ): void;
+    pause(): void;
+    resume(): void;
+    consume(stream: Stream): void;
+    unconsume(): void;
+    getCurrentBuffer(): Buffer;
+  }
+}
+
+export interface HttpParserBinding {
+  methods: string[];
+  HTTPParser: typeof InternalHttpParserBinding.HTTPParser;
+}

typings/internalBinding/inspector.d.ts

@@ -0,0 +1,36 @@
+interface InspectorConnectionInstance {
+  dispatch(message: string): void;
+  disconnect(): void;
+}
+
+interface InspectorConnectionConstructor {
+  new(onMessageHandler: (message: string) => void): InspectorConnectionInstance;
+}
+
+export interface InspectorBinding {
+  consoleCall(
+    inspectorMethod: (...args: any[]) => any,
+    nodeMethod: (...args: any[]) => any,
+    ...args: any[]
+  ): void;
+  setConsoleExtensionInstaller(installer: Function): void;
+  callAndPauseOnStart(
+    fn: (...args: any[]) => any,
+    thisArg: any,
+    ...args: any[]
+  ): any;
+  open(port: number, host: string): void;
+  url(): string | undefined;
+  waitForDebugger(): boolean;
+  asyncTaskScheduled(taskName: string, taskId: number, recurring: boolean): void;
+  asyncTaskCanceled(taskId: number): void;
+  asyncTaskStarted(taskId: number): void;
+  asyncTaskFinished(taskId: number): void;
+  registerAsyncHook(enable: () => void, disable: () => void): void;
+  isEnabled(): boolean;
+  emitProtocolEvent(eventName: string, params: object): void;
+  setupNetworkTracking(enable: () => void, disable: () => void): void;
+  console: Console;
+  Connection: InspectorConnectionConstructor;
+  MainThreadConnection: InspectorConnectionConstructor;
+}

typings/internalBinding/messaging.d.ts

@@ -0,0 +1,31 @@
+declare namespace InternalMessagingBinding {
+  class MessageChannel {
+    port1: MessagePort;
+    port2: MessagePort;
+  }
+
+  class MessagePort {
+    private constructor();
+    postMessage(message: any, transfer?: any[] | null): void;
+    start(): void;
+    close(): void;
+    ref(): void;
+    unref(): void;
+  }
+
+  class JSTransferable {}
+}
+
+
+export interface MessagingBinding {
+  DOMException: typeof import('internal/per_context/domexception').DOMException;
+  MessageChannel: typeof InternalMessagingBinding.MessageChannel;
+  MessagePort: typeof InternalMessagingBinding.MessagePort;
+  JSTransferable: typeof InternalMessagingBinding.JSTransferable;
+  stopMessagePort(port: typeof InternalMessagingBinding.MessagePort): void;
+  drainMessagePort(port: typeof InternalMessagingBinding.MessagePort): void;
+  receiveMessageOnPort(port: typeof InternalMessagingBinding.MessagePort): any;
+  moveMessagePortToContext(port: typeof InternalMessagingBinding.MessagePort, context: any): typeof InternalMessagingBinding.MessagePort;
+  setDeserializerCreateObjectFunction(func: (deserializeInfo: string) => any): void;
+  broadcastChannel(name: string): typeof InternalMessagingBinding.MessagePort;
+}

typings/internalBinding/modules.d.ts

@@ -0,0 +1,32 @@
+export type PackageType = 'commonjs' | 'module' | 'none'
+export type PackageConfig = {
+  name?: string
+  main?: any
+  type: PackageType
+  exports?: string | string[] | Record<string, unknown>
+  imports?: string | string[] | Record<string, unknown>
+}
+export type DeserializedPackageConfig = {
+  data: PackageConfig,
+  exists: boolean,
+  path: string,
+}
+export type SerializedPackageConfig = [
+  PackageConfig['name'],
+  PackageConfig['main'],
+  PackageConfig['type'],
+  string | undefined, // exports
+  string | undefined, // imports
+  DeserializedPackageConfig['path'], // pjson file path
+]
+
+export interface ModulesBinding {
+  readPackageJSON(path: string): SerializedPackageConfig | undefined;
+  getNearestParentPackageJSONType(path: string): PackageConfig['type']
+  getNearestParentPackageJSON(path: string): SerializedPackageConfig | undefined
+  getPackageScopeConfig(path: string): SerializedPackageConfig | undefined
+  getPackageType(path: string): PackageConfig['type'] | undefined
+  enableCompileCache(path?: string): { status: number, message?: string, directory?: string }
+  getCompileCacheDir(): string | undefined
+  flushCompileCache(keepDeserializedCache?: boolean): void
+}

typings/internalBinding/options.d.ts

@@ -0,0 +1,35 @@
+export interface OptionsBinding {
+  getOptions(): {
+    options: Map<
+      string,
+      {
+        helpText: string;
+        envVarSettings: 0 | 1;
+      } & (
+        | { type: 0 | 1; value: undefined }
+        | { type: 2; value: boolean }
+        | { type: 3 | 4; value: number }
+        | { type: 5; value: string }
+        | { type: 6; value: { host: string; port: number } }
+        | { type: 7; value: string[] }
+      )
+    >;
+    aliases: Map<string, string[]>;
+  };
+  envSettings: {
+    kAllowedInEnvvar: 0;
+    kDisallowedInEnvvar: 1;
+  };
+  noGlobalSearchPaths: boolean;
+  shouldNotRegisterESMLoader: boolean;
+  types: {
+    kNoOp: 0;
+    kV8Option: 1;
+    kBoolean: 2;
+    kInteger: 3;
+    kUInteger: 4;
+    kString: 5;
+    kHostPort: 6;
+    kStringList: 7;
+  };
+}

typings/internalBinding/os.d.ts

@@ -0,0 +1,25 @@
+declare namespace InternalOSBinding {
+  type OSContext = {};
+}
+
+export interface OSBinding {
+  getHostname(ctx: InternalOSBinding.OSContext): string | undefined;
+  getLoadAvg(array: Float64Array): void;
+  getUptime(): number;
+  getTotalMem(): number;
+  getFreeMem(): number;
+  getCPUs(): Array<string | number>;
+  getInterfaceAddresses(ctx: InternalOSBinding.OSContext): Array<string | number | boolean> | undefined;
+  getHomeDirectory(ctx: InternalOSBinding.OSContext): string | undefined;
+  getUserInfo(options: { encoding?: string } | undefined, ctx: InternalOSBinding.OSContext): {
+    uid: number;
+    gid: number;
+    username: string;
+    homedir: string;
+    shell: string | null;
+  } | undefined;
+  setPriority(pid: number, priority: number, ctx: InternalOSBinding.OSContext): number;
+  getPriority(pid: number, ctx: InternalOSBinding.OSContext): number | undefined;
+  getOSInformation(ctx: InternalOSBinding.OSContext): [sysname: string, version: string, release: string];
+  isBigEndian: boolean;
+}

typings/internalBinding/process.d.ts

@@ -0,0 +1,15 @@
+interface CpuUsageValue { 
+  user: number;
+  system: number;
+}
+
+declare namespace InternalProcessBinding {
+  interface Process {
+    cpuUsage(previousValue?: CpuUsageValue): CpuUsageValue;
+    threadCpuUsage(previousValue?: CpuUsageValue): CpuUsageValue;
+  }
+}
+
+export interface ProcessBinding {
+  process: InternalProcessBinding.Process;
+}

typings/internalBinding/quic.d.ts

@@ -0,0 +1,100 @@
+interface QuicCallbacks {
+  onEndpointClose: (context: number, status: number) => void;
+  onSessionNew: (session: Session) => void;
+  onSessionClose: (type: number, code: bigint, reason?: string) => void;
+  onSessionDatagram: (datagram: Uint8Array, early: boolean) => void;
+  onSessionDatagramStatus: (id: bigint, status: string) => void;
+  onSessionHandshake: (sni: string,
+                       alpn: string,
+                       cipher: string,
+                       cipherVersion: string,
+                       validationReason?: string,
+                       validationCode?: string) => void;
+  onSessionPathValidation: (result: string,
+                            local: SocketAddress,
+                            remote: SocketAddress,
+                            preferred: boolean) => void;
+  onSessionTicket: (ticket: ArrayBuffer) => void;
+  onSessionVersionNegotiation: (version: number,
+                                versions: number[],
+                                supports: number[]) => void;
+  onStreamCreated: (stream: Stream) => void;
+  onStreamBlocked: () => void;
+  onStreamClose: (error: [number,bigint,string]) => void;
+  onStreamReset: (error: [number,bigint,string]) => void;
+  onStreamHeaders: (headers: string[], kind: number) => void;
+  onStreamTrailers: () => void;
+}
+
+interface EndpointOptions {
+  address?: SocketAddress;
+  retryTokenExpiration?: number|bigint;
+  tokenExpiration?: number|bigint;
+  maxConnectionsPerHost?: number|bigint;
+  maxConnectionsTotal?: number|bigint;
+  maxStatelessResetsPerHost?: number|bigint;
+  addressLRUSize?: number|bigint;
+  maxRetries?: number|bigint;
+  maxPayloadSize?: number|bigint;
+  unacknowledgedPacketThreshold?: number|bigint;
+  validateAddress?: boolean;
+  disableStatelessReset?: boolean;
+  ipv6Only?: boolean;
+  udpReceiveBufferSize?: number;
+  udpSendBufferSize?: number;
+  udpTTL?: number;
+  resetTokenSecret?: ArrayBufferView;
+  tokenSecret?: ArrayBufferView;
+  cc?: 'reno'|'cubic'|'pcc'|'bbr'| 0 | 2 | 3 | 4;
+}
+
+interface SessionOptions {}
+interface SocketAddress {}
+
+interface Session {}
+interface Stream {}
+
+interface Endpoint {
+  listen(options: SessionOptions): void;
+  connect(address: SocketAddress, options: SessionOptions): Session;
+  closeGracefully(): void;
+  markBusy(on?: boolean): void;
+  ref(on?: boolean): void;
+  address(): SocketAddress|void;
+  readonly state: ArrayBuffer;
+  readonly stats: ArrayBuffer;
+}
+
+export interface QuicBinding {
+  setCallbacks(callbacks: QuicCallbacks): void;
+  flushPacketFreeList(): void;
+
+  readonly IDX_STATS_ENDPOINT_CREATED_AT: number;
+  readonly IDX_STATS_ENDPOINT_DESTROYED_AT: number;
+  readonly IDX_STATS_ENDPOINT_BYTES_RECEIVED: number;
+  readonly IDX_STATS_ENDPOINT_BYTES_SENT: number;
+  readonly IDX_STATS_ENDPOINT_PACKETS_RECEIVED: number;
+  readonly IDX_STATS_ENDPOINT_PACKETS_SENT: number;
+  readonly IDX_STATS_ENDPOINT_SERVER_SESSIONS: number;
+  readonly IDX_STATS_ENDPOINT_CLIENT_SESSIONS: number;
+  readonly IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT: number;
+  readonly IDX_STATS_ENDPOINT_RETRY_COUNT: number;
+  readonly IDX_STATS_ENDPOINT_VERSION_NEGOTIATION_COUNT: number;
+  readonly IDX_STATS_ENDPOINT_STATELESS_RESET_COUNT: number;
+  readonly IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT: number;
+  readonly IDX_STATS_ENDPOINT_COUNT: number;
+  readonly IDX_STATE_ENDPOINT_BOUND: number;
+  readonly IDX_STATE_ENDPOINT_BOUND_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_RECEIVING: number;
+  readonly IDX_STATE_ENDPOINT_RECEIVING_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_LISTENING: number;
+  readonly IDX_STATE_ENDPOINT_LISTENING_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_CLOSING: number;
+  readonly IDX_STATE_ENDPOINT_CLOSING_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_WAITING_FOR_CALLBACKS: number;
+  readonly IDX_STATE_ENDPOINT_WAITING_FOR_CALLBACKS_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_BUSY: number;
+  readonly IDX_STATE_ENDPOINT_BUSY_SIZE: number;
+  readonly IDX_STATE_ENDPOINT_PENDING_CALLBACKS: number;
+  readonly IDX_STATE_ENDPOINT_PENDING_CALLBACKS_SIZE: number;
+}

typings/internalBinding/serdes.d.ts

@@ -0,0 +1,36 @@
+declare namespace InternalSerdesBinding {
+  type Buffer = Uint8Array;
+
+  class Serializer {
+    _getDataCloneError: typeof Error;
+    constructor();
+    _setTreatArrayBufferViewsAsHostObjects(value: boolean): void;
+    releaseBuffer(): Buffer;
+    transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+    writeDouble(value: number): void;
+    writeHeader(): void;
+    writeRawBytes(value: ArrayBufferView): void;
+    writeUint32(value: number): void;
+    writeUint64(hi: number, lo: number): void;
+    writeValue(value: any): void;
+  }
+
+  class Deserializer {
+    buffer: ArrayBufferView;
+    constructor(buffer: ArrayBufferView);
+    _readRawBytes(length: number): number;
+    getWireFormatVersion(): number;
+    readDouble(): number;
+    readHeader(): boolean;
+    readRawBytes(length: number): Buffer;
+    readUint32(): number;
+    readUint64(): [hi: number, lo: number];
+    readValue(): unknown;
+    transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer | SharedArrayBuffer): void;
+  }
+}
+
+export interface SerdesBinding {
+  Serializer: typeof InternalSerdesBinding.Serializer;
+  Deserializer: typeof InternalSerdesBinding.Deserializer;
+}

typings/internalBinding/symbols.d.ts

@@ -0,0 +1,25 @@
+export const async_id_symbol: unique symbol;
+export const handle_onclose_symbol: unique symbol;
+export const no_message_symbol: unique symbol;
+export const messaging_deserialize_symbol: unique symbol;
+export const messaging_transfer_symbol: unique symbol;
+export const messaging_clone_symbol: unique symbol;
+export const messaging_transfer_list_symbol: unique symbol;
+export const oninit_symbol: unique symbol;
+export const owner_symbol: unique symbol;
+export const onpskexchange_symbol: unique symbol;
+export const trigger_async_id_symbol: unique symbol;
+
+export interface SymbolsBinding {
+  async_id_symbol: typeof async_id_symbol;
+  handle_onclose_symbol: typeof handle_onclose_symbol;
+  no_message_symbol: typeof no_message_symbol;
+  messaging_deserialize_symbol: typeof messaging_deserialize_symbol;
+  messaging_transfer_symbol: typeof messaging_transfer_symbol;
+  messaging_clone_symbol: typeof messaging_clone_symbol;
+  messaging_transfer_list_symbol: typeof messaging_transfer_list_symbol;
+  oninit_symbol: typeof oninit_symbol;
+  owner_symbol: typeof owner_symbol;
+  onpskexchange_symbol: typeof onpskexchange_symbol;
+  trigger_async_id_symbol: typeof trigger_async_id_symbol;
+}

typings/internalBinding/timers.d.ts

@@ -0,0 +1,8 @@
+export interface TimersBinding {
+  getLibuvNow(): number;
+  setupTimers(immediateCallback: () => void, timersCallback: (now: number) => void): void;
+  scheduleTimer(msecs: number): void;
+  toggleTimerRef(value: boolean): void;
+  toggleImmediateRef(value: boolean): void;
+  immediateInfo: Uint32Array;
+}

typings/internalBinding/types.d.ts

@@ -0,0 +1,26 @@
+export interface TypesBinding {
+  isAsyncFunction(value: unknown): value is (...args: unknown[]) => Promise<unknown>;
+  isGeneratorFunction(value: unknown): value is GeneratorFunction;
+  isAnyArrayBuffer(value: unknown): value is (ArrayBuffer | SharedArrayBuffer);
+  isArrayBuffer(value: unknown): value is ArrayBuffer;
+  isArgumentsObject(value: unknown): value is ArrayLike<unknown>;
+  isBoxedPrimitive(value: unknown): value is (BigInt | Boolean | Number | String | Symbol);
+  isDataView(value: unknown): value is DataView;
+  isExternal(value: unknown): value is Object;
+  isMap(value: unknown): value is Map<unknown, unknown>;
+  isMapIterator: (value: unknown) => value is IterableIterator<unknown>;
+  isModuleNamespaceObject: (value: unknown) => value is { [Symbol.toStringTag]: 'Module' };
+  isNativeError: (value: unknown) => Error;
+  isPromise: (value: unknown) => value is Promise<unknown>;
+  isSet: (value: unknown) => value is Set<unknown>;
+  isSetIterator: (value: unknown) => value is IterableIterator<unknown>;
+  isWeakMap: (value: unknown) => value is WeakMap<object, unknown>;
+  isWeakSet: (value: unknown) => value is WeakSet<object>;
+  isRegExp: (value: unknown) => RegExp;
+  isDate: (value: unknown) => Date;
+  isTypedArray: (value: unknown) => value is TypedArray;
+  isStringObject: (value: unknown) => value is String;
+  isNumberObject: (value: unknown) => value is Number;
+  isBooleanObject: (value: unknown) => value is Boolean,
+  isBigIntObject: (value: unknown) => value is BigInt;
+}

typings/internalBinding/url.d.ts

@@ -0,0 +1,13 @@
+import type { urlUpdateActions } from 'internal/url'
+
+export interface URLBinding {
+  urlComponents: Uint32Array;
+
+  domainToASCII(input: string): string;
+  domainToUnicode(input: string): string;
+  canParse(input: string): boolean;
+  canParse(input: string, base: string): boolean;
+  format(input: string, fragment?: boolean, unicode?: boolean, search?: boolean, auth?: boolean): string;
+  parse(input: string, base?: string): string | false;
+  update(input: string, actionType: typeof urlUpdateActions, value: string): string | false;
+}

typings/internalBinding/url_pattern.d.ts

@@ -0,0 +1,20 @@
+export class URLPattern {
+  protocol: string
+  username: string
+  password: string
+  hostname: string
+  port: string
+  pathname: string
+  search: string
+  hash: string
+
+  constructor(input: Record<string, string> | string, options?: { ignoreCase: boolean });
+  constructor(input: Record<string, string> | string, baseUrl?: string, options?: { ignoreCase: boolean });
+
+  exec(input: string | Record<string, string>, baseURL?: string): null | Record<string, unknown>;
+  test(input: string | Record<string, string>, baseURL?: string): boolean;
+}
+
+export interface URLPatternBinding {
+  URLPattern: URLPattern;
+}

typings/internalBinding/util.d.ts

@@ -0,0 +1,49 @@
+declare namespace InternalUtilBinding {
+  class WeakReference<T> {
+    constructor(value: T);
+    get(): undefined | T;
+    incRef(): void;
+    decRef(): void;
+  }
+}
+
+export interface UtilBinding {
+  // PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES, defined in src/env_properties.h
+  arrow_message_private_symbol: 1;
+  contextify_context_private_symbol: 2;
+  decorated_private_symbol: 3;
+  napi_type_tag: 4;
+  napi_wrapper: 5;
+  untransferable_object_private_symbol: 6;
+  exiting_aliased_Uint32Array: 7;
+
+  kPending: 0;
+  kFulfilled: 1;
+  kRejected: 2;
+
+  getHiddenValue(object: object, index: number): any;
+  setHiddenValue(object: object, index: number, value: any): boolean;
+  getPromiseDetails(promise: any): undefined | [state: 0] | [state: 1 | 2, result: any];
+  getProxyDetails(proxy: any, fullProxy?: boolean): undefined | any | [target: any, handler: any];
+  previewEntries(object: object, slowPath?: boolean): undefined | any[] | [entries: any[], isKeyValue: boolean];
+  getOwnNonIndexProperties(object: object, filter: number): Array<string | symbol>;
+  getConstructorName(object: object): string;
+  getExternalValue(value: any): bigint;
+  sleep(msec: number): void;
+  isConstructor(fn: Function): boolean;
+  arrayBufferViewHasBuffer(view: ArrayBufferView): boolean;
+  propertyFilter: {
+    ALL_PROPERTIES: 0;
+    ONLY_WRITABLE: 1;
+    ONLY_ENUMERABLE: 2;
+    ONLY_CONFIGURABLE: 4;
+    SKIP_STRINGS: 8;
+    SKIP_SYMBOLS: 16;
+  };
+  shouldAbortOnUncaughtToggle: [shouldAbort: 0 | 1];
+  WeakReference: typeof InternalUtilBinding.WeakReference;
+  guessHandleType(fd: number): 'TCP' | 'TTY' | 'UDP' | 'FILE' | 'PIPE' | 'UNKNOWN';
+  parseEnv(content: string): Record<string, string>;
+  styleText(format: Array<string> | string, text: string): string;
+  isInsideNodeModules(frameLimit: number, defaultValue: unknown): boolean;
+}

typings/internalBinding/wasi.d.ts

@@ -0,0 +1,14 @@
+declare namespace InternalWASIBinding {
+  type EnvStr = `${string}=${string}`
+
+  class WASI {
+    constructor(args: string[], env: EnvStr[], preopens: string[], stdio: [stdin: number, stdout: number, stderr: number])
+
+    _setMemory(memory: WebAssembly.Memory): void;
+  }
+}
+
+export interface WASIBinding {
+  WASI: typeof InternalWASIBinding.WASI;
+}
+

typings/internalBinding/worker.d.ts

@@ -0,0 +1,36 @@
+import { InternalMessagingBinding } from './messaging';
+
+declare namespace InternalWorkerBinding {
+  class Worker {
+    constructor(
+      url: string | URL | null,
+      env: object | null | undefined,
+      execArgv: string[] | null | undefined,
+      resourceLimits: Float64Array,
+      trackUnmanagedFds: boolean,
+    );
+    startThread(): void;
+    stopThread(): void;
+    ref(): void;
+    unref(): void;
+    getResourceLimits(): Float64Array;
+    takeHeapSnapshot(): object;
+    getHeapStatistics(): Promise<object>;
+    loopIdleTime(): number;
+    loopStartTime(): number;
+  }
+}
+
+export interface WorkerBinding {
+  Worker: typeof InternalWorkerBinding.Worker;
+  getEnvMessagePort(): InternalMessagingBinding.MessagePort;
+  threadId: number;
+  isMainThread: boolean;
+  ownsProcessState: boolean;
+  resourceLimits?: Float64Array;
+  kMaxYoungGenerationSizeMb: number;
+  kMaxOldGenerationSizeMb: number;
+  kCodeRangeSizeMb: number;
+  kStackSizeMb: number;
+  kTotalResourceLimitCount: number;
+}

typings/internalBinding/zlib.d.ts

@@ -0,0 +1,40 @@
+import { TypedArray } from '../globals';
+
+declare namespace InternalZlibBinding {
+  class ZlibBase {
+    // These attributes are not used by the C++ binding, but declared on JS side.
+    buffer?: TypedArray;
+    cb?: VoidFunction;
+    availOutBefore?: number;
+    availInBefore?: number;
+    inOff?: number;
+    flushFlag?: number;
+
+    reset(): void;
+    close(): void;
+    params(level: number, strategy: number): void;
+    write(flushFlag: number, input: TypedArray, inputOff: number, inputLen: number, out: TypedArray, outOff: number, outLen: number): void;
+    writeSync(flushFlag: number, input: TypedArray, inputOff: number, inputLen: number, out: TypedArray, outOff: number, outLen: number): void;
+  }
+
+  class Zlib extends ZlibBase{
+    constructor(mode: number)
+    init(windowBits: number, level: number, memLevel: number, strategy: number, writeState: Uint32Array, callback: VoidFunction, dictionary: Uint32Array): number;
+  }
+
+  class BrotliDecoder extends ZlibBase {
+    constructor(mode: number);
+    init(initParamsArray: Uint32Array, writeState: Uint32Array, callback: VoidFunction): boolean;
+  }
+
+  class BrotliEncoder extends ZlibBase {
+    constructor(mode: number);
+    init(initParamsArray: Uint32Array, writeState: Uint32Array, callback: VoidFunction): boolean;
+  }
+}
+
+export interface ZlibBinding {
+  BrotliDecoder: typeof InternalZlibBinding.BrotliDecoder;
+  BrotliEncoder: typeof InternalZlibBinding.BrotliEncoder;
+  Zlib: typeof InternalZlibBinding.Zlib;
+}

typings/primordials.d.ts

@@ -0,0 +1,558 @@
+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>;
+
+type UncurryMethod<O, K extends keyof O, T = O> =
+  O[K] extends (this: infer U, ...args: infer A) => infer R
+    ? (self: unknown extends U ? T : U, ...args: A) => R
+    : never;
+type UncurryMethodApply<O, K extends keyof O, T = O> =
+  O[K] extends (this: infer U, ...args: infer A) => infer R
+    ? (self: unknown extends U ? T : U, args: A) => R
+    : never;
+
+type UncurryGetter<O, K extends keyof O, T = O> =
+  O[K] extends infer V ? (self: T) => V : never;
+type UncurrySetter<O, K extends keyof O, T = O> =
+  O[K] extends infer V ? (self: T, value: V) => void : never;
+
+type TypedArrayContentType<T extends TypedArray> = T extends { [k: number]: infer V } ? V : never;
+
+/**
+ * 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 {
+  export function uncurryThis<T extends (...args: unknown[]) => unknown>(fn: T): UncurryThis<T>;
+  export function makeSafe<T extends NewableFunction>(unsafe: NewableFunction, safe: T): T;
+
+  export import decodeURI = globalThis.decodeURI;
+  export import decodeURIComponent = globalThis.decodeURIComponent;
+  export import encodeURI = globalThis.encodeURI;
+  export import encodeURIComponent = globalThis.encodeURIComponent;
+  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 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 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 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 import AggregateError = globalThis.AggregateError;
+  export const AggregateErrorPrototype: typeof AggregateError.prototype
+  export import Array = globalThis.Array;
+  export const ArrayPrototype: typeof Array.prototype
+  export const ArrayIsArray: typeof Array.isArray
+  export const ArrayFrom: typeof Array.from
+  export const ArrayFromAsync: typeof Array.fromAsync
+  export const ArrayOf: typeof Array.of
+  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 ArrayPrototypeToSorted: UncurryThis<typeof Array.prototype.toSorted>
+  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 ArrayPrototypeSymbolIterator: UncurryMethod<typeof Array.prototype, typeof Symbol.iterator>;
+  export import ArrayBuffer = globalThis.ArrayBuffer;
+  export const ArrayBufferPrototype: typeof ArrayBuffer.prototype
+  export const ArrayBufferIsView: typeof ArrayBuffer.isView
+  export const ArrayBufferPrototypeGetDetached: UncurryThis<typeof ArrayBuffer.prototype.detached>
+  export const ArrayBufferPrototypeSlice: UncurryThis<typeof ArrayBuffer.prototype.slice>
+  export const ArrayBufferPrototypeTransfer: UncurryThis<typeof ArrayBuffer.prototype.transfer>
+  export const ArrayBufferPrototypeGetByteLength: UncurryGetter<typeof ArrayBuffer.prototype , "byteLength">;
+  export const AsyncIteratorPrototype: AsyncIterable<any>;
+  export import BigInt = globalThis.BigInt;
+  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 import BigInt64Array = globalThis.BigInt64Array;
+  export const BigInt64ArrayPrototype: typeof BigInt64Array.prototype
+  export const BigInt64ArrayBYTES_PER_ELEMENT: typeof BigInt64Array.BYTES_PER_ELEMENT
+  export import BigUint64Array = globalThis.BigUint64Array;
+  export const BigUint64ArrayPrototype: typeof BigUint64Array.prototype
+  export const BigUint64ArrayBYTES_PER_ELEMENT: typeof BigUint64Array.BYTES_PER_ELEMENT
+  export import Boolean = globalThis.Boolean;
+  export const BooleanPrototype: typeof Boolean.prototype
+  export const BooleanPrototypeToString: UncurryThis<typeof Boolean.prototype.toString>
+  export const BooleanPrototypeValueOf: UncurryThis<typeof Boolean.prototype.valueOf>
+  export import DataView = globalThis.DataView;
+  export const DataViewPrototype: typeof DataView.prototype
+  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 DataViewPrototypeGetBuffer: UncurryGetter<typeof DataView.prototype, "buffer">;
+  export const DataViewPrototypeGetByteLength: UncurryGetter<typeof DataView.prototype, "byteLength">;
+  export const DataViewPrototypeGetByteOffset: UncurryGetter<typeof DataView.prototype, "byteOffset">;
+  export import Date = globalThis.Date;
+  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 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 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 DatePrototypeSymbolToPrimitive: UncurryMethod<typeof Date.prototype, typeof Symbol.toPrimitive>;
+  export import Error = globalThis.Error;
+  export const ErrorPrototype: typeof Error.prototype
+  // @ts-ignore
+  export const ErrorCaptureStackTrace: typeof Error.captureStackTrace
+  export const ErrorPrototypeToString: UncurryThis<typeof Error.prototype.toString>
+  export import EvalError = globalThis.EvalError;
+  export const EvalErrorPrototype: typeof EvalError.prototype
+  export import Float32Array = globalThis.Float32Array;
+  export const Float32ArrayPrototype: typeof Float32Array.prototype
+  export const Float32ArrayBYTES_PER_ELEMENT: typeof Float32Array.BYTES_PER_ELEMENT
+  export import Float64Array = globalThis.Float64Array;
+  export const Float64ArrayPrototype: typeof Float64Array.prototype
+  export const Float64ArrayBYTES_PER_ELEMENT: typeof Float64Array.BYTES_PER_ELEMENT
+  export import Function = 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 import Int16Array = globalThis.Int16Array;
+  export const Int16ArrayPrototype: typeof Int16Array.prototype
+  export const Int16ArrayBYTES_PER_ELEMENT: typeof Int16Array.BYTES_PER_ELEMENT
+  export import Int32Array = globalThis.Int32Array;
+  export const Int32ArrayPrototype: typeof Int32Array.prototype
+  export const Int32ArrayBYTES_PER_ELEMENT: typeof Int32Array.BYTES_PER_ELEMENT
+  export import Int8Array = globalThis.Int8Array;
+  export const Int8ArrayPrototype: typeof Int8Array.prototype
+  export const Int8ArrayBYTES_PER_ELEMENT: typeof Int8Array.BYTES_PER_ELEMENT
+  export import Map = globalThis.Map;
+  export const MapPrototype: typeof Map.prototype
+  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 MapPrototypeGetSize: UncurryGetter<typeof Map.prototype, "size">;
+  export import Number = globalThis.Number;
+  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 import Object = globalThis.Object;
+  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 ObjectPrototypeHasOwnProperty: UncurryThis<typeof Object.prototype.hasOwnProperty>
+  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 import RangeError = globalThis.RangeError;
+  export const RangeErrorPrototype: typeof RangeError.prototype
+  export import ReferenceError = globalThis.ReferenceError;
+  export const ReferenceErrorPrototype: typeof ReferenceError.prototype
+  export import RegExp = globalThis.RegExp;
+  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 RegExpPrototypeGetDotAll: UncurryGetter<typeof RegExp.prototype, "dotAll">;
+  export const RegExpPrototypeGetFlags: UncurryGetter<typeof RegExp.prototype, "flags">;
+  export const RegExpPrototypeGetGlobal: UncurryGetter<typeof RegExp.prototype, "global">;
+  export const RegExpPrototypeGetIgnoreCase: UncurryGetter<typeof RegExp.prototype, "ignoreCase">;
+  export const RegExpPrototypeGetMultiline: UncurryGetter<typeof RegExp.prototype, "multiline">;
+  export const RegExpPrototypeGetSource: UncurryGetter<typeof RegExp.prototype, "source">;
+  export const RegExpPrototypeGetSticky: UncurryGetter<typeof RegExp.prototype, "sticky">;
+  export const RegExpPrototypeGetUnicode: UncurryGetter<typeof RegExp.prototype, "unicode">;
+  export import Set = globalThis.Set;
+  export const SetLength: typeof Set.length
+  export const SetName: typeof Set.name
+  export const SetPrototype: typeof Set.prototype
+  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 SetPrototypeGetSize: UncurryGetter<typeof Set.prototype, "size">;
+  export import String = 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 StringFromCharCodeApply: StaticApply<typeof String.fromCharCode>
+  export const StringFromCodePoint: typeof String.fromCodePoint
+  export const StringFromCodePointApply: StaticApply<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 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 StringPrototypeToWellFormed: UncurryThis<typeof String.prototype.toWellFormed>
+  export const StringPrototypeValueOf: UncurryThis<typeof String.prototype.valueOf>
+  export const StringPrototypeReplaceAll: UncurryThis<typeof String.prototype.replaceAll>
+  export import Symbol = globalThis.Symbol;
+  export const SymbolPrototype: typeof Symbol.prototype
+  export const SymbolFor: typeof Symbol.for
+  export const SymbolKeyFor: typeof Symbol.keyFor
+  export const SymbolAsyncDispose: typeof Symbol.asyncDispose
+  export const SymbolAsyncIterator: typeof Symbol.asyncIterator
+  export const SymbolDispose: typeof Symbol.dispose
+  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 SymbolPrototypeSymbolToPrimitive: UncurryMethod<typeof Symbol.prototype, typeof Symbol.toPrimitive, symbol | Symbol>;
+  export const SymbolPrototypeGetDescription: UncurryGetter<typeof Symbol.prototype, "description", symbol | Symbol>;
+  export import SyntaxError = globalThis.SyntaxError;
+  export const SyntaxErrorPrototype: typeof SyntaxError.prototype
+  export import TypeError = globalThis.TypeError;
+  export const TypeErrorPrototype: typeof TypeError.prototype
+  export function TypedArrayFrom<T extends TypedArray>(
+    constructor: new (length: number) => T,
+    source:
+      | Iterable<TypedArrayContentType<T>>
+      | ArrayLike<TypedArrayContentType<T>>,
+  ): T;
+  export function TypedArrayFrom<T extends TypedArray, U, THIS_ARG = undefined>(
+    constructor: new (length: number) => T,
+    source: Iterable<U> | ArrayLike<U>,
+    mapfn: (
+      this: THIS_ARG,
+      value: U,
+      index: number,
+    ) => TypedArrayContentType<T>,
+    thisArg?: THIS_ARG,
+  ): T;
+  export function TypedArrayOf<T extends TypedArray>(
+    constructor: new (length: number) => T,
+    ...items: readonly TypedArrayContentType<T>[]
+  ): T;
+  export function TypedArrayOfApply<T extends TypedArray>(
+    constructor: new (length: number) => T,
+    items: readonly TypedArrayContentType<T>[],
+  ): T;
+  export const TypedArray: TypedArray;
+  export const TypedArrayPrototype:
+    | typeof Uint8Array.prototype
+    | typeof Int8Array.prototype
+    | typeof Uint16Array.prototype
+    | typeof Int16Array.prototype
+    | typeof Uint32Array.prototype
+    | typeof Int32Array.prototype
+    | typeof Float32Array.prototype
+    | typeof Float64Array.prototype
+    | typeof BigInt64Array.prototype
+    | typeof BigUint64Array.prototype
+    | typeof Uint8ClampedArray.prototype;
+  export const TypedArrayPrototypeGetBuffer: UncurryGetter<TypedArray, "buffer">;
+  export const TypedArrayPrototypeGetByteLength: UncurryGetter<TypedArray, "byteLength">;
+  export const TypedArrayPrototypeGetByteOffset: UncurryGetter<TypedArray, "byteOffset">;
+  export const TypedArrayPrototypeGetLength: UncurryGetter<TypedArray, "length">;
+  export function TypedArrayPrototypeAt<T extends TypedArray>(self: T, ...args: Parameters<T["at"]>): ReturnType<T["at"]>;
+  export function TypedArrayPrototypeIncludes<T extends TypedArray>(self: T, ...args: Parameters<T["includes"]>): ReturnType<T["includes"]>;
+  export function TypedArrayPrototypeFill<T extends TypedArray>(self: T, ...args: Parameters<T["fill"]>): ReturnType<T["fill"]>;
+  export function TypedArrayPrototypeSet<T extends TypedArray>(self: T, ...args: Parameters<T["set"]>): ReturnType<T["set"]>;
+  export function TypedArrayPrototypeSubarray<T extends TypedArray>(self: T, ...args: Parameters<T["subarray"]>): ReturnType<T["subarray"]>;
+  export function TypedArrayPrototypeSlice<T extends TypedArray>(self: T, ...args: Parameters<T["slice"]>): ReturnType<T["slice"]>;
+  export function TypedArrayPrototypeGetSymbolToStringTag(self: unknown):
+    | 'Int8Array'
+    | 'Int16Array'
+    | 'Int32Array'
+    | 'Uint8Array'
+    | 'Uint16Array'
+    | 'Uint32Array'
+    | 'Uint8ClampedArray'
+    | 'BigInt64Array'
+    | 'BigUint64Array'
+    | 'Float32Array'
+    | 'Float64Array'
+    | undefined;
+  export import URIError = globalThis.URIError;
+  export const URIErrorPrototype: typeof URIError.prototype
+  export import Uint16Array = globalThis.Uint16Array;
+  export const Uint16ArrayPrototype: typeof Uint16Array.prototype
+  export const Uint16ArrayBYTES_PER_ELEMENT: typeof Uint16Array.BYTES_PER_ELEMENT
+  export import Uint32Array = globalThis.Uint32Array;
+  export const Uint32ArrayPrototype: typeof Uint32Array.prototype
+  export const Uint32ArrayBYTES_PER_ELEMENT: typeof Uint32Array.BYTES_PER_ELEMENT
+  export import Uint8Array = globalThis.Uint8Array;
+  export const Uint8ArrayPrototype: typeof Uint8Array.prototype
+  export const Uint8ArrayBYTES_PER_ELEMENT: typeof Uint8Array.BYTES_PER_ELEMENT
+  export import Uint8ClampedArray = globalThis.Uint8ClampedArray;
+  export const Uint8ClampedArrayPrototype: typeof Uint8ClampedArray.prototype
+  export const Uint8ClampedArrayBYTES_PER_ELEMENT: typeof Uint8ClampedArray.BYTES_PER_ELEMENT
+  export import WeakMap = globalThis.WeakMap;
+  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 import WeakSet = globalThis.WeakSet;
+  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 import Promise = globalThis.Promise;
+  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>
+  export const PromiseWithResolvers: typeof Promise.withResolvers
+  export import Proxy = globalThis.Proxy
+  import _globalThis = globalThis
+  export { _globalThis as globalThis }
+}