import { notImplemented } from "./_utils.ts";import { EventEmitter } from "./events.ts";import { fromFileUrl } from "../path/mod.ts";import { isWindows } from "../_util/os.ts";import { Readable, Writable } from "./stream.ts";import { Buffer } from "./buffer.ts";
const notImplementedEvents = [ "beforeExit", "disconnect", "message", "multipleResolves", "rejectionHandled", "SIGBREAK", "SIGBUS", "SIGFPE", "SIGHUP", "SIGILL", "SIGINT", "SIGSEGV", "SIGTERM", "SIGWINCH", "uncaughtException", "uncaughtExceptionMonitor", "unhandledRejection",];
export const arch = Deno.build.arch;
const argv = ["", "", ...Deno.args];Object.defineProperty(argv, "0", { get: Deno.execPath });Object.defineProperty(argv, "1", { get: () => fromFileUrl(Deno.mainModule) });
export const chdir = Deno.chdir;
export const cwd = Deno.cwd;
export const env: Record<string, string> = new Proxy({}, { get(_target, prop) { return Deno.env.get(String(prop)); }, ownKeys: () => Reflect.ownKeys(Deno.env.toObject()), getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true }), set(_target, prop, value) { Deno.env.set(String(prop), String(value)); return value; },});
export const exit = Deno.exit;
export function nextTick(this: unknown, cb: () => void): void;export function nextTick<T extends Array<unknown>>( this: unknown, cb: (...args: T) => void, ...args: T): void;export function nextTick<T extends Array<unknown>>( this: unknown, cb: (...args: T) => void, ...args: T) { if (args) { queueMicrotask(() => cb.call(this, ...args)); } else { queueMicrotask(cb); }}
export const pid = Deno.pid;
export const platform = isWindows ? "win32" : Deno.build.os;
export const version = `v${Deno.version.deno}`;
export const versions = { node: Deno.version.deno, ...Deno.version,};
interface _Readable extends Readable { get isTTY(): true | undefined; destroySoon: Readable["destroy"]; fd: number; _isStdio: undefined;}
interface _Writable extends Writable { get isTTY(): true | undefined; get columns(): number | undefined; get rows(): number | undefined; getWindowSize(): [columns: number, rows: number] | undefined; destroySoon: Writable["destroy"]; fd: number; _isStdio: true;}
function createWritableStdioStream(writer: typeof Deno.stdout): _Writable { const stream = new Writable({ write(buf: Uint8Array, enc: string, cb) { writer.writeSync(buf instanceof Uint8Array ? buf : Buffer.from(buf, enc)); cb(); }, destroy(err, cb) { cb(err); this._undestroy(); if (!this._writableState.emitClose) { queueMicrotask(() => this.emit("close")); } }, }) as _Writable; stream.fd = writer.rid; stream.destroySoon = stream.destroy; stream._isStdio = true; stream.once("close", () => writer.close()); Object.defineProperties(stream, { columns: { enumerable: true, configurable: true, get: () => Deno.isatty(writer.rid) ? Deno.consoleSize(writer.rid).columns : undefined, }, rows: { enumerable: true, configurable: true, get: () => Deno.isatty(writer.rid) ? Deno.consoleSize(writer.rid).rows : undefined, }, isTTY: { enumerable: true, configurable: true, get: () => Deno.isatty(writer.rid), }, getWindowSize: { enumerable: true, configurable: true, value: () => Deno.isatty(writer.rid) ? Object.values(Deno.consoleSize(writer.rid)) : undefined, }, }); return stream;}
export const stderr = createWritableStdioStream(Deno.stderr);
export const stdin = new Readable({ read(this: Readable, size: number) { const p = Buffer.alloc(size || 16 * 1024); const length = Deno.stdin.readSync(p); this.push(length === null ? null : p.slice(0, length)); },}) as _Readable;stdin.on("close", () => Deno.stdin.close());stdin.fd = Deno.stdin.rid;Object.defineProperty(stdin, "isTTY", { enumerable: true, configurable: true, get() { return Deno.isatty(Deno.stdin.rid); },});
export const stdout = createWritableStdioStream(Deno.stdout);
class Process extends EventEmitter { constructor() { super();
window.addEventListener("unload", () => { super.emit("exit", 0); }); }
arch = arch;
argv = argv;
chdir = chdir;
cwd = cwd;
exit = exit;
env = env;
nextTick = nextTick;
on(event: typeof notImplementedEvents[number], listener: Function): never; on(event: "exit", listener: (code: number) => void): this; on(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { notImplemented(); }
super.on(event, listener);
return this; }
pid = pid;
platform = platform;
removeAllListeners(_event: string): never { notImplemented(); }
removeListener( event: typeof notImplementedEvents[number], listener: Function, ): never; removeListener(event: "exit", listener: (code: number) => void): this; removeListener(event: string, listener: (...args: any[]) => void): this { if (notImplementedEvents.includes(event)) { notImplemented(); }
super.removeListener("exit", listener);
return this; }
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]; }
stderr = stderr;
stdin = stdin;
stdout = stdout;
version = version;
versions = versions;}
const process = new Process();
Object.defineProperty(process, Symbol.toStringTag, { enumerable: false, writable: true, configurable: false, value: "process",});
export const removeListener = process.removeListener;export const removeAllListeners = process.removeAllListeners;
export default process;
export { process };