import * as DenoUnstable from "../_deno_unstable.ts";import { warnNotImplemented } from "./_utils.ts";import { EventEmitter } from "./events.ts";import { validateString } from "./internal/validators.js";import { ERR_INVALID_ARG_TYPE } from "./internal/errors.ts";import { getOptionValue } from "./_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.js";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";
const notImplementedEvents = [ "beforeExit", "disconnect", "message", "multipleResolves", "rejectionHandled", "uncaughtException", "uncaughtExceptionMonitor", "unhandledRejection",];
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;};
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;
on(event: "exit", listener: (code: number) => void): this; on(event: string, listener: (...args: any[]) => void): this; on(event: typeof notImplementedEvents[number], listener: Function): this; on(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.on("${event}")`); } else if (event.startsWith("SIG")) { DenoUnstable.addSignalListener(event as Deno.Signal, listener); } else { super.on(event, listener); }
return this; }
off(event: "exit", listener: (code: number) => void): this; off(event: string, listener: (...args: any[]) => void): this; off(event: typeof notImplementedEvents[number], listener: Function): this; off(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.off("${event}")`); } else if (event.startsWith("SIG")) { DenoUnstable.removeSignalListener(event as Deno.Signal, listener); } else { super.off(event, listener); }
return this; }
pid = pid;
platform = platform;
removeAllListeners(eventName?: string | symbol): this { return super.removeAllListeners(eventName); }
removeListener( event: typeof notImplementedEvents[number], listener: Function, ): this; removeListener(event: "exit", listener: (code: number) => void): this; removeListener(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { warnNotImplemented(`process.removeListener("${event}")`); return this; }
super.removeListener("exit", listener);
return this; }
hrtime = hrtime;
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; }}
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 };