Dante/Kmake
1
0
Fork 0
forked from LeenkxTeam/Kmake
Code Pull Requests Activity

Upload Kmake

Browse Source
This commit is contained in:
Gorochu
2026-05-26 23:36:42 -07:00
parent ba051b2f74
commit 555ec72358
41615 changed files with 13344630 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
typings/internalBinding/async_wrap.d.ts vendored Normal file
View File

@ -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;
}

11
typings/internalBinding/blob.d.ts vendored Normal file
View File

@ -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;
}

12
typings/internalBinding/config.d.ts vendored Normal file
View File

@ -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;
}

394
typings/internalBinding/constants.d.ts vendored Normal file
View File

@ -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;
};
}

10
typings/internalBinding/debug.d.ts vendored Normal file
View File

@ -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;
}

302
typings/internalBinding/fs.d.ts vendored Normal file
View File

@ -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;
}

23
typings/internalBinding/fs_dir.d.ts vendored Normal file
View File

@ -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;
}

45
typings/internalBinding/http_parser.d.ts vendored Normal file
View File

@ -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;
}

36
typings/internalBinding/inspector.d.ts vendored Normal file
View File

@ -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;
}

31
typings/internalBinding/messaging.d.ts vendored Normal file
View File

@ -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;
}

32
typings/internalBinding/modules.d.ts vendored Normal file
View File

@ -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
}

35
typings/internalBinding/options.d.ts vendored Normal file
View File

@ -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;
};
}

25
typings/internalBinding/os.d.ts vendored Normal file
View File

@ -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;
}

15
typings/internalBinding/process.d.ts vendored Normal file
View File

@ -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;
}

100
typings/internalBinding/quic.d.ts vendored Normal file
View File

@ -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;
}

36
typings/internalBinding/serdes.d.ts vendored Normal file
View File

@ -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;
}

25
typings/internalBinding/symbols.d.ts vendored Normal file
View File

@ -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;
}

8
typings/internalBinding/timers.d.ts vendored Normal file
View File

@ -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;
}

26
typings/internalBinding/types.d.ts vendored Normal file
View File

@ -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;
}

13
typings/internalBinding/url.d.ts vendored Normal file
View File

@ -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;
}

20
typings/internalBinding/url_pattern.d.ts vendored Normal file
View File

@ -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;
}

49
typings/internalBinding/util.d.ts vendored Normal file
View File

@ -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;
}

14
typings/internalBinding/wasi.d.ts vendored Normal file
View File

@ -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;
}

36
typings/internalBinding/worker.d.ts vendored Normal file
View File

@ -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;
}

40
typings/internalBinding/zlib.d.ts vendored Normal file
View File

@ -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;
}