Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
LICENSE	1.11 KB	-rwxr-xr-x
README.md	2.24 KB	-rwxr-xr-x
assert.d.ts	4.97 KB	-rwxr-xr-x
async_hooks.d.ts	10.58 KB	-rwxr-xr-x
buffer.d.ts	706 B	-rwxr-xr-x
child_process.d.ts	24.97 KB	-rwxr-xr-x
cluster.d.ts	15.78 KB	-rwxr-xr-x
console.d.ts	51 B	-rwxr-xr-x
constants.d.ts	22.43 KB	-rwxr-xr-x
crypto.d.ts	44.69 KB	-rwxr-xr-x
dgram.d.ts	5.82 KB	-rwxr-xr-x
dns.d.ts	15.86 KB	-rwxr-xr-x
domain.d.ts	547 B	-rwxr-xr-x
events.d.ts	1.83 KB	-rwxr-xr-x
fs.d.ts	135.98 KB	-rwxr-xr-x
globals.d.ts	49.15 KB	-rwxr-xr-x
globals.global.d.ts	55 B	-rwxr-xr-x
http.d.ts	23.57 KB	-rwxr-xr-x
http2.d.ts	55.76 KB	-rwxr-xr-x
https.d.ts	12.14 KB	-rwxr-xr-x
index.d.ts	4.29 KB	-rwxr-xr-x
inspector.d.ts	120.65 KB	-rwxr-xr-x
module.d.ts	56 B	-rwxr-xr-x
net.d.ts	13.21 KB	-rwxr-xr-x
os.d.ts	7.78 KB	-rwxr-xr-x
package.json	5.74 KB	-rwxr-xr-x
path.d.ts	5.85 KB	-rwxr-xr-x
perf_hooks.d.ts	9.71 KB	-rwxr-xr-x
process.d.ts	517 B	-rwxr-xr-x
punycode.d.ts	3.39 KB	-rwxr-xr-x
querystring.d.ts	1.07 KB	-rwxr-xr-x
readline.d.ts	6.98 KB	-rwxr-xr-x
repl.d.ts	17.67 KB	-rwxr-xr-x
stream.d.ts	17.88 KB	-rwxr-xr-x
string_decoder.d.ts	185 B	-rwxr-xr-x
timers.d.ts	826 B	-rwxr-xr-x
tls.d.ts	34.33 KB	-rwxr-xr-x
trace_events.d.ts	2.06 KB	-rwxr-xr-x
tty.d.ts	2.38 KB	-rwxr-xr-x
url.d.ts	4.34 KB	-rwxr-xr-x
util.d.ts	12.06 KB	-rwxr-xr-x
v8.d.ts	6.76 KB	-rwxr-xr-x
vm.d.ts	4.79 KB	-rwxr-xr-x
wasi.d.ts	2.2 KB	-rwxr-xr-x
worker_threads.d.ts	9.49 KB	-rwxr-xr-x
zlib.d.ts	13.92 KB	-rwxr-xr-x

Code Editor : worker_threads.d.ts

declare module 'worker_threads' {
    import { Context } from 'vm';
    import EventEmitter = require('events');
    import { Readable, Writable } from 'stream';
    import { promises } from 'fs';

const isMainThread: boolean;
    const parentPort: null | MessagePort;
    const resourceLimits: ResourceLimits;
    const SHARE_ENV: unique symbol;
    const threadId: number;
    const workerData: any;

class MessageChannel {
        readonly port1: MessagePort;
        readonly port2: MessagePort;
    }

type TransferListItem = ArrayBuffer | MessagePort | promises.FileHandle;

class MessagePort extends EventEmitter {
        close(): void;
        postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
        ref(): void;
        unref(): void;
        start(): void;

addListener(event: "close", listener: () => void): this;
        addListener(event: "message", listener: (value: any) => void): this;
        addListener(event: string | symbol, listener: (...args: any[]) => void): this;

emit(event: "close"): boolean;
        emit(event: "message", value: any): boolean;
        emit(event: string | symbol, ...args: any[]): boolean;

on(event: "close", listener: () => void): this;
        on(event: "message", listener: (value: any) => void): this;
        on(event: string | symbol, listener: (...args: any[]) => void): this;

once(event: "close", listener: () => void): this;
        once(event: "message", listener: (value: any) => void): this;
        once(event: string | symbol, listener: (...args: any[]) => void): this;

prependListener(event: "close", listener: () => void): this;
        prependListener(event: "message", listener: (value: any) => void): this;
        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;

prependOnceListener(event: "close", listener: () => void): this;
        prependOnceListener(event: "message", listener: (value: any) => void): this;
        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;

removeListener(event: "close", listener: () => void): this;
        removeListener(event: "message", listener: (value: any) => void): this;
        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;

off(event: "close", listener: () => void): this;
        off(event: "message", listener: (value: any) => void): this;
        off(event: string | symbol, listener: (...args: any[]) => void): this;
    }

interface WorkerOptions {
        eval?: boolean | undefined;
        env?: NodeJS.ProcessEnv | typeof SHARE_ENV | undefined;
        workerData?: any;
        stdin?: boolean | undefined;
        stdout?: boolean | undefined;
        stderr?: boolean | undefined;
        execArgv?: string[] | undefined;
        resourceLimits?: ResourceLimits | undefined;
        /**
         * Additional data to send in the first worker message.
         */
        transferList?: TransferListItem[] | undefined;
        trackUnmanagedFds?: boolean | undefined;
    }

interface ResourceLimits {
        /**
         * The maximum size of a heap space for recently created objects.
         */
        maxYoungGenerationSizeMb?: number | undefined;
        /**
         * The maximum size of the main heap in MB.
         */
        maxOldGenerationSizeMb?: number | undefined;
        /**
         * The size of a pre-allocated memory range used for generated code.
         */
        codeRangeSizeMb?: number | undefined;
        /**
         * The default maximum stack size for the thread. Small values may lead to unusable Worker instances.
         * @default 4
         */
        stackSizeMb?: number | undefined;
    }

class Worker extends EventEmitter {
        readonly stdin: Writable | null;
        readonly stdout: Readable;
        readonly stderr: Readable;
        readonly threadId: number;
        readonly resourceLimits?: ResourceLimits | undefined;

constructor(filename: string, options?: WorkerOptions);

postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
        ref(): void;
        unref(): void;
        /**
         * Stop all JavaScript execution in the worker thread as soon as possible.
         * Returns a Promise for the exit code that is fulfilled when the `exit` event is emitted.
         */
        terminate(): Promise<number>;

addListener(event: "error", listener: (err: Error) => void): this;
        addListener(event: "exit", listener: (exitCode: number) => void): this;
        addListener(event: "message", listener: (value: any) => void): this;
        addListener(event: "messageerror", listener: (error: Error) => void): this;
        addListener(event: "online", listener: () => void): this;
        addListener(event: string | symbol, listener: (...args: any[]) => void): this;

emit(event: "error", err: Error): boolean;
        emit(event: "exit", exitCode: number): boolean;
        emit(event: "message", value: any): boolean;
        emit(event: "messageerror", error: Error): boolean;
        emit(event: "online"): boolean;
        emit(event: string | symbol, ...args: any[]): boolean;

on(event: "error", listener: (err: Error) => void): this;
        on(event: "exit", listener: (exitCode: number) => void): this;
        on(event: "message", listener: (value: any) => void): this;
        on(event: "messageerror", listener: (error: Error) => void): this;
        on(event: "online", listener: () => void): this;
        on(event: string | symbol, listener: (...args: any[]) => void): this;

once(event: "error", listener: (err: Error) => void): this;
        once(event: "exit", listener: (exitCode: number) => void): this;
        once(event: "message", listener: (value: any) => void): this;
        once(event: "messageerror", listener: (error: Error) => void): this;
        once(event: "online", listener: () => void): this;
        once(event: string | symbol, listener: (...args: any[]) => void): this;

prependListener(event: "error", listener: (err: Error) => void): this;
        prependListener(event: "exit", listener: (exitCode: number) => void): this;
        prependListener(event: "message", listener: (value: any) => void): this;
        prependListener(event: "messageerror", listener: (error: Error) => void): this;
        prependListener(event: "online", listener: () => void): this;
        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;

prependOnceListener(event: "error", listener: (err: Error) => void): this;
        prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
        prependOnceListener(event: "message", listener: (value: any) => void): this;
        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
        prependOnceListener(event: "online", listener: () => void): this;
        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;

removeListener(event: "error", listener: (err: Error) => void): this;
        removeListener(event: "exit", listener: (exitCode: number) => void): this;
        removeListener(event: "message", listener: (value: any) => void): this;
        removeListener(event: "messageerror", listener: (error: Error) => void): this;
        removeListener(event: "online", listener: () => void): this;
        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;

off(event: "error", listener: (err: Error) => void): this;
        off(event: "exit", listener: (exitCode: number) => void): this;
        off(event: "message", listener: (value: any) => void): this;
        off(event: "messageerror", listener: (error: Error) => void): this;
        off(event: "online", listener: () => void): this;
        off(event: string | symbol, listener: (...args: any[]) => void): this;
    }

/**
     * Mark an object as not transferable.
     * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.
     *
     * In particular, this makes sense for objects that can be cloned, rather than transferred,
     * and which are used by other objects on the sending side. For example, Node.js marks
     * the `ArrayBuffer`s it uses for its Buffer pool with this.
     *
     * This operation cannot be undone.
     */
    function markAsUntransferable(object: object): void;

/**
     * Transfer a `MessagePort` to a different `vm` Context. The original `port`
     * object will be rendered unusable, and the returned `MessagePort` instance will
     * take its place.
     *
     * The returned `MessagePort` will be an object in the target context, and will
     * inherit from its global `Object` class. Objects passed to the
     * `port.onmessage()` listener will also be created in the target context
     * and inherit from its global `Object` class.
     *
     * However, the created `MessagePort` will no longer inherit from
     * `EventEmitter`, and only `port.onmessage()` can be used to receive
     * events using it.
     */
    function moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;

/**
     * Receive a single message from a given `MessagePort`. If no message is available,
     * `undefined` is returned, otherwise an object with a single `message` property
     * that contains the message payload, corresponding to the oldest message in the
     * `MessagePort`’s queue.
     */
    function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
}

${this.title}

Code Editor : worker_threads.d.ts