yavascript 0.0.8 → 0.0.10

package/yavascript.d.ts

@@ -3,6 +3,44 @@
 // YavaScript APIs
 // ---------------
 // ===============
+/**
+ * Prints help and usage text about the provided value, if any is available.
+ */
+declare var help: {
+  /**
+   * Prints help and usage text about the provided value, if any is available.
+   */
+  (value?: any): void;
+
+  /**
+   * Set the help text for the provided value to the provided string.
+   *
+   * If the value is later passed into the `help` function, the provided text
+   * will be printed.
+   */
+  setHelpText: {
+    /**
+     * Set the help text for the provided value to the provided string.
+     *
+     * If the value is later passed into the `help` function, the provided text
+     * will be printed.
+     */
+    (value: object, text: string): void;
+
+    /**
+     * Lazily sets the help text for the provided value using the provided
+     * string-returning function.
+     *
+     * The first time help text is requested for the value, the string-returning
+     * function will be called, and its result will be registered as the help
+     * text for the value. Afterwards, the function will not be called again;
+     * instead, it will re-use the text returned from the first time the
+     * function was called.
+     */
+    lazy(value: object, getText: () => string): void;
+  };
+};
+
 /** Info about the currently-running yavascript binary */
 declare const yavascript: {
   /**
@@ -90,72 +128,30 @@ declare const env: { [key: string]: string | undefined };
  * Anything that appears after `--` is considered a positional argument instead
  * of a flag. `--` is not present in the returned positional arguments Array.
  *
- * Single-character flags must have a single leading dash, and multi-character
- * flags must have two leading dashes.
- *
- * Flags with equals signs in them (eg. `--something=42`) are not supported.
- * Write `--something 42` instead.
- *
- * Flags where you specify them multiple times, like `-vvv`, are not supported.
- * Write something like `-v 3` instead.
- *
- * @param hints - An object whose keys are flag names (in camelCase) and whose values indicate what type to treat that flag as. Valid property values are `String`, `Boolean`, `Number`, and `parseScriptArgs.Path`. `parseScriptArgs.Path` will resolve relative paths into absolute paths for you. If no hints object is specified, `parseScriptArgs` will do its best to guess, based on the command-line args.
+ * @param hints - An object whose keys are flag names (in camelCase) and whose values indicate what type to treat that flag as. Valid property values are `String`, `Boolean`, `Number`, and `Path`. `Path` will resolve relative paths into absolute paths for you. If no hints object is specified, `parseScriptArgs` will do its best to guess, based on the command-line args.
  * @param argv - An array containing the command line flags you want to parse. If unspecified, `scriptArgs.slice(2)` will be used (we slice 2 in order to skip the yavascript binary and script name). If you pass in an array here, it should only contain command-line flags, not the binary being called.
  *
- * @returns An object with two properties: `flags` and `args`. `flags` is an object whose keys are camelCase flag names and whose values are strings, booleans, or numbers corresponding to the input command-line args. `args` is an Array of positional arguments, as found on the command-line.
+ * @returns An object with three properties: `flags`, `args`, and `metadata`. `flags` is an object whose keys are camelCase flag names and whose values are strings, booleans, numbers, or `Path`s corresponding to the input command-line args. `args` is an Array of positional arguments, as found on the command-line. `metadata` contains information about what name and type the flags got mapped to.
  */
-declare const parseScriptArgs: {
-  /**
-   * Parse command line --flags into an object of flags and an array of
-   * positional arguments. This function is opinionated; if it doesn't meet your
-   * needs, you can parse the `scriptArgs` global manually.
-   *
-   * Flags `--like-this`, `--like_this`, or `--LIKE_THIS` get converted into
-   * property names `likeThis` on the returned flags object.
-   *
-   * Flags like this: `-v` get converted into into property names like this: `v`
-   * on the returned flags object.
-   *
-   * Anything that appears after `--` is considered a positional argument instead
-   * of a flag. `--` is not present in the returned positional arguments Array.
-   *
-   * Single-character flags must have a single leading dash, and multi-character
-   * flags must have two leading dashes.
-   *
-   * Flags with equals signs in them (eg. `--something=42`) are not supported.
-   * Write `--something 42` instead.
-   *
-   * Flags where you specify them multiple times, like `-vvv`, are not supported.
-   * Write something like `-v 3` instead.
-   *
-   * @param hints - An object whose keys are flag names (in camelCase) and whose values indicate what type to treat that flag as. Valid property values are `String`, `Boolean`, `Number`, and `parseScriptArgs.Path`. `parseScriptArgs.Path` will resolve relative paths into absolute paths for you. If no hints object is specified, `parseScriptArgs` will do its best to guess, based on the command-line args.
-   * @param args - An array containing the command line flags you want to parse. If unspecified, `scriptArgs.slice(2)` will be used (we slice 2 in order to skip the yavascript binary and script name). If you pass in an array here, it should only contain command-line flags, not the binary being called.
-   *
-   * @returns An object with two properties: `flags` and `args`. `flags` is an object whose keys are camelCase flag names and whose values are strings, booleans, or numbers corresponding to the input command-line args. `args` is an Array of positional arguments, as found on the command-line.
-   */
-  (
-    hints?: {
-      [key: string]:
-        | typeof String
-        | typeof Boolean
-        | typeof Number
-        | typeof parseScriptArgs["Path"];
-    },
-    args?: Array<string>
-  ): {
-    flags: { [key: string]: any };
-    args: Array<string>;
+declare function parseScriptArgs(
+  hints?: {
+    [key: string]: typeof String | typeof Boolean | typeof Number | typeof Path;
+  },
+  args?: Array<string>
+): {
+  flags: { [key: string]: any };
+  args: Array<string>;
+  metadata: {
+    keys: {
+      [key: string]: string | undefined;
+    };
+    hints: {
+      [key: string]: string | undefined;
+    };
+    guesses: {
+      [key: string]: string | undefined;
+    };
   };
-
-  /**
-   * A hint value for {@link parseScriptArgs}. Behaves similar to the hint value
-   * `String`, except that it also resolves relative paths into absolute paths,
-   * using the following rules:
-   *
-   * - paths `./like/this` or `../like/this` get resolved relative to `pwd()`.
-   * - paths `like/this` or `this` get resolved relative to `pwd()` as if they had a leading `./`.
-   */
-  readonly Path: unique symbol;
 };
 
 /**
@@ -165,22 +161,22 @@ declare const readFile: {
   /**
    * Read the contents of a file from disk, as a UTF-8 string.
    */
-  (path: string): string;
+  (path: string | Path): string;
 
   /**
    * Read the contents of a file from disk, as a UTF-8 string.
    */
-  (path: string, options: {}): string;
+  (path: string | Path, options: {}): string;
 
   /**
    * Read the contents of a file from disk, as a UTF-8 string.
    */
-  (path: string, options: { binary: false }): string;
+  (path: string | Path, options: { binary: false }): string;
 
   /**
    * Read the contents of a file from disk, as an ArrayBuffer.
    */
-  (path: string, options: { binary: true }): ArrayBuffer;
+  (path: string | Path, options: { binary: true }): ArrayBuffer;
 };
 
 /**
@@ -188,37 +184,49 @@ declare const readFile: {
  *
  * Strings are written using the UTF-8 encoding.
  */
-declare function writeFile(path: string, data: string | ArrayBuffer): void;
+declare function writeFile(
+  path: string | Path,
+  data: string | ArrayBuffer
+): void;
 
 /**
- * Function which returns true if the path points to a directory, or if the
- * path points to a symlink which points to a directory. Otherwise, it returns
- * false.
+ * Function which returns true if the path points to a regular file.
  */
-interface IsDir {
-  /**
-   * Returns true if the path points to a directory, or if the path points to
-   * a symlink which points to a directory. Otherwise, returns false.
-   */
-  (path: string): boolean;
-
-  /**
-   * Maximum number of symlinks to follow before erroring. Defaults to 100.
-   */
-  symlinkLimit: number;
-}
+declare function isFile(path: string | Path): boolean;
 
 /**
  * Function which returns true if the path points to a directory, or if the
  * path points to a symlink which points to a directory. Otherwise, it returns
  * false.
  */
-declare const isDir: IsDir;
+declare function isDir(path: string | Path): boolean;
 
 /**
  * Returns true if the path points to a symlink.
  */
-declare function isLink(path: string): boolean;
+declare function isLink(path: string | Path): boolean;
+
+/**
+ * Returns true if the resource at the provided path can be executed by the
+ * current user.
+ *
+ * If nothing exists at that path, an error will be thrown.
+ */
+declare function isExecutable(path: string | Path): boolean;
+
+/**
+ * Returns true if the resource at the provided path can be read by the current
+ * user.
+ *
+ * If nothing exists at that path, an error will be thrown.
+ */
+declare function isReadable(path: string | Path): boolean;
+
+/**
+ * Returns true if a resource at the provided path could be written to by the
+ * current user.
+ */
+declare function isWritable(path: string | Path): boolean;
 
 /**
  * Delete the file or directory at the specified path.
@@ -227,22 +235,22 @@ declare function isLink(path: string): boolean;
  *
  * Provides the same functionality as the command `rm -rf`.
  */
-declare function remove(path: string): void;
+declare function remove(path: string | Path): void;
 
 /**
  * Returns true if a file or directory exists at the specified path.
  *
  * Provides the same functionality as the command `test -e`.
  */
-declare function exists(path: string): boolean;
+declare function exists(path: string | Path): boolean;
 
 /**
- * Create directories for each of the provided path components,
+ * Creates directories for each of the provided path components,
  * if they don't already exist.
  *
  * Provides the same functionality as the command `mkdir -p`.
  */
-declare function ensureDir(path: string): string;
+declare function ensureDir(path: string | Path): string;
 
 /**
  * Options for {@link copy}.
@@ -270,12 +278,23 @@ declare type CopyOptions = {
 };
 
 /**
- * Copy a file or folder from one location to another.
+ * Copies a file or folder from one location to another.
  * Folders are copied recursively.
  *
  * Provides the same functionality as the command `cp -R`.
  */
-declare function copy(from: string, to: string, options?: CopyOptions): void;
+declare function copy(
+  from: string | Path,
+  to: string | Path,
+  options?: CopyOptions
+): void;
+
+/**
+ * Rename the file or directory at the specified path.
+ *
+ * Provides the same functionality as the command `mv`.
+ */
+declare function rename(from: string | Path, to: string | Path): void;
 
 /** An object that represents a filesystem path. */
 declare class Path {
@@ -323,10 +342,10 @@ declare class Path {
   ): string;
 
   /**
-   * Return whether the provided path string is absolute; that is, whether it
+   * Return whether the provided path is absolute; that is, whether it
    * starts with either `/` or a drive letter (ie `C:`).
    */
-  static isAbsolute(path: string): boolean;
+  static isAbsolute(path: string | Path): boolean;
 
   /** A tagged template literal function that creates a `Path` object. */
   static tag(
@@ -390,25 +409,52 @@ declare class Path {
    */
   isAbsolute(): boolean;
 
+  /**
+   * Make a second Path object containing the same information as this one.
+   */
+  clone(): this;
+
+  /**
+   * Express this path relative to `dir`.
+   *
+   * @param dir - The directory to create a new path relative to.
+   * @param options - Options that affect the resulting path.
+   */
+  relativeTo(
+    dir: Path | string,
+    options?: {
+      /**
+       * Defaults to false. When true, a leading `./` will be omitted from the
+       * path, if present. Note that a leading `../` will never be omitted.
+       */
+      noLeadingDot?: boolean;
+    }
+  ): Path;
+
   /**
    * Turn this path into a string by joining its segments using its separator.
    */
   toString(): string;
+
+  /**
+   * Alias for `toString`; causes Path objects to be serialized as strings.
+   */
+  toJSON(): string;
 }
 
 /**
  * The absolute path to the current file (whether script or module).
  *
- * Behaves the same as in Node.js, except that it's present within ES modules.
+ * Behaves the same as in Node.js, except that it's also present within ES modules.
  */
-declare const __filename: string;
+declare var __filename: string;
 
 /**
  * The absolute path to the directory the current file is inside of.
  *
- * Behaves the same as in Node.js, except that it's present within ES modules.
+ * Behaves the same as in Node.js, except that it's also present within ES modules.
  */
-declare const __dirname: string;
+declare var __dirname: string;
 
 /**
  * Return the last component of a path string.
@@ -500,7 +546,7 @@ declare function extname(
 ): string;
 
 /**
- * Return the contents of a directory, as absolute paths. `.` and `..` are
+ * Returns the contents of a directory, as absolute paths. `.` and `..` are
  * omitted.
  *
  * Use the `relativePaths` option to get relative paths instead (relative to
@@ -513,18 +559,22 @@ declare function ls(
 
 /**
  * Print data to stdout using C-style format specifiers.
+ *
+ * The same formats as the standard C library printf are supported. Integer
+ * format types (e.g. `%d`) truncate the Numbers or BigInts to 32 bits. Use the l
+ * modifier (e.g. `%ld`) to truncate to 64 bits.
  */
 declare function printf(format: string, ...args: Array<any>): void;
 
 /**
- * Return the process's current working directory.
+ * Returns the process's current working directory.
  *
  * Provides the same functionality as the shell builtin of the same name.
  */
 declare function pwd(): string;
 
 /**
- * Read a symlink.
+ * Reads a symlink.
  *
  * Returns the target of the symlink, which may be absolute or relative.
  *
@@ -541,6 +591,40 @@ declare function readlink(path: string | Path): string;
  */
 declare function realpath(path: string | Path): string;
 
+/**
+ * Blocks the current thread for at least the specified number of milliseconds,
+ * or maybe a tiny bit longer.
+ *
+ * alias for `sleep.sync`.
+ */
+declare var sleep: {
+  /**
+   * Blocks the current thread for at least the specified number of milliseconds,
+   * or maybe a tiny bit longer.
+   *
+   * alias for `sleep.sync`.
+   *
+   * @param milliseconds - The number of milliseconds to block for.
+   */
+  (milliseconds: number): void;
+
+  /**
+   * Blocks the current thread for at least the specified number of milliseconds,
+   * or maybe a tiny bit longer.
+   *
+   * @param milliseconds - The number of milliseconds to block for.
+   */
+  sync(milliseconds: number): void;
+
+  /**
+   * Returns a Promise which resolves in at least the specified number of
+   * milliseconds, maybe a little longer.
+   *
+   * @param milliseconds - The number of milliseconds to wait before the returned Promise should be resolved.
+   */
+  async(milliseconds: number): Promise<void>;
+};
+
 /**
  * If the file at `path` exists, update its creation/modification timestamps.
  *
@@ -552,7 +636,7 @@ declare function touch(path: string | Path): void;
 
 declare type BaseExecOptions = {
   /** Sets the current working directory for the child process. */
-  cwd?: string;
+  cwd?: string | Path;
 
   /** Sets environment variables within the process. */
   env?: { [key: string | number]: string | number | boolean };
@@ -567,29 +651,29 @@ declare type BaseExecOptions = {
    * ```
    */
   trace?: (...args: Array<any>) => void;
-};
 
-declare interface Exec {
-  (args: Array<string> | string): void;
+  /**
+   * Whether an Error should be thrown when the process exits with a nonzero
+   * status code.
+   *
+   * Defaults to true.
+   */
+  failOnNonZeroStatus?: boolean;
 
-  (args: Array<string> | string, options: Record<string, never>): void;
+  /**
+   * If true, stdout and stderr will be collected into strings or array buffers
+   * and returned instead of being printed to the screen.
+   *
+   * Defaults to false. true is an alias for "utf8".
+   */
+  captureOutput?: boolean | "utf8" | "arraybuffer";
+};
 
+declare interface Exec {
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * Whether an Error should be thrown when the process exits with a nonzero
-       * status code.
-       *
-       * Defaults to true.
-       */
       failOnNonZeroStatus: true;
-      /**
-       * If true, stdout and stderr will be collected into strings and returned
-       * instead of being printed to the screen.
-       *
-       * Defaults to false.
-       */
       captureOutput: false;
     }
   ): void;
@@ -597,19 +681,7 @@ declare interface Exec {
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * Whether an Error should be thrown when the process exits with a nonzero
-       * status code.
-       *
-       * Defaults to true.
-       */
       failOnNonZeroStatus: false;
-      /**
-       * If true, stdout and stderr will be collected into strings and returned
-       * instead of being printed to the screen.
-       *
-       * Defaults to false.
-       */
       captureOutput: false;
     }
   ):
@@ -619,69 +691,115 @@ declare interface Exec {
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * Whether an Error should be thrown when the process exits with a nonzero
-       * status code.
-       *
-       * Defaults to true.
-       */
-      failOnNonZeroStatus: false;
+      failOnNonZeroStatus: true;
+      captureOutput: true;
     }
-  ):
-    | { status: number; signal: undefined }
-    | { status: undefined; signal: number };
+  ): { stdout: string; stderr: string };
 
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * Whether an Error should be thrown when the process exits with a nonzero
-       * status code.
-       *
-       * Defaults to true.
-       */
       failOnNonZeroStatus: true;
-      /**
-       * If true, stdout and stderr will be collected into strings and returned
-       * instead of being printed to the screen.
-       *
-       * Defaults to false.
-       */
-      captureOutput: true;
+      captureOutput: "utf8";
     }
   ): { stdout: string; stderr: string };
 
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * If true, stdout and stderr will be collected into strings and returned
-       * instead of being printed to the screen.
-       *
-       * Defaults to false.
-       */
-      captureOutput: true;
+      failOnNonZeroStatus: true;
+      captureOutput: "arraybuffer";
     }
-  ): { stdout: string; stderr: string };
+  ): { stdout: ArrayBuffer; stderr: ArrayBuffer };
 
   (
     args: Array<string> | string,
     options: BaseExecOptions & {
-      /**
-       * Whether an Error should be thrown when the process exits with a nonzero
-       * status code.
-       *
-       * Defaults to true.
-       */
       failOnNonZeroStatus: false;
       captureOutput: true;
     }
   ):
     | { stdout: string; stderr: string; status: number; signal: undefined }
     | { stdout: string; stderr: string; status: undefined; signal: number };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      failOnNonZeroStatus: false;
+      captureOutput: "utf-8";
+    }
+  ):
+    | { stdout: string; stderr: string; status: number; signal: undefined }
+    | { stdout: string; stderr: string; status: undefined; signal: number };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      failOnNonZeroStatus: false;
+      captureOutput: "arraybuffer";
+    }
+  ):
+    | {
+        stdout: ArrayBuffer;
+        stderr: ArrayBuffer;
+        status: number;
+        signal: undefined;
+      }
+    | {
+        stdout: ArrayBuffer;
+        stderr: ArrayBuffer;
+        status: undefined;
+        signal: number;
+      };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      failOnNonZeroStatus: true;
+    }
+  ): void;
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      failOnNonZeroStatus: false;
+    }
+  ):
+    | { status: number; signal: undefined }
+    | { status: undefined; signal: number };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      captureOutput: true;
+    }
+  ): { stdout: string; stderr: string };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      captureOutput: "utf8";
+    }
+  ): { stdout: string; stderr: string };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      captureOutput: "arraybuffer";
+    }
+  ): { stdout: ArrayBuffer; stderr: ArrayBuffer };
+
+  (
+    args: Array<string> | string,
+    options: BaseExecOptions & {
+      captureOutput: false;
+    }
+  ): void;
+
+  (args: Array<string> | string, options?: BaseExecOptions): void;
 }
 
-/** Run a child process using the provided arguments. The first value in the arguments array is the program to run. */
+/** Runs a child process using the provided arguments. The first value in the arguments array is the program to run. */
 declare const exec: Exec;
 
 /** Alias for `exec(args, { captureOutput: true })` */
@@ -690,6 +808,100 @@ declare function $(args: Array<string> | string): {
   stderr: string;
 };
 
+/** A class which represents a child process. The process may or may not be running. */
+declare interface ChildProcess {
+  /**
+   * The argv for the process. The first entry in this array is the program to
+   * run.
+   */
+  args: Array<string>;
+
+  /** The current working directory for the process. */
+  cwd: string;
+
+  /** The environment variables for the process. */
+  env: { [key: string]: string };
+
+  /**
+   * The standard I/O streams for the process. Generally these are the same as
+   * `std.in`, `std.out`, and `std.err`, but they can be customized to write
+   * output elsewhere.
+   */
+  stdio: {
+    /** Where the process reads stdin from */
+    in: FILE;
+    /** Where the process writes stdout to */
+    out: FILE;
+    /** Where the process writes stderr to */
+    err: FILE;
+  };
+
+  /**
+   * Optional trace function which, if present, will be called at various times
+   * to provide information about the lifecycle of the process.
+   */
+  trace?: (...args: Array<any>) => void;
+
+  pid: number | null;
+
+  /** Spawns the process and returns its pid (process id). */
+  start(): number;
+
+  /** Blocks the calling thread until the process exits or is killed. */
+  waitUntilComplete():
+    | { status: number; signal: undefined }
+    | { status: undefined; signal: number };
+}
+
+/**
+ * Options to be passed to the ChildProcess constructor. Their purposes and
+ * types match the same-named properties found on the resulting ChildProcess.
+ */
+declare type ChildProcessOptions = {
+  /** The current working directory for the process. */
+  cwd?: string;
+
+  /** The environment variables for the process. */
+  env?: { [key: string]: string };
+
+  /**
+   * The standard I/O streams for the process. Generally these are the same as
+   * `std.in`, `std.out`, and `std.err`, but they can be customized to write
+   * output elsewhere.
+   */
+  stdio?: {
+    /** Where the process reads stdin from */
+    in?: FILE;
+    /** Where the process writes stdout to */
+    out?: FILE;
+    /** Where the process writes stderr to */
+    err?: FILE;
+  };
+
+  /**
+   * Optional trace function which, if present, will be called at various times
+   * to provide information about the lifecycle of the process.
+   */
+  trace?: (...args: Array<any>) => void;
+};
+
+declare interface ChildProcessConstructor {
+  /**
+   * Construct a new ChildProcess.
+   *
+   * @param args - The argv for the process. The first entry in this array is the program to run.
+   * @param options - Options for the process (cwd, env, stdio, etc)
+   */
+  new (
+    args: string | Array<string>,
+    options?: ChildProcessOptions
+  ): ChildProcess;
+
+  readonly prototype: ChildProcess;
+}
+
+declare var ChildProcess: ChildProcessConstructor;
+
 /**
  * Options for {@link glob}.
  */
@@ -717,7 +929,7 @@ declare type GlobOptions = {
   /**
    * Directory to interpret glob patterns relative to. Defaults to `pwd()`.
    */
-  dir?: string;
+  dir?: string | Path;
 };
 
 /**
@@ -729,7 +941,17 @@ declare type GlobOptions = {
 declare function glob(
   patterns: string | Array<string>,
   options?: GlobOptions
-): Array<string>;
+): Array<Path>;
+
+/**
+ * Clear the contents and scrollback buffer of the tty by printing special characters into stdout.
+ */
+declare function clear(): void;
+
+interface Console {
+  /** Same as {@link clear}(). */
+  clear: typeof clear;
+}
 
 /**
  * Remove ANSI control characters from a string.
@@ -741,11 +963,6 @@ declare function stripAnsi(input: string): string;
  */
 declare function quote(input: string): string;
 
-/**
- * Clear the contents and scrollback buffer of the tty by printing special characters into stdout.
- */
-declare function clear(): void;
-
 // Colors
 
 /** Wrap a string with the ANSI control characters that will make it print as black text. */
@@ -866,51 +1083,59 @@ declare const grepString: {
     str: string,
     pattern: string | RegExp,
     options: { inverse: true; details: true }
-  ): Array<string>;
+  ): Array<{
+    lineNumber: number;
+    lineContent: string;
+    matches: RegExpMatchArray;
+  }>;
 };
 
 /** Read the content at `path`, split it on newline, and then return lines matching `pattern`. */
 declare const grepFile: {
   /** Read the content at `path`, split it on newline,  and then return lines matching `pattern`. */
-  (path: string, pattern: string | RegExp): Array<string>;
+  (path: string | Path, pattern: string | RegExp): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return lines matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: false }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return lines NOT matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: true }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return lines matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { details: false }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return lines matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: false; details: false }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return lines NOT matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: true; details: false }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return info about lines matching `pattern`. */
-  (path: string, pattern: string | RegExp, options: { details: true }): Array<{
+  (
+    path: string | Path,
+    pattern: string | RegExp,
+    options: { details: true }
+  ): Array<{
     lineNumber: number;
     lineContent: string;
     matches: RegExpMatchArray;
@@ -918,17 +1143,21 @@ declare const grepFile: {
 
   /** Read the content at `path`, split it on newline,  and then return info about lines matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: false; details: true }
   ): Array<string>;
 
   /** Read the content at `path`, split it on newline,  and then return info about lines NOT matching `pattern`. */
   (
-    path: string,
+    path: string | Path,
     pattern: string | RegExp,
     options: { inverse: true; details: true }
-  ): Array<string>;
+  ): Array<{
+    lineNumber: number;
+    lineContent: string;
+    matches: RegExpMatchArray;
+  }>;
 };
 
 interface String {
@@ -975,7 +1204,11 @@ interface String {
     (
       pattern: string | RegExp,
       options: { inverse: true; details: true }
-    ): Array<string>;
+    ): Array<{
+      lineNumber: number;
+      lineContent: string;
+      matches: RegExpMatchArray;
+    }>;
   };
 }
 
@@ -2365,7 +2598,7 @@ declare const assert: {
  * - Use `maxLength` to limit how much data to read.
  * - Use `until` to stop reading once a certain byte or character has been
  *   read.
- * - Use `path` or `fd` to open a file.
+ * - Use `path` or `fd` to open a file (or pass a FILE or Path object).
  */
 declare type PipeSource =
   | { data: string; maxLength?: number; until?: string | byte }
@@ -2378,12 +2611,9 @@ declare type PipeSource =
   | DataView
   | { data: DataView; maxLength?: number; until?: string | byte }
   | FILE
-  | {
-      data: FILE;
-      maxLength?: number;
-      until?: string | byte;
-    }
-  | { path: string; maxLength?: number; until?: string | byte }
+  | { data: FILE; maxLength?: number; until?: string | byte }
+  | Path
+  | { path: Path | string; maxLength?: number; until?: string | byte }
   | { fd: number; maxLength?: number; until?: string | byte };
 
 /**
@@ -2399,6 +2629,7 @@ declare type PipeDestination =
   | SharedArrayBuffer
   | DataView
   | TypedArray
+  | Path
   | FILE
   | ArrayBufferConstructor
   | SharedArrayBufferConstructor
@@ -2437,39 +2668,132 @@ declare function pipe<Dest extends PipeDestination>(
     : never;
 };
 
+interface InteractivePrompt {
+  prompt?: () => string;
+  printInput?: (input: string) => void;
+  historyFileName?: string;
+  getCompletions?: (
+    line: string,
+    pos: number
+  ) => {
+    // TODO refactor these to have better key names
+    tab: Array<string>;
+    pos: number;
+    ctx: { [key: string | number | symbol]: any };
+  };
+
+  handleInput: (input: string) => void;
+  start(): void;
+}
+
+interface InteractivePromptConstructor {
+  new (
+    handleInput: (input: string) => void,
+    options?: {
+      prompt?: () => string;
+      printInput?: (input: string) => void;
+      historyFileName?: string;
+      getCompletions?: (
+        line: string,
+        pos: number
+      ) => {
+        // TODO refactor these to have better key names
+        tab: Array<string>;
+        pos: number;
+        ctx: { [key: string | number | symbol]: any };
+      };
+    }
+  ): InteractivePrompt;
+
+  prototype: InteractivePrompt;
+}
+
+/** wip experimental use at your own risk */
+declare var InteractivePrompt: InteractivePromptConstructor;
+
 /**
  * Launch the Yavascript REPL (read-eval-print-loop).
  *
  * @param context Variables to make available as globals within the repl.
  * @param lang The langauge to use in the repl. Defaults to "javascript".
  */
-declare function startRepl(
-  context?: { [key: string]: any },
-  lang?:
-    | "js"
-    | "javascript"
-    | "ts"
-    | "typescript"
-    | "jsx"
-    | "tsx"
-    | "coffee"
-    | "coffeescript"
-): void;
+declare const startRepl: {
+  (
+    context?: { [key: string]: any },
+    lang?:
+      | "js"
+      | "javascript"
+      | "ts"
+      | "typescript"
+      | "jsx"
+      | "tsx"
+      | "coffee"
+      | "coffeescript"
+  ): void;
 
-/**
- * Returns the absolute path to the root folder of the git/hg repo.
- *
- * This is done by running `git rev-parse --show-toplevel` and `hg root`.
- *
- * If `relativeTo` is provided, the git and hg commands will be executed in
- * that folder instead of in `pwd()`.
- */
-declare function repoRoot(relativeTo?: string): string;
+  /**
+   * A special value; when expressions result in this value, the repl will
+   * print nothing instead of printing this value.
+   */
+  NOTHING: symbol;
+};
 
 /**
- * Returns whether the provided path is ignored by git.
+ * An object that points to a git repository on disk and provides utility
+ * methods for getting information from that repo.
  */
-declare function isGitignored(path: string): boolean;
+declare class GitRepo {
+  /**
+   * Given a path to a file or folder on disk, searches upwards through the
+   * directory ancestry to find a `.git` folder, then returns the Path that
+   * contains that `.git` folder. If no `.git` folder is found, an error will be
+   * thrown.
+   */
+  static findRoot(fromPath: string | Path): Path;
+
+  /**
+   * Creates a new `GitRepo` object for the given repo on disk.
+   */
+  constructor(repoDir: string | Path);
+
+  /**
+   * The root folder of the git repo that this `GitRepo` object represents (the
+   * folder that contains the '.git' folder).
+   */
+  repoDir: Path;
+
+  /**
+   * Returns the commit SHA the git repo is currently pointed at.
+   *
+   * This is done by running `git rev-parse HEAD`.
+   */
+  commitSHA(): string;
+
+  /**
+   * If the commit SHA the git repo is currently pointed at is the tip of a
+   * named branch, returns the branch name. Otherwise, returns `null`.
+   *
+   * This is done by running `git rev-parse --abbrev-ref HEAD`.
+   */
+  branchName(): string | null;
+
+  /**
+   * Returns a boolean indicating whether there are uncommited changes in the
+   * git repo. `true` means there are changes, `false` means there are no
+   * changes (ie. the repo is clean).
+   *
+   * This is done by running `git status --quiet`.
+   */
+  isWorkingTreeDirty(): boolean;
+
+  /**
+   * Returns whether the provided path is ignored by git.
+   *
+   * If `path` is an absolute path, it must be a child directory of this GitRepo
+   * object's `repoDir`, or else an error will be thrown.
+   */
+  isIgnored(path: string | Path): boolean;
+}
 
 /**
  * Configures the default value of `trace` in functions which receive `trace`
@@ -2689,6 +3013,866 @@ declare type TypedArrayConstructor =
 // QuickJS APIs, which YavaScript builds upon
 // ------------------------------------------
 // ==========================================
+interface ObjectConstructor {
+  /**
+   * Convert the specified value to a primitive value.
+   *
+   * The provided hint indicates a preferred return type, which may or may not
+   * be respected by the engine.
+   *
+   * See the abstract operation "ToPrimitive" in the ECMAScript standard for
+   * more info.
+   */
+  toPrimitive(
+    input: any,
+    hint: "string" | "number" | "default"
+  ): string | number | bigint | boolean | undefined | symbol | null;
+
+  /**
+   * Returns a boolean indicating whether the specified value is a primitive value.
+   */
+  isPrimitive(input: any): boolean;
+}
+
+interface SymbolConstructor {
+  /**
+   * A method that changes the result of using the `typeof` operator on the
+   * object. Called by the semantics of the typeof operator.
+   *
+   * Note that the following semantics will come into play when use of the
+   * `typeof` operator causes the engine to call a `Symbol.typeofValue` method
+   * on an object:
+   *
+   * - If the method returns any value other than one of the string values
+   *   which are normally the result of using the `typeof` operator, the engine
+   *   behaves as if no `Symbol.typeofValue` method was present on the object.
+   * - If an error is thrown from this method, or an error is thrown while
+   *   accessing this property, the error will be silently ignored, and the
+   *   engine will behave as if no `Symbol.typeofValue` method was present on
+   *   the object.
+   * - If this property is present on an object, but the value of that property
+   *   is not a function, the engine will not consider that value when
+   *   determining the result of the `typeof` operation (it'll ignore it).
+   */
+  readonly typeofValue: unique symbol;
+
+  /**
+   * To override operators (+, -, ==, etc) for an object, set its
+   * `Symbol.operatorSet` property to an `OperatorSet` object, which can be
+   * created via `Operators.create`.
+   */
+  readonly operatorSet: unique symbol;
+}
+
+/**
+ * An object that, if placed on another object's `Symbol.operatorSet` property,
+ * will overload its operators to behave as defined by the functions this
+ * OperatorSet was constructed with.
+ *
+ * You can create an OperatorSet via `Operators(...)` or
+ * `Operators.create(...)`.
+ */
+declare type OperatorSet = {
+  /**
+   * This property is not here at runtime; we just use it to make this type
+   * differ from an empty object.
+   */
+  __is__: "OperatorSet";
+};
+
+interface OperatorFunctions<Left, Right> {
+  "+": (left: Left, right: Right) => any;
+  "-": (left: Left, right: Right) => any;
+  "*": (left: Left, right: Right) => any;
+  "/": (left: Left, right: Right) => any;
+  "%": (left: Left, right: Right) => any;
+  "**": (left: Left, right: Right) => any;
+  "|": (left: Left, right: Right) => any;
+  "&": (left: Left, right: Right) => any;
+  "^": (left: Left, right: Right) => any;
+  "<<": (left: Left, right: Right) => any;
+  ">>": (left: Left, right: Right) => any;
+  ">>>": (left: Left, right: Right) => any;
+  "==": (left: Left, right: Right) => any;
+  "<": (left: Left, right: Right) => any;
+  pos: (left: Left, right: Right) => any;
+  neg: (left: Left, right: Right) => any;
+  "++": (left: Left, right: Right) => any;
+  "--": (left: Left, right: Right) => any;
+  "~": (left: Left, right: Right) => any;
+}
+
+interface SelfOperators<T> extends Partial<OperatorFunctions<T, T>> {
+  left?: undefined;
+  right?: undefined;
+}
+
+interface LeftOperators<T, Left> extends Partial<OperatorFunctions<Left, T>> {
+  left: {};
+  right?: undefined;
+}
+
+interface RightOperators<T, Right>
+  extends Partial<OperatorFunctions<T, Right>> {
+  left?: undefined;
+  right: {};
+}
+
+interface OperatorsConstructor {
+  /**
+   * Creates a new OperatorSet object, which should be placed on an object's
+   * Symbol.operatorSet property.
+   */
+  <T>(
+    selfOperators?: SelfOperators<T>,
+    ...otherOperators: Array<LeftOperators<T, any> | RightOperators<T, any>>
+  ): OperatorSet;
+
+  /**
+   * Creates a new OperatorSet object, which should be placed on an object's
+   * Symbol.operatorSet property.
+   */
+  create: <T>(
+    selfOperators?: SelfOperators<T>,
+    ...otherOperators: Array<LeftOperators<T, any> | RightOperators<T, any>>
+  ) => OperatorSet;
+
+  /**
+   * In math mode, the BigInt division and power operators can be overloaded by
+   * using this function.
+   */
+  updateBigIntOperators(
+    ops: Pick<OperatorFunctions<BigInt, BigInt>, "/" | "**">
+  ): void;
+}
+
+declare var Operators: OperatorsConstructor;
+
+interface Number {
+  [Symbol.operatorSet]: OperatorSet;
+}
+
+interface Boolean {
+  [Symbol.operatorSet]: OperatorSet;
+}
+
+interface String {
+  [Symbol.operatorSet]: OperatorSet;
+}
+
+interface BigInt {
+  [Symbol.operatorSet]: OperatorSet;
+}
+
+interface BigIntConstructor {
+  /**
+   * Return trunc(a/b).
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  tdiv(a: bigint, b: bigint): bigint;
+
+  /**
+   * Return \lfloor a/b \rfloor.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  fdiv(a: bigint, b: bigint): bigint;
+
+  /**
+   * Return \lceil a/b \rceil.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  cdiv(a: bigint, b: bigint): bigint;
+
+  /**
+   * Return sgn(b) \lfloor a/{|b|} \rfloor (Euclidian division).
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  ediv(a: bigint, b: bigint): bigint;
+
+  /**
+   * Perform trunc(a/b) and return an array of two elements. The first element
+   * is the quotient, the second is the remainder.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  tdivrem(a: bigint, b: bigint): [bigint, bigint];
+
+  /**
+   * Perform \lfloor a/b \rfloor and return an array of two elements. The first
+   * element is the quotient, the second is the remainder.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  fdivrem(a: bigint, b: bigint): [bigint, bigint];
+
+  /**
+   * Perform \lceil a/b \rceil and return an array of two elements. The first
+   * element is the quotient, the second is the remainder.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  cdivrem(a: bigint, b: bigint): [bigint, bigint];
+
+  /**
+   * Perform sgn(b) \lfloor a/{|b|} \rfloor (Euclidian division) and return an
+   * array of two elements. The first element is the quotient, the second is
+   * the remainder.
+   *
+   * b = 0 raises a RangeError exception.
+   */
+  edivrem(a: bigint, b: bigint): [bigint, bigint];
+
+  /**
+   * Return \lfloor \sqrt(a) \rfloor.
+   *
+   * A RangeError exception is raised if a < 0.
+   */
+  sqrt(a: bigint): bigint;
+
+  /**
+   * Return an array of two elements. The first element is
+   * \lfloor \sqrt{a} \rfloor. The second element is
+   * a-\lfloor \sqrt{a} \rfloor^2.
+   *
+   * A RangeError exception is raised if a < 0.
+   */
+  sqrtrem(a: bigint): [bigint, bigint];
+
+  /**
+   * Return -1 if a \leq 0 otherwise return \lfloor \log2(a) \rfloor.
+   */
+  floorLog2(a: bigint): bigint;
+
+  /**
+   * Return the number of trailing zeros in the two’s complement binary representation of a.
+   *
+   * Return -1 if a=0.
+   */
+  ctz(a: bigint): bigint;
+}
+
+declare type BigFloatRoundingMode = number & {
+  /**
+   * This property is not here at runtime; we just use it to make this type
+   * differ from a normal number
+   */
+  __is__: "BigFloatRoundingMode";
+};
+
+interface BigFloatEnvConstructor {
+  /**
+   * Creates a new floating point environment. Its status flags are reset.
+   *
+   * - If unspecified, `precision` defaults to the precision from the global floating point environment.
+   * - If unspecified, `roundingMode` defaults to RNDN.
+   */
+  new (precision?: number, roundingMode?: BigFloatRoundingMode): BigFloatEnv;
+
+  /**
+   * The mantissa precision in bits of the global floating point environment.
+   *
+   * The initial value is 113.
+   */
+  get prec(): number;
+
+  /**
+   * The exponent size in bits of the global floating point environment,
+   * assuming an IEEE 754 representation.
+   *
+   * The initial value is 15.
+   */
+  get expBits(): number;
+
+  /**
+   * Sets the mantissa precision of the global floating point environment to
+   * `prec` and the exponent size to `expBits`, then calls the function `func`.
+   * Then the precision and exponent size are reset to their previous values
+   * and the return value of `func` is returned (or an exception is raised if
+   * `func` raised an exception).
+   *
+   * If expBits is undefined, it is set to {@link BigFloatEnv.expBitsMax}.
+   *
+   * @param func The function to call within the modified environment
+   * @param prec The mantissa precision (in bits) to use in the modified environment
+   * @param expBits The exponent size (in bits) to use in the modified environment. Defaults to {@link BigFloatEnv.expBitsMax}.
+   */
+  setPrec<Ret>(func: () => Ret, prec: number, expBits?: number): Ret;
+
+  /**
+   * Integer; the minimum allowed precision. Must be at least 2.
+   */
+  readonly precMin: number;
+
+  /**
+   * Integer; the maximum allowed precision. Must be at least 113.
+   */
+  readonly precMax: number;
+
+  /**
+   * Integer; the minimum allowed exponent size in bits. Must be at least 3.
+   */
+  readonly expBitsMin: number;
+
+  /**
+   * Integer; the maximum allowed exponent size in bits. Must be at least 15.
+   */
+  readonly expBitsMax: number;
+
+  /**
+   * Round to nearest, with ties to even rounding mode.
+   */
+  readonly RNDN: BigFloatRoundingMode;
+
+  /**
+   * Round to zero rounding mode.
+   */
+  readonly RNDZ: BigFloatRoundingMode;
+
+  /**
+   * Round to -Infinity rounding mode.
+   */
+  readonly RNDD: BigFloatRoundingMode;
+
+  /**
+   * Round to +Infinity rounding mode.
+   */
+  readonly RNDU: BigFloatRoundingMode;
+
+  /**
+   * Round to nearest, with ties away from zero rounding mode.
+   */
+  readonly RNDNA: BigFloatRoundingMode;
+
+  /**
+   * Round away from zero rounding mode.
+   */
+  readonly RNDA: BigFloatRoundingMode;
+
+  /**
+   * Faithful rounding mode. The result is non-deterministically rounded to
+   * -Infinity or +Infinity.
+   *
+   * This rounding mode usually gives a faster and deterministic running time
+   * for the floating point operations.
+   */
+  readonly RNDF: BigFloatRoundingMode;
+
+  prototype: BigFloatEnv;
+}
+
+declare var BigFloatEnv: BigFloatEnvConstructor;
+
+/**
+ * A BigFloatEnv contains:
+ *
+ * - the mantissa precision in bits
+ * - the exponent size in bits assuming an IEEE 754 representation;
+ * - the subnormal flag (if true, subnormal floating point numbers can be generated by the floating point operations).
+ * - the rounding mode
+ * - the floating point status. The status flags can only be set by the floating point operations. They can be reset with BigFloatEnv.prototype.clearStatus() or with the various status flag setters.
+ */
+interface BigFloatEnv {
+  /**
+   * The mantissa precision, in bits.
+   *
+   * If precision was not specified as an argument to the BigFloatEnv
+   * constructor, defaults to the precision value of the global floating-point
+   * environment ({@link BigFloatEnv.prec}).
+   */
+  get prec(): number;
+  set prec(newValue: number);
+
+  /**
+   * The exponent size in bits assuming an IEEE 754 representation.
+   *
+   * Defaults to the exponent size of the global floating-point environment
+   * ({@link BigFloatEnv.expBits}).
+   */
+  get expBits(): number;
+  set expBits(newValue: number);
+
+  /**
+   * The rounding mode.
+   *
+   * If the rounding mode was not specified as an argument to the BigFloatEnv
+   * constructor, defaults to {@link BigFloatEnv.RNDN}.
+   */
+  get rndMode(): BigFloatRoundingMode;
+  set rndMode(newMode: BigFloatRoundingMode);
+
+  /** subnormal flag. It is false when expBits = expBitsMax. Defaults to false. */
+  get subnormal(): boolean;
+  set subnormal(newValue: boolean);
+
+  /** Status flag; cleared by `clearStatus`. */
+  get invalidOperation(): boolean;
+  set invalidOperation(newValue: boolean);
+
+  /** Status flag; cleared by `clearStatus`. */
+  get divideByZero(): boolean;
+  set divideByZero(newValue: boolean);
+
+  /** Status flag; cleared by `clearStatus`. */
+  get overflow(): boolean;
+  set overflow(newValue: boolean);
+
+  /** Status flag; cleared by `clearStatus`. */
+  get underflow(): boolean;
+  set underflow(newValue: boolean);
+
+  /** Status flag; cleared by `clearStatus`. */
+  get inexact(): boolean;
+  set inexact(newValue: boolean);
+
+  /**
+   * Clear the status flags (invalidOperation, divideByZero, overflow,
+   * underflow, and inexact).
+   */
+  clearStatus(): void;
+}
+
+interface BigFloatConstructor {
+  /**
+   * If `value` is a numeric type, it is converted to BigFloat without rounding.
+   *
+   * If `value`` is a string, it is converted to BigFloat using the precision of the global floating point environment ({@link BigFloatEnv.prec}).
+   */
+  (value: number | string | BigInt | BigFloat): BigFloat;
+
+  prototype: BigFloat;
+
+  /**
+   * The value of {@link Math.LN2} rounded to nearest, ties to even with the
+   * current global precision.
+   *
+   * The constant values are cached for small precisions.
+   */
+  get LN2(): BigFloat;
+
+  /**
+   * The value of {@link Math.PI} rounded to nearest, ties to even with
+   * the current global precision.
+   *
+   * The constant values are cached for small precisions.
+   */
+  get PI(): BigFloat;
+
+  /**
+   * The value of {@link Number.MIN_VALUE} as a BigFloat.
+   */
+  get MIN_VALUE(): BigFloat;
+
+  /**
+   * The value of {@link Number.MAX_VALUE} as a BigFloat.
+   */
+  get MAX_VALUE(): BigFloat;
+
+  /**
+   * The value of {@link Number.EPSILON} as a BigFloat.
+   */
+  get EPSILON(): BigFloat;
+
+  /**
+   * Rounds the floating point number `a` according to the floating point
+   * environment `e` or the global environment if `e` is undefined.
+   */
+  fpRound(a: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Parses the string `a` as a floating point number in radix `radix`.
+   *
+   * The radix is 0 (default) or from 2 to 36. The radix 0 means radix 10
+   * unless there is a hexadecimal or binary prefix.
+   *
+   * The result is rounded according to the floating point environment `e` or
+   * the global environment if `e` is undefined.
+   */
+  parseFloat(a: string, radix?: number, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns true if `a` is a finite bigfloat. Returns false otherwise.
+   */
+  isFinite(a: BigFloat): boolean;
+
+  /**
+   * Returns true if a is a NaN bigfloat. Returns false otherwise.
+   */
+  isNaN(a: BigFloat): boolean;
+
+  /**
+   * Adds `a` and `b` together and rounds the resulting floating point number
+   * according to the floating point environment `e`, or the global environment
+   * if e is undefined.
+   *
+   * If `e` is specified, the floating point status flags on `e` are updated.
+   */
+  add(a: BigFloat, b: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Subtracts `b` from `a` and rounds the resulting floating point number
+   * according to the floating point environment `e`, or the global environment
+   * if e is undefined.
+   *
+   * If `e` is specified, the floating point status flags on `e` are updated.
+   */
+  sub(a: BigFloat, b: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Multiplies `a` and `b` together and rounds the resulting floating point
+   * number according to the floating point environment `e`, or the global
+   * environment if e is undefined.
+   *
+   * If `e` is specified, the floating point status flags on `e` are updated.
+   */
+  mul(a: BigFloat, b: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Divides `a` by `b` and rounds the resulting floating point number
+   * according to the floating point environment `e`, or the global environment
+   * if e is undefined.
+   *
+   * If `e` is specified, the floating point status flags on `e` are updated.
+   */
+  div(a: BigFloat, b: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Rounds `x` down to the nearest integer.
+   *
+   * No additional rounding (ie. BigFloatEnv-related rounding) is performed.
+   */
+  floor(x: BigFloat): BigFloat;
+
+  /**
+   * Rounds `x` up to the nearest integer.
+   *
+   * No additional rounding (ie. BigFloatEnv-related rounding) is performed.
+   */
+  ceil(x: BigFloat): BigFloat;
+
+  /**
+   * Rounds `x` to the nearest integer.
+   *
+   * No additional rounding (ie. BigFloatEnv-related rounding) is performed.
+   */
+  round(x: BigFloat): BigFloat;
+
+  /**
+   * Truncates the fractional part of `x`, resulting in an integer.
+   *
+   * No additional rounding (ie. BigFloatEnv-related rounding) is performed.
+   */
+  trunc(x: BigFloat): BigFloat;
+
+  /**
+   * Returns the absolute value of `x`.
+   *
+   * No additional rounding (ie. BigFloatEnv-related rounding) is performed.
+   */
+  abs(x: BigFloat): BigFloat;
+
+  /**
+   * Floating point remainder. The quotient is truncated to zero.
+   *
+   * `e` is an optional floating point environment.
+   */
+  fmod(x: BigFloat, y: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Floating point remainder. The quotient is rounded to the nearest integer
+   * with ties to even.
+   *
+   * `e` is an optional floating point environment.
+   */
+  remainder(x: BigFloat, y: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Square root. Returns a rounded floating point number.
+   *
+   * e is an optional floating point environment.
+   */
+  sqrt(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  sin(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  cos(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  tan(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  asin(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  acos(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  atan(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  atan2(x: BigFloat, y: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  exp(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  log(x: BigFloat, e?: BigFloatEnv): BigFloat;
+
+  /**
+   * Returns a rounded floating point number.
+   *
+   * `e` is an optional floating point environment.
+   */
+  pow(x: BigFloat, y: BigFloat, e?: BigFloatEnv): BigFloat;
+}
+
+declare var BigFloat: BigFloatConstructor;
+
+/**
+ * The BigFloat type represents floating point numbers in base 2 with the IEEE 754 semantics.
+ *
+ * A floating point number is represented as a sign, mantissa and exponent.
+ *
+ * The special values NaN, +/-Infinity, +0 and -0 are supported.
+ *
+ * The mantissa and exponent can have any bit length with an implementation specific minimum and maximum.
+ */
+interface BigFloat {
+  valueOf(): BigFloat;
+
+  /** radix must be between 2 and 36 */
+  toString(radix?: number): string;
+
+  /**
+   * Returns a string containing a number represented either in exponential or
+   * fixed-point notation with a specified number of digits.
+   *
+   * @param precision Number of significant digits. There is no range limit on this number.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to {@link BigFloatEnv.RNDNA}.
+   * @param radix The base to use when representing the value. Must be an integer between 2 and 36. Defaults to 10.
+   */
+  toPrecision(
+    precision: number,
+    roundingMode?: BigFloatRoundingMode,
+    radix?: number
+  ): string;
+
+  /**
+   * Returns a string representing a number in fixed-point notation.
+   *
+   * @param fractionDigits Number of digits after the decimal point. There is no range limit on this number.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to {@link BigFloatEnv.RNDNA}.
+   * @param radix The base to use when representing the value. Must be an integer between 2 and 36. Defaults to 10.
+   */
+  toFixed(
+    fractionDigits: number,
+    roundingMode?: BigFloatRoundingMode,
+    radix?: number
+  ): string;
+
+  /**
+   * Returns a string containing a number represented in exponential notation.
+   *
+   * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to {@link BigFloatEnv.RNDNA}.
+   * @param radix The base to use when representing the value. Must be an integer between 2 and 36. Defaults to 10.
+   */
+  toExponential(
+    fractionDigits: number,
+    roundingMode?: BigFloatRoundingMode,
+    radix?: number
+  ): string;
+
+  [Symbol.typeofValue]: () => "bigfloat";
+}
+
+declare type BigDecimalRoundingMode =
+  | "floor"
+  | "ceiling"
+  | "down"
+  | "up"
+  | "half-even"
+  | "half-up";
+
+declare type BigDecimalRoundingObject =
+  | {
+      /** must be >= 1 */
+      maximumSignificantDigits: number;
+      roundingMode: BigDecimalRoundingMode;
+    }
+  | {
+      /** must be >= 0 */
+      maximumFractionDigits: number;
+      roundingMode: BigDecimalRoundingMode;
+    };
+
+interface BigDecimalConstructor {
+  (): BigDecimal;
+  (value: number | string | BigInt | BigFloat): BigDecimal;
+
+  /**
+   * Adds together `a` and `b` and rounds the result according to the rounding
+   * object `e`. If the rounding object is not present, the operation is
+   * executed with infinite precision; in other words, no rounding occurs when
+   * the rounding object is not present.
+   */
+  add(a: BigDecimal, b: BigDecimal, e?: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Subtracts `b` from `a` and rounds the result according to the rounding
+   * object `e`. If the rounding object is not present, the operation is
+   * executed with infinite precision; in other words, no rounding occurs when
+   * the rounding object is not present.
+   */
+  sub(a: BigDecimal, b: BigDecimal, e?: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Multiplies together `a` and `b` and rounds the result according to the
+   * rounding object `e`. If the rounding object is not present, the operation
+   * is executed with infinite precision; in other words, no rounding occurs
+   * when the rounding object is not present.
+   */
+  mul(a: BigDecimal, b: BigDecimal, e?: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Divides `a` by `b` and rounds the result according to the rounding object
+   * `e`.
+   *
+   * If the rounding object is not present, an attempt is made to perform the
+   * operation with infinite precision. However, not all quotients can be
+   * represented with infinite precision. If the quotient cannot be represented
+   * with infinite precision, a RangeError is thrown.
+   *
+   * A RangeError is thrown when dividing by zero.
+   */
+  div(a: BigDecimal, b: BigDecimal, e?: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Perform the modulo operation of `a` by `b` and round the result according
+   * to the rounding object `e`. If the rounding object is not present, the
+   * operation is executed with infinite precision; in other words, no rounding
+   * occurs when the rounding object is not present.
+   */
+  mod(a: BigDecimal, b: BigDecimal, e?: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Obtain the square root of `a`, rounding the result according to the
+   * rounding object `e`.
+   *
+   * If `a` is less than zero, a RangeError will be thrown.
+   *
+   * Note that the rounding object is *required*.
+   */
+  sqrt(a: BigDecimal, e: BigDecimalRoundingObject): BigDecimal;
+
+  /**
+   * Rounds `a` using the rounding object `e`.
+   */
+  round(a: BigDecimal, e: BigDecimalRoundingObject): BigDecimal;
+
+  prototype: BigDecimal;
+}
+
+declare var BigDecimal: BigDecimalConstructor;
+
+/**
+ * The BigDecimal type represents floating point numbers in base 10.
+ *
+ * It is inspired from the proposal available at https://github.com/littledan/proposal-bigdecimal.
+ *
+ * The BigDecimal floating point numbers are always normalized and finite.
+ * There is no concept of -0, Infinity or NaN. By default, all the computations
+ * are done with infinite precision.
+ */
+interface BigDecimal {
+  /**
+   * Returns the bigdecimal primitive value corresponding to this BigDecimal.
+   */
+  valueOf(): BigDecimal;
+
+  /**
+   * Converts this BigDecimal to a string with infinite precision in base 10.
+   */
+  toString(): string;
+
+  /**
+   * Returns a string containing a number represented either in exponential or
+   * fixed-point notation with a specified number of digits.
+   *
+   * @param precision Number of significant digits. There is no range limit on this number.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to "half-up".
+   */
+  toPrecision(precision: number, roundingMode?: BigDecimalRoundingMode): string;
+
+  /**
+   * Returns a string representing a number in fixed-point notation.
+   *
+   * @param fractionDigits Number of digits after the decimal point. There is no range limit on this number.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to "half-up".
+   */
+  toFixed(
+    fractionDigits: number,
+    roundingMode?: BigDecimalRoundingMode
+  ): string;
+
+  /**
+   * Returns a string containing a number represented in exponential notation.
+   *
+   * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
+   * @param roundingMode The rounding mode to use when representing the value. Defaults to "half-up".
+   */
+  toExponential(
+    fractionDigits: number,
+    roundingMode?: BigDecimalRoundingMode
+  ): string;
+}
+
+// Note that BigFloat and BigDecimal have custom operator overloads defined in
+// QuickJS, but TypeScript does not support operator overloading. As such,
+// TypeScript will not understand or handle unary/binary operators for BigFloat
+// and BigDecimal properly.
+
 // Definitions of the globals and modules added by quickjs-libc
 
 /**
@@ -2707,7 +3891,7 @@ declare var print: (...args: Array<any>) => void;
 /**
  * Object that provides functions for logging information.
  */
-declare var console: {
+interface Console {
   /** Same as {@link print}(). */
   log: typeof print;
 
@@ -2719,7 +3903,9 @@ declare var console: {
 
   /** Same as {@link print}(). */
   info: typeof print;
-};
+}
+
+declare var console: Console;
 
 /** An object representing a file handle. */
 declare interface FILE {
@@ -2804,6 +3990,16 @@ declare interface FILE {
 
   /** Write one byte to the file. */
   putByte(value: number): void;
+
+  /**
+   * Set the buffering mode and buffer size for the file stream (wrapper to the libc `setvbuf()`).
+   *
+   * Note that unlike the libc setvbuf, the "buffer" argument is not supported, and therefore is not present.
+   *
+   * @param mode The buffering mode to use. It can be one of the following values: `std._IOFBF` for full buffering, `std._IOLBF` for line buffering, or `std._IONBF` for no buffering.
+   * @param size The size to resize the internal in-memory buffer for this file to.
+   */
+  setvbuf(mode: number, size: number): void;
 }
 
 declare module "quickjs:std" {
@@ -2820,11 +4016,12 @@ declare module "quickjs:std" {
    * @param code - The code to evaluate.
    * @param options - An optional object containing the following optional properties:
    * @property backtraceBarrier - Boolean (default = false). If true, error backtraces do not list the stack frames below the evalScript.
+   * @property filename - String (default = "<evalScript>"). The filename to associate with the code being executed.
    * @returns The result of the evaluation.
    */
   export function evalScript(
     code: string,
-    options?: { backtraceBarrier?: boolean }
+    options?: { backtraceBarrier?: boolean; filename?: string }
   ): any;
 
   /**
@@ -2947,6 +4144,15 @@ declare module "quickjs:std" {
   /** Constant for {@link FILE.seek}. Declares that the offset should be relative to the end of the file. See also libc `fseek()`. */
   export var SEEK_END: number;
 
+  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'full buffering'. */
+  export var _IOFBF: number;
+
+  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'line buffering'. */
+  export var _IOLBF: number;
+
+  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'no buffering'. */
+  export var _IONBF: number;
+
   /** Manually invoke the cycle removal algorithm (garbage collector). The cycle removal algorithm is automatically started when needed, so this function is useful in case of specific memory constraints or for testing. */
   export function gc(): void;
 
@@ -2962,6 +4168,38 @@ declare module "quickjs:std" {
   /** Return an object containing the environment variables as key-value pairs. */
   export function getenviron(): { [key: string]: string | undefined };
 
+  /**
+   * Return the real user ID of the calling process.
+   *
+   * This function throws an error on windows, because windows doesn't support
+   * the same uid/gid paradigm as Unix-like operating systems.
+   */
+  export function getuid(): number;
+
+  /**
+   * Return the effective user ID of the calling process.
+   *
+   * This function throws an error on windows, because windows doesn't support
+   * the same uid/gid paradigm as Unix-like operating systems.
+   */
+  export function geteuid(): number;
+
+  /**
+   * Return the real group ID of the calling process.
+   *
+   * This function throws an error on windows, because windows doesn't support
+   * the same uid/gid paradigm as Unix-like operating systems.
+   */
+  export function getgid(): number;
+
+  /**
+   * Return the effective group ID of the calling process.
+   *
+   * This function throws an error on windows, because windows doesn't support
+   * the same uid/gid paradigm as Unix-like operating systems.
+   */
+  export function getegid(): number;
+
   interface UrlGet {
     /**
      * Download `url` using the `curl` command line utility. Returns string
@@ -3079,6 +4317,20 @@ declare module "quickjs:std" {
    * - octal (0o prefix) and hexadecimal (0x prefix) numbers
    */
   export function parseExtJSON(str: string): any;
+
+  /**
+   * A wrapper around the standard C [strftime](https://en.cppreference.com/w/c/chrono/strftime).
+   * Formats a time/date into a format as specified by the user.
+   *
+   * @param maxBytes - The number of bytes to allocate for the string that will be returned
+   * @param format - Format string, using `%`-prefixed sequences as found in [this table](https://en.cppreference.com/w/c/chrono/strftime#Format_string).
+   * @param time - The Date object (or unix timestamp, in ms) to render.
+   */
+  export function strftime(
+    maxBytes: number,
+    format: string,
+    time: Date | number
+  ): string;
 }
 
 declare module "quickjs:os" {
@@ -3112,8 +4364,19 @@ declare module "quickjs:os" {
   /** POSIX open flag, used in {@link open}. */
   export var O_TRUNC: number;
 
-  /** Windows-specific open flag: open the file in text mode. The default is binary mode. Used in {@link open}. */
-  export var O_TEXT: number;
+  /**
+   * Windows-specific open flag: open the file in binary mode (which is the default). Used in {@link open}.
+   *
+   * NOTE: this property is only present on windows
+   */
+  export var O_BINARY: number | undefined;
+
+  /**
+   * Windows-specific open flag: open the file in text mode. The default is binary mode. Used in {@link open}.
+   *
+   * NOTE: this property is only present on windows
+   */
+  export var O_TEXT: number | undefined;
 
   /** Close the file with descriptor `fd`. */
   export function close(fd: number): void;
@@ -3227,26 +4490,167 @@ declare module "quickjs:os" {
    */
   export function lstat(path: string): Stats;
 
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Mask for getting type of file from mode.
+   */
   export var S_IFMT: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: named pipe (fifo)
+   */
   export var S_IFIFO: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: character special
+   */
   export var S_IFCHR: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: directory
+   */
   export var S_IFDIR: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: block special
+   */
   export var S_IFBLK: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: regular
+   */
   export var S_IFREG: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
-  export var S_IFSOCK: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
-  export var S_IFLNK: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
-  export var S_ISGID: number;
-  /** Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`. */
-  export var S_ISUID: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: socket
+   *
+   * NOTE: this property is not present on windows
+   */
+  export var S_IFSOCK: number | undefined;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * File type: symbolic link
+   *
+   * NOTE: this property is not present on windows
+   */
+  export var S_IFLNK: number | undefined;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Flag: set group id on execution
+   *
+   * NOTE: this property is not present on windows
+   */
+  export var S_ISGID: number | undefined;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Flag: set user id on execution
+   *
+   * NOTE: this property is not present on windows
+   */
+  export var S_ISUID: number | undefined;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Mask for getting RWX permissions for owner
+   */
+  export var S_IRWXU: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: read for owner
+   */
+  export var S_IRUSR: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: write for owner
+   */
+  export var S_IWUSR: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: execute for owner
+   */
+  export var S_IXUSR: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Mask for getting RWX permissions for group
+   */
+  export var S_IRWXG: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: read for group
+   */
+  export var S_IRGRP: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: write for group
+   */
+  export var S_IWGRP: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: execute for group
+   */
+  export var S_IXGRP: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Mask for getting RWX permissions for others
+   */
+  export var S_IRWXO: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: read for others
+   */
+  export var S_IROTH: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: write for others
+   */
+  export var S_IWOTH: number;
+
+  /**
+   * Constant to interpret the `mode` property returned by `stat()`. Has the same value as in the C system header `sys/stat.h`.
+   *
+   * Permission: execute for others
+   */
+  export var S_IXOTH: number;
 
   /**
    * Change the access and modification times of the file path.
@@ -3294,6 +4698,39 @@ declare module "quickjs:os" {
   /** POSIX signal number. */
   export var SIGTERM: number;
 
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGQUIT: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGPIPE: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGALRM: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGUSR1: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGUSR2: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGCHLD: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGCONT: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGSTOP: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGTSTP: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGTTIN: number | undefined;
+
+  /** POSIX signal number. NOTE: this signal is not present on windows. */
+  export var SIGTTOU: number | undefined;
+
   /** Send the signal `sig` to the process `pid`. Use `os.SIG*` constants. */
   export function kill(pid: number, sig: number): void;
 
@@ -3588,29 +5025,19 @@ declare interface InspectFunction {
 declare var inspect: InspectFunction;
 
 /**
- * A class which represents a module namespace object. Note, however, that
- * instances of this class cannot be constructed manually, and must instead be
- * obtained from `import * as`, `import()`, `std.importModule`, or `require`.
+ * A global which lets you configure the module loader (import/export/require).
+ * You can use these properties to add support for importing new filetypes.
  *
- * The static properties on `Module` let you configure the module loader
- * (import/export/require). You can use these properties to add support for
- * importing new filetypes.
+ * This global can also be used to identify whether an object is a module
+ * namespace record.
  */
-declare class Module {
-  /** A module namespace object has arbitrary exports. */
-  [key: string | number | symbol]: any;
-
-  /**
-   * Module objects are not constructable.
-   *
-   * You must instead obtain them using import or require.
-   */
-  private constructor();
-
+interface ModuleGlobal {
   /**
    * Returns true if `target` is a module namespace object.
    */
-  static [Symbol.hasInstance](target: any): target is Module;
+  [Symbol.hasInstance](target: any): target is {
+    [key: string | number | symbol]: any;
+  };
 
   /**
    * A list of filetype extensions that may be omitted from an import specifier
@@ -3625,7 +5052,7 @@ declare class Module {
    * NOTE: If you add a new extension to this array, you will likely also want
    * to add to {@link Module.compilers}.
    */
-  static searchExtensions: Array<string>;
+  searchExtensions: Array<string>;
 
   /**
    * User-defined functions which will handle getting the JavaScript code
@@ -3666,7 +5093,7 @@ declare class Module {
    * NOTE: When adding to this object, you may also wish to add to
    * {@link Module.searchExtensions}.
    */
-  static compilers: {
+  compilers: {
     [extensionWithDot: string]: (filename: string, content: string) => string;
   };
 
@@ -3674,63 +5101,75 @@ declare class Module {
    * Create a virtual built-in module whose exports consist of the own
    * enumerable properties of `obj`.
    */
-  static define(name: string, obj: { [key: string]: any }): void;
+  define(name: string, obj: { [key: string]: any }): void;
 
   /**
    * Resolves a require/import request from `fromFile` into a canonicalized path.
    *
    * To change native module resolution behavior, replace this function with
-   * your own implementation.
+   * your own implementation. Note that you must handle
+   * `Module.searchExtensions` yourself in your replacement implementation.
    */
-  static resolve(name: string, fromFile: string): string;
+  resolve(name: string, fromFile: string): string;
 
   /**
    * Reads the contents of the given resolved module name into a string.
    *
    * To change native module loading behavior, replace this function with your
-   * own implementation.
+   * own implementation. Note that you must handle `Module.compilers` yourself
+   * in your replacement implementation.
    */
-  static read(modulePath: string): string;
+  read(modulePath: string): string;
 }
 
-/**
- * Synchronously import a module.
- *
- * `source` will be resolved relative to the calling file.
- *
- * If `source` does not have a file extension, and a file without an extension
- * cannot be found, the engine will check for files with the extensions in
- * {@link Module.searchExtensions}, and use one of those if present. This
- * behavior also happens when using normal `import` statements.
- *
- * For example, if you write:
- *
- * ```js
- * import something from "./somewhere";
- * ```
- *
- * but there's no file named `somewhere` in the same directory as the file
- * where that import appears, and `Module.searchExtensions` is the default
- * value:
- *
- * ```js
- * [".js"]
- * ```
- *
- * then the engine will look for `somewhere.js`. If that doesn't exist, the
- * engine will look for `somewhere/index.js`. If *that* doesn't exist, an error
- * will be thrown.
- *
- * If you add more extensions to `Module.searchExtensions`, then the engine
- * will use those, too. It will search in the same order as the strings appear
- * in the `Module.searchExtensions` array.
- */
-declare var require: ((source: string) => any) & {
+declare var Module: ModuleGlobal;
+
+interface RequireFunction {
+  /**
+   * Synchronously import a module.
+   *
+   * `source` will be resolved relative to the calling file.
+   *
+   * If `source` does not have a file extension, and a file without an extension
+   * cannot be found, the engine will check for files with the extensions in
+   * {@link Module.searchExtensions}, and use one of those if present. This
+   * behavior also happens when using normal `import` statements.
+   *
+   * For example, if you write:
+   *
+   * ```js
+   * import something from "./somewhere";
+   * ```
+   *
+   * but there's no file named `somewhere` in the same directory as the file
+   * where that import appears, and `Module.searchExtensions` is the default
+   * value:
+   *
+   * ```js
+   * [".js"]
+   * ```
+   *
+   * then the engine will look for `somewhere.js`. If that doesn't exist, the
+   * engine will look for `somewhere/index.js`. If *that* doesn't exist, an error
+   * will be thrown.
+   *
+   * If you add more extensions to `Module.searchExtensions`, then the engine
+   * will use those, too. It will search in the same order as the strings appear
+   * in the `Module.searchExtensions` array.
+   */
+  (source: string): any;
+
   /**
    * Resolves the normalized path to a modules, relative to the calling file.
    */
   resolve: (source: string) => string;
-};
+}
+
+declare var require: RequireFunction;
+
+interface ImportMeta {
+  require: RequireFunction;
+}
 
 declare var setTimeout: typeof import("quickjs:os").setTimeout;
 declare var clearTimeout: typeof import("quickjs:os").clearTimeout;
@@ -3794,41 +5233,210 @@ interface StringConstructor {
   };
 }
 
-interface ObjectConstructor {
+declare module "quickjs:bytecode" {
   /**
-   * Convert the specified value to a primitive value.
+   * Convert the module or script in the specified file into bytecode.
    *
-   * The provided hint indicates a preferred return type, which may or may not
-   * be respected by the engine.
-   *
-   * See the abstract operation "ToPrimitive" in the ECMAScript standard for
-   * more info.
+   * When converted back to a value, it will be a function.
    */
-  toPrimitive(
-    input: any,
-    hint: "string" | "number" | "default"
-  ): string | number | bigint | boolean | undefined | symbol | null;
+  export function fromFile(
+    path: string,
+    options?: { byteSwap?: boolean; sourceType?: "module" | "script" }
+  ): ArrayBuffer;
+
+  /**
+   * Convert the provided value into bytecode. Doesn't work with all values.
+   */
+  export function fromValue(
+    value: any,
+    options?: { byteSwap?: boolean }
+  ): ArrayBuffer;
+
+  /**
+   * Convert the provided bytecode into a value.
+   */
+  export function toValue(bytecode: ArrayBuffer): any;
 }
 
-interface SymbolConstructor {
+declare module "quickjs:context" {
   /**
-   * A method that changes the result of using the `typeof` operator on the
-   * object. Called by the semantics of the typeof operator.
-   *
-   * Note that the following semantics will come into play when use of the
-   * `typeof` operator causes the engine to call a `Symbol.typeofValue` method
-   * on an object:
-   *
-   * - If the method returns any value other than one of the string values
-   *   which are normally the result of using the `typeof` operator, the engine
-   *   behaves as if no `Symbol.typeofValue` method was present on the object.
-   * - If an error is thrown from this method, or an error is thrown while
-   *   accessing this property, the error will be silently ignored, and the
-   *   engine will behave as if no `Symbol.typeofValue` method was present on
-   *   the object.
-   * - If this property is present on an object, but the value of that property
-   *   is not a function, the engine will not consider that value when
-   *   determining the result of the `typeof` operation (it'll ignore it).
+   * A separate global context (or 'realm') within which code can be executed.
    */
-  readonly typeofValue: unique symbol;
+  export class Context {
+    /**
+     * Create a new global context (or 'realm') within code can be executed.
+     *
+     * @param options Options for what globals/modules/etc to make available within the context.
+     *
+     * The following globals are always present, regardless of options:
+     *
+     * - Object
+     * - Function
+     * - Error
+     * - EvalError
+     * - RangeError
+     * - ReferenceError
+     * - SyntaxError
+     * - TypeError
+     * - URIError
+     * - InternalError
+     * - AggregateError
+     * - Array
+     * - parseInt
+     * - parseFloat
+     * - isNaN
+     * - isFinite
+     * - decodeURI
+     * - decodeURIComponent
+     * - encodeURI
+     * - encodeURIComponent
+     * - escape
+     * - unescape
+     * - Infinity
+     * - NaN
+     * - undefined
+     * - __date_clock
+     * - Number
+     * - Boolean
+     * - String
+     * - Math
+     * - Reflect
+     * - Symbol
+     * - eval (but it doesn't work unless the `eval` option is enabled)
+     * - globalThis
+     */
+    constructor(options?: {
+      /** Enables `Date`. Defaults to `true` */
+      date?: boolean;
+
+      /** Enables `eval`. Defaults to `true` */
+      eval?: boolean;
+
+      /** Enables `String.prototype.normalize`. Defaults to `true`. */
+      stringNormalize?: boolean;
+
+      /** Enables `RegExp`. Defaults to `true`. */
+      regExp?: boolean;
+
+      /** Enables `JSON`. Defaults to `true`. */
+      json?: boolean;
+
+      /** Enables `Proxy`. Defaults to `true`. */
+      proxy?: boolean;
+
+      /** Enables `Map` and `Set`. Defaults to `true`. */
+      mapSet?: boolean;
+
+      /**
+       * Enables:
+       *
+       * - ArrayBuffer
+       * - SharedArrayBuffer
+       * - Uint8ClampedArray
+       * - Int8Array
+       * - Uint8Array
+       * - Int16Array
+       * - Uint16Array
+       * - Int32Array
+       * - Uint32Array
+       * - BigInt64Array
+       * - BigUint64Array
+       * - Float32Array
+       * - Float64Array
+       * - DataView
+       *
+       * Defaults to `true`.
+       */
+      typedArrays?: boolean;
+
+      /**
+       * Enables:
+       *
+       * - Promise
+       * - async functions
+       * - async iterators
+       * - async generators
+       *
+       * Defaults to `true`.
+       */
+      promise?: boolean;
+
+      /** Enables `BigInt`. Defaults to `true`. */
+      bigint?: boolean;
+
+      /** Enables `BigFloat`. Defaults to `true`. */
+      bigfloat?: boolean;
+
+      /** Enables `BigDecimal`. Defaults to `true`. */
+      bigdecimal?: boolean;
+
+      /**
+       * Enables:
+       *
+       * - Operators
+       * - OperatorSet creation
+       * - operator overloading
+       *
+       * Defaults to `true`.
+       */
+      operators?: boolean;
+
+      /** Enables "use math". Defaults to `true`. */
+      useMath?: boolean;
+
+      /**
+       * Enables:
+       *
+       * - inspect
+       * - console
+       * - print
+       * - require (and require.resolve)
+       * - setTimeout
+       * - clearTimeout
+       * - setInterval
+       * - clearInterval
+       * - String.cooked
+       * - String.dedent
+       *
+       * Defaults to `true`.
+       *
+       * NOTE: The following globals, normally part of `js_std_add_helpers`, are NEVER added:
+       *
+       * - Module
+       * - scriptArgs
+       *
+       * If you need them in the new context, copy them over from your context's globalThis onto the child context's globalThis.
+       */
+      stdHelpers?: boolean;
+
+      /** Enable builtin modules. */
+      modules?: {
+        /** Enables the "quickjs:std" module. Defaults to `true`. */
+        "quickjs:std"?: boolean;
+        /** Enables the "quickjs:os" module. Defaults to `true`. */
+        "quickjs:os"?: boolean;
+        /** Enables the "quickjs:bytecode" module. Defaults to `true`. */
+        "quickjs:bytecode"?: boolean;
+        /** Enables the "quickjs:context" module. Defaults to `true`. */
+        "quickjs:context"?: boolean;
+      };
+    });
+
+    /**
+     * The `globalThis` object used by this context.
+     *
+     * You can add to or remove from it to change what is visible to the context.
+     */
+    globalThis: typeof globalThis;
+
+    /**
+     * Runs code within the context and returns the result.
+     *
+     * @param code The code to run.
+     */
+    eval(code: string): any;
+  }
 }
+
+declare const std: typeof import("quickjs:std");
+declare const os: typeof import("quickjs:os");