123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.import { warnNotImplemented } from "./_utils.ts";import { EventEmitter } from "./events.ts";import { validateString } from "./_validators.ts";import { ERR_INVALID_ARG_TYPE } from "./_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";export {  _nextTick as nextTick,  arch,  chdir,  cwd,  env,  pid,  platform,  version,  versions,};import { stderr, stdin, stdout } from "./_process/streams.ts";export { stderr, stdin, stdout };
const notImplementedEvents = [  "beforeExit",  "disconnect",  "message",  "multipleResolves",  "rejectionHandled",  "uncaughtException",  "uncaughtExceptionMonitor",  "unhandledRejection",];
// The first 2 items are placeholders.// They will be overwritten by the below Object.defineProperty calls.const argv = ["", "", ...Deno.args];// Overwrites the 1st item with getter.Object.defineProperty(argv, "0", { get: Deno.execPath });// Overwrites the 2st item with getter.Object.defineProperty(argv, "1", { get: () => fromFileUrl(Deno.mainModule) });
/** https://nodejs.org/api/process.html#process_process_exit_code */export const exit = (code?: number) => {  if (code || code === 0) {    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,  // deno-lint-ignore ban-types  ctor?: Function,  detail?: string,): Error {  assert(typeof warning === "string");
  // deno-lint-ignore no-explicit-any  const warningErr: any = new Error(warning);  warningErr.name = String(type || "Warning");
  if (code !== undefined) {    warningErr.code = code;  }  if (detail !== undefined) {    warningErr.detail = detail;  }
  // @ts-ignore this function is not available in lib.dom.d.ts  Error.captureStackTrace(warningErr, ctor || process.emitWarning);
  return warningErr;}
function doEmitWarning(warning: Error) {  process.emit("warning", warning);}
/** https://nodejs.org/api/process.html#process_process_emitwarning_warning_options */export function emitWarning(  warning: string | Error,  type:    // deno-lint-ignore ban-types    | { type: string; detail: string; code: string; ctor: Function }    | string    | null,  code?: string,  // deno-lint-ignore ban-types  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") {    // deno-lint-ignore no-explicit-any    if ((process as any).noDeprecation) {      return;    }
    // deno-lint-ignore no-explicit-any    if ((process as any).throwDeprecation) {      // Delay throwing the error to guarantee that all former warnings were      // properly logged.      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();
    //This causes the exit event to be binded to the unload event    globalThis.addEventListener("unload", () => {      //TODO(Soremwar)      //Get the exit code from the unload event      super.emit("exit", 0);    });  }
  /** https://nodejs.org/api/process.html#process_process_arch */  arch = arch;
  /**   * https://nodejs.org/api/process.html#process_process_argv   * Read permissions are required in order to get the executable route   */  argv = argv;
  /** https://nodejs.org/api/process.html#process_process_chdir_directory */  chdir = chdir;
  /** https://nodejs.org/api/process.html#processconfig */  config = {    target_defaults: {},    variables: {},  };
  /** https://nodejs.org/api/process.html#process_process_cwd */  cwd = cwd;
  /**   * https://nodejs.org/api/process.html#process_process_env   * Requires env permissions   */  env = env;
  /** https://nodejs.org/api/process.html#process_process_execargv */  execArgv = [];
  /** https://nodejs.org/api/process.html#process_process_exit_code */  exit = exit;
  _exiting = false;
  /** https://nodejs.org/api/process.html#processexitcode_1 */  exitCode: undefined | number = undefined;
  // Typed as any to avoid importing "module" module for types  // deno-lint-ignore no-explicit-any  mainModule: any = undefined;
  /** https://nodejs.org/api/process.html#process_process_nexttick_callback_args */  nextTick = _nextTick;
  /** https://nodejs.org/api/process.html#process_process_events */  on(event: "exit", listener: (code: number) => void): this;  // deno-lint-ignore no-explicit-any  on(event: string, listener: (...args: any[]) => void): this;  // deno-lint-ignore ban-types  on(event: typeof notImplementedEvents[number], listener: Function): this;  // deno-lint-ignore no-explicit-any  on(event: string, listener: (...args: any[]) => void): this {    if (notImplementedEvents.includes(event)) {      warnNotImplemented(`process.on("${event}")`);    } else if (event.startsWith("SIG")) {      Deno.addSignalListener(event as Deno.Signal, listener);    } else {      super.on(event, listener);    }
    return this;  }
  off(event: "exit", listener: (code: number) => void): this;  // deno-lint-ignore no-explicit-any  off(event: string, listener: (...args: any[]) => void): this;  // deno-lint-ignore ban-types  off(event: typeof notImplementedEvents[number], listener: Function): this;  // deno-lint-ignore no-explicit-any  off(event: string, listener: (...args: any[]) => void): this {    if (notImplementedEvents.includes(event)) {      warnNotImplemented(`process.off("${event}")`);    } else if (event.startsWith("SIG")) {      Deno.removeSignalListener(event as Deno.Signal, listener);    } else {      super.off(event, listener);    }
    return this;  }
  /** https://nodejs.org/api/process.html#process_process_pid */  pid = pid;
  /** https://nodejs.org/api/process.html#process_process_platform */  platform = platform;
  // @ts-ignore `deno_std`'s types are scricter than types from DefinitelyTyped for Node.js thus causing problems  removeAllListeners(eventName?: string | symbol): this {    // @ts-ignore `deno_std`'s types are scricter than types from DefinitelyTyped for Node.js thus causing problems    return super.removeAllListeners(eventName);  }
  // @ts-ignore `deno_std`'s types are scricter than types from DefinitelyTyped for Node.js thus causing problems  removeListener(    event: typeof notImplementedEvents[number],    //deno-lint-ignore ban-types    listener: Function,  ): this;  // @ts-ignore `deno_std`'s types are scricter than types from DefinitelyTyped for Node.js thus causing problems  removeListener(event: "exit", listener: (code: number) => void): this;  // @ts-ignore `deno_std`'s types are scricter than types from DefinitelyTyped for Node.js thus causing problems  //deno-lint-ignore no-explicit-any  removeListener(event: string, listener: (...args: any[]) => void): this {    if (notImplementedEvents.includes(event)) {      warnNotImplemented(`process.removeListener("${event}")`);      return this;    }
    super.removeListener("exit", listener);
    return this;  }
  /**   * Returns the current high-resolution real time in a [seconds, nanoseconds]   * tuple.   *   * Note: You need to give --allow-hrtime permission to Deno to actually get   * nanoseconds precision values. If you don't give 'hrtime' permission, the returned   * values only have milliseconds precision.   *   * `time` is an optional parameter that must be the result of a previous process.hrtime() call to diff with the current time.   *   * These times are relative to an arbitrary time in the past, and not related to the time of day and therefore not subject to clock drift. The primary use is for measuring performance between intervals.   * https://nodejs.org/api/process.html#process_process_hrtime_time   */  hrtime = hrtime;
  memoryUsage = memoryUsage;
  /** https://nodejs.org/api/process.html#process_process_stderr */  stderr = stderr;
  /** https://nodejs.org/api/process.html#process_process_stdin */  stdin = stdin;
  /** https://nodejs.org/api/process.html#process_process_stdout */  stdout = stdout;
  /** https://nodejs.org/api/process.html#process_process_version */  version = version;
  /** https://nodejs.org/api/process.html#process_process_versions */  versions = versions;
  /** https://nodejs.org/api/process.html#process_process_emitwarning_warning_options */  emitWarning = emitWarning;}
/** https://nodejs.org/api/process.html#process_process */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;
//TODO(Soremwar)//Remove on 1.0//Kept for backwards compatibility with stdexport { process };