import * as DenoUnstable from "../_deno_unstable.ts";import { warnNotImplemented } from "./_utils.ts";import { EventEmitter } from "./events.ts";import { validateString } from "./internal/validators.mjs";import { ERR_INVALID_ARG_TYPE, ERR_UNKNOWN_SIGNAL } from "./internal/errors.ts";import { getOptionValue } from "./internal/options.ts";import { assert } from "../_util/assert.ts";import { fromFileUrl } from "../path/mod.ts";import { arch, chdir, cwd, env, nextTick as _nextTick, pid, platform, version, versions,} from "./_process/process.ts";import { _exiting } from "./_process/exiting.ts";export { _nextTick as nextTick, arch, chdir, cwd, env, pid, platform, version, versions,};import { stderr as stderr_, stdin as stdin_, stdout as stdout_,} from "./_process/streams.mjs";const stderr = stderr_ as any;const stdin = stdin_ as any;const stdout = stdout_ as any;export { stderr, stdin, stdout };import { getBinding } from "./internal_binding/mod.ts";import type { BindingName } from "./internal_binding/mod.ts";import { buildAllowedFlags } from "./internal/process/per_thread.mjs";
const notImplementedEvents = [ "beforeExit", "disconnect", "message", "multipleResolves", "rejectionHandled", "uncaughtException", "uncaughtExceptionMonitor", "unhandledRejection", "worker",];
const argv = ["", "", ...Deno.args];Object.defineProperty(argv, "0", { get: Deno.execPath });Object.defineProperty(argv, "1", { get: () => fromFileUrl(Deno.mainModule) });
export const exit = (code?: number | string) => { if (code || code === 0) { if (typeof code === "string") { const parsedCode = parseInt(code); process.exitCode = isNaN(parsedCode) ? undefined : parsedCode; } else { process.exitCode = code; } }
if (!process._exiting) { process._exiting = true; process.emit("exit", process.exitCode || 0); }
Deno.exit(process.exitCode || 0);};
function addReadOnlyProcessAlias( name: string, option: string, enumerable = true,) { const value = getOptionValue(option);
if (value) { Object.defineProperty(process, name, { writable: false, configurable: true, enumerable, value, }); }}
function createWarningObject( warning: string, type: string, code?: string, ctor?: Function, detail?: string,): Error { assert(typeof warning === "string");
const warningErr: any = new Error(warning); warningErr.name = String(type || "Warning");
if (code !== undefined) { warningErr.code = code; } if (detail !== undefined) { warningErr.detail = detail; }
Error.captureStackTrace(warningErr, ctor || process.emitWarning);
return warningErr;}
function doEmitWarning(warning: Error) { process.emit("warning", warning);}
export function emitWarning( warning: string | Error, type: | { type: string; detail: string; code: string; ctor: Function } | string | null, code?: string, ctor?: Function,) { let detail;
if (type !== null && typeof type === "object" && !Array.isArray(type)) { ctor = type.ctor; code = type.code;
if (typeof type.detail === "string") { detail = type.detail; }
type = type.type || "Warning"; } else if (typeof type === "function") { ctor = type; code = undefined; type = "Warning"; }
if (type !== undefined) { validateString(type, "type"); }
if (typeof code === "function") { ctor = code; code = undefined; } else if (code !== undefined) { validateString(code, "code"); }
if (typeof warning === "string") { warning = createWarningObject(warning, type as string, code, ctor, detail); } else if (!(warning instanceof Error)) { throw new ERR_INVALID_ARG_TYPE("warning", ["Error", "string"], warning); }
if (warning.name === "DeprecationWarning") { if ((process as any).noDeprecation) { return; }
if ((process as any).throwDeprecation) { return process.nextTick(() => { throw warning; }); } }
process.nextTick(doEmitWarning, warning);}
function hrtime(time?: [number, number]): [number, number] { const milli = performance.now(); const sec = Math.floor(milli / 1000); const nano = Math.floor(milli * 1_000_000 - sec * 1_000_000_000); if (!time) { return [sec, nano]; } const [prevSec, prevNano] = time; return [sec - prevSec, nano - prevNano];}
hrtime.bigint = function (): BigInt { const [sec, nano] = hrtime(); return BigInt(sec) * 1_000_000_000n + BigInt(nano);};
function memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; external: number; arrayBuffers: number;} { return { ...Deno.memoryUsage(), arrayBuffers: 0, };}
memoryUsage.rss = function (): number { return memoryUsage().rss;};
export function kill(pid: number, sig: Deno.Signal | number = "SIGTERM") { if (pid != (pid | 0)) { throw new ERR_INVALID_ARG_TYPE("pid", "number", pid); }
if (typeof sig === "string") { try { Deno.kill(pid, sig); } catch (e) { if (e instanceof TypeError) { throw new ERR_UNKNOWN_SIGNAL(sig); } throw e; } } else { throw new ERR_UNKNOWN_SIGNAL(sig.toString()); }
return true;}
class Process extends EventEmitter { constructor() { super();
globalThis.addEventListener("unload", () => { if (!process._exiting) { process._exiting = true; super.emit("exit", process.exitCode || 0); } }); }
arch = arch;
argv = argv;
chdir = chdir;
config = { target_defaults: {}, variables: {}, };
cwd = cwd;
env = env;
execArgv: string[] = [];
exit = exit;
_exiting = _exiting;
exitCode: undefined | number = undefined;
mainModule: any = undefined;
nextTick = _nextTick;
override on(event: "exit", listener: (code: number) => void): this; override on( event: typeof notImplementedEvents[number], listener: Function, ): this; override on(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.on("${event}")`); super.on(event, listener); } else if (event.startsWith("SIG")) { if (event === "SIGBREAK" && Deno.build.os !== "windows") { } else { DenoUnstable.addSignalListener(event as Deno.Signal, listener); } } else { super.on(event, listener); }
return this; }
override off(event: "exit", listener: (code: number) => void): this; override off( event: typeof notImplementedEvents[number], listener: Function, ): this; override off(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.off("${event}")`); super.off(event, listener); } else if (event.startsWith("SIG")) { if (event === "SIGBREAK" && Deno.build.os !== "windows") { } else { DenoUnstable.removeSignalListener(event as Deno.Signal, listener); } } else { super.off(event, listener); }
return this; }
override emit(event: string, ...args: any[]): boolean { if (event.startsWith("SIG")) { if (event === "SIGBREAK" && Deno.build.os !== "windows") { } else { Deno.kill(Deno.pid, event as Deno.Signal); } } else { return super.emit(event, ...args); }
return true; }
override prependListener( event: "exit", listener: (code: number) => void, ): this; override prependListener( event: typeof notImplementedEvents[number], listener: Function, ): this; override prependListener( event: string, listener: (...args: any[]) => void, ): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.prependListener("${event}")`); super.prependListener(event, listener); } else if (event.startsWith("SIG")) { if (event === "SIGBREAK" && Deno.build.os !== "windows") { } else { DenoUnstable.addSignalListener(event as Deno.Signal, listener); } } else { super.prependListener(event, listener); }
return this; }
pid = pid;
platform = platform;
override addListener(event: "exit", listener: (code: number) => void): this; override addListener( event: typeof notImplementedEvents[number], listener: Function, ): this; override addListener( event: string, listener: (...args: any[]) => void, ): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.addListener("${event}")`); }
return this.on(event, listener); }
override removeListener( event: "exit", listener: (code: number) => void, ): this; override removeListener( event: typeof notImplementedEvents[number], listener: Function, ): this; override removeListener( event: string, listener: (...args: any[]) => void, ): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.removeListener("${event}")`); }
return this.off(event, listener); }
hrtime = hrtime;
kill = kill;
memoryUsage = memoryUsage;
stderr = stderr;
stdin = stdin;
stdout = stdout;
version = version;
versions = versions;
emitWarning = emitWarning;
binding(name: BindingName) { return getBinding(name); }
umask() { return 0o22; }
getuid(): number { return NaN; }
getgid(): number { return NaN; }
_eval: string | undefined = undefined;
get execPath() { return argv[0]; }
#startTime = Date.now(); uptime() { return (Date.now() - this.#startTime) / 1000; }
#allowedFlags = buildAllowedFlags(); get allowedNodeEnvironmentFlags() { return this.#allowedFlags; }
features = { inspector: false };}
const process = new Process();
Object.defineProperty(process, Symbol.toStringTag, { enumerable: false, writable: true, configurable: false, value: "process",});
addReadOnlyProcessAlias("noDeprecation", "--no-deprecation");addReadOnlyProcessAlias("throwDeprecation", "--throw-deprecation");
export const removeListener = process.removeListener;export const removeAllListeners = process.removeAllListeners;
export default process;
export { process };