npm - yavascript - Versions diffs - 0.0.6 → 0.0.8 - Mend

yavascript 0.0.6 → 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +68 -19
package/bin/darwin-arm64/yavascript +0 -0
package/bin/darwin-x86_64/yavascript +0 -0
package/bin/linux-aarch64/yavascript +0 -0
package/bin/linux-amd64/yavascript +0 -0
package/bin/windows-x86_64/yavascript.exe +0 -0
package/lib/binary-path.js +28 -25
package/lib/cli.js +1 -1
package/lib/index.js +4 -2
package/package.json +1 -1
package/yavascript.d.ts +2178 -198
package/bin/darwin/yavascript +0 -0
package/bin/darwin-arm/yavascript +0 -0
package/bin/linux/yavascript +0 -0
package/bin/windows/yavascript.exe +0 -0

package/yavascript.d.ts CHANGED Viewed

@@ -3,6 +3,71 @@
 // YavaScript APIs
 // ---------------
 // ===============
+/** Info about the currently-running yavascript binary */
+declare const yavascript: {
+  /**
+   * The version of the currently-running yavascript binary.
+   *
+   * Will be something formatted like one of these:
+   * - "v0.0.7"
+   * - "v0.1.3-alpha"
+   * - "git-286a3a336849"
+   * - "git-286a3a336849-dirty"
+   *
+   * Or, more formally: either a "V" version string or a "GIT" version string:
+   * - "V" version strings start with the character 'v', followed by a semver
+   *   version string, optionally followed by the character '-' and any
+   *   arbitrary content afterwards.
+   * - "GIT" version strings start with the prefix "git-", followed by the
+   *   first 12 digits of a git commit SHA, optionally followed by the
+   *   character '-' and any arbitrary content afterwards.
+   */
+  version: string;
+  /** The processor architecture we're running on. */
+  arch: "x86_64" | "arm64";
+  /**
+   * The version of the ecma262 standard supported by the currently-running yavascript binary.
+   *
+   * Will always be in the format "ES" + a year. Is never lower than ES2020.
+   */
+  ecmaVersion: string;
+  /** The compilers yavascript uses internally to load files. */
+  compilers: {
+    js(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+    tsx(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+    ts(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+    jsx(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+    coffee(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+    autodetect(
+      code: string,
+      options?: { filename?: string; expression?: boolean }
+    ): string;
+  };
+};
 /**
  * An object representing the process's environment variables. You can read
  * from it to read environment variables, write into it to set environment
@@ -12,30 +77,111 @@
 declare const env: { [key: string]: string | undefined };
 /**
- * Return the contents of a directory, as absolute paths. `.` and `..` are
- * omitted.
+ * 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.
  *
- * Use the `relativePaths` option to get relative paths instead (relative to
- * the parent directory).
- */
-declare function ls(
-  dir?: string,
-  options?: { relativePaths?: boolean }
-): Array<string>;
-/**
- * Read a symlink.
+ * Flags `--like-this`, `--like_this`, or `--LIKE_THIS` get converted into
+ * property names `likeThis` on the returned flags object.
  *
- * Returns the target of the symlink, which may be absolute or relative.
+ * Flags like this: `-v` get converted into into property names like this: `v`
+ * on the returned flags object.
  *
- * Provides the same functionality as the unix binary of the same name.
+ * 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 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.
  */
-declare function readlink(path: string): string;
+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>;
+  };
+  /**
+   * 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;
+};
 /**
- * Read the contents of a file from disk, as a UTF-8 string.
+ * Read the contents of a file from disk.
  */
-declare function readFile(path: string): string;
+declare const readFile: {
+  /**
+   * Read the contents of a file from disk, as a UTF-8 string.
+   */
+  (path: string): string;
+  /**
+   * Read the contents of a file from disk, as a UTF-8 string.
+   */
+  (path: string, options: {}): string;
+  /**
+   * Read the contents of a file from disk, as a UTF-8 string.
+   */
+  (path: string, options: { binary: false }): string;
+  /**
+   * Read the contents of a file from disk, as an ArrayBuffer.
+   */
+  (path: string, options: { binary: true }): ArrayBuffer;
+};
 /**
  * Write the contents of a string or ArrayBuffer to a file.
@@ -131,42 +277,215 @@ declare type CopyOptions = {
  */
 declare function copy(from: string, to: string, options?: CopyOptions): void;
+/** An object that represents a filesystem path. */
+declare class Path {
+  /** The character used to separate path segments on this OS. */
+  static readonly OS_SEGMENT_SEPARATOR: "/" | "\\";
+  /**
+   * The character used to separate entries within the PATH environment
+   * variable on this OS.
+   */
+  static readonly OS_ENV_VAR_SEPARATOR: ":" | ";";
+  /** Split one or more path strings into an array of path segments. */
+  static splitToSegments(inputParts: Array<string> | string): Array<string>;
+  /**
+   * Search the provided path string or strings for a path separator character,
+   * and return it. If none is found, return `fallback`, which defaults to the
+   * OS's path segment separator.
+   */
+  static detectSeparator<Fallback extends string | null = string>(
+    input: Array<string> | string,
+    // @ts-ignore might be instantiated with a different subtype
+    fallback: Fallback = Path.OS_SEGMENT_SEPARATOR
+  ): string | Fallback;
+  /** Join together one or more paths. */
+  static join(...inputs: Array<string | Path | Array<string | Path>>): string;
+  /**
+   * Turns the input path(s) into an absolute path by resolving all `.` and `..`
+   * segments, using `pwd()` as a base dir to use when resolving leading `.` or
+   * `..` segments.
+   */
+  static resolve(
+    ...inputs: Array<string | Path | Array<string | Path>>
+  ): string;
+  /**
+   * Concatenates the input path(s) and then resolves all non-leading `.` and
+   * `..` segments.
+   */
+  static normalize(
+    ...inputs: Array<string | Path | Array<string | Path>>
+  ): string;
+  /**
+   * Return whether the provided path string is absolute; that is, whether it
+   * starts with either `/` or a drive letter (ie `C:`).
+   */
+  static isAbsolute(path: string): boolean;
+  /** A tagged template literal function that creates a `Path` object. */
+  static tag(
+    strings: TemplateStringsArray,
+    ...values: ReadonlyArray<string | Path | Array<string | Path>>
+  ): Path;
+  /**
+   * Returns a tagged template literal that creates a `Path` object. `dir` is
+   * used as a prefix for every `Path` object created.
+   */
+  static tagUsingBase(dir: string | Path): typeof Path.tag;
+  /**
+   * An array of the path segments that make up this path.
+   *
+   * For `/tmp/foo.txt`, it'd be `["", "tmp", "foo.txt"]`.
+   *
+   * For `C:\something\somewhere.txt`, it'd be `["C:", "something", "somewhere.txt"]`.
+   */
+  segments: Array<string>;
+  /**
+   * The path separator that should be used to turn this path into a string.
+   *
+   * Will be either `/` or `\`.
+   */
+  separator: string;
+  /** Create a new Path object using the provided input(s). */
+  constructor(...inputs: Array<string | Path | Array<string | Path>>);
+  /** Create a new Path object using the provided segments and separator. */
+  static from(segments: Array<string>, separator: string): Path;
+  /**
+   * Turn this path into an absolute path by resolving all `.` and `..`
+   * segments, using `from` as a base dir to use when resolving leading `.` or
+   * `..` segments.
+   *
+   * If `from` is unspecified, it defaults to `pwd()`.
+   */
+  resolve(from?: string | Path): Path;
+  /**
+   * Resolve all non-leading `.` and `..` segments in this path.
+   */
+  normalize(): Path;
+  /**
+   * Create a new path by appending another path's segments after this path's
+   * segments.
+   *
+   * The returned path will use this path's separator.
+   */
+  concat(other: string | Path | Array<string | Path>): Path;
+  /**
+   * Return whether this path is absolute; that is, whether it starts with
+   * either `/` or a drive letter (ie `C:`).
+   */
+  isAbsolute(): boolean;
+  /**
+   * Turn this path into a string by joining its segments using its separator.
+   */
+  toString(): string;
+}
 /**
- * Change the process's current working directory to the specified path.
+ * The absolute path to the current file (whether script or module).
  *
- * Provides the same functionality as the shell builtin of the same name.
+ * Behaves the same as in Node.js, except that it's present within ES modules.
  */
-declare function cd(path: string): void;
+declare const __filename: string;
 /**
- * Return the process's current working directory.
+ * The absolute path to the directory the current file is inside of.
  *
- * Provides the same functionality as the shell builtin of the same name.
+ * Behaves the same as in Node.js, except that it's present within ES modules.
  */
-declare function pwd(): string;
+declare const __dirname: string;
 /**
- * Get the absolute path given a relative path. Symlinks are also resolved.
- *
- * The path's target file/directory must exist.
+ * Return the last component of a path string.
  *
  * Provides the same functionality as the unix binary of the same name.
  */
-declare function realpath(path: string): string;
+declare function basename(path: string | Path): string;
 /**
- * Removes the final component from a path string.
+ * Read the contents of one of more files from disk as one UTF-8 string,
+ * print that string to stdout, then return it.
+ */
+declare function cat(...paths: Array<string | Path>): string;
+/**
+ * Change the process's current working directory to the specified path. If no
+ * path is specified, moves to the user's home directory.
  *
- * Provides the same functionality as the unix binary of the same name.
+ * Provides the same functionality as the shell builtin of the same name.
  */
-declare function dirname(path: string): string;
+declare function cd(path?: string | Path): void;
+/** A string representing who a permission applies to. */
+declare type ChmodPermissionsWho =
+  | "user"
+  | "group"
+  | "others"
+  | "all"
+  | "u"
+  | "g"
+  | "o"
+  | "a"
+  | "ug"
+  | "go"
+  | "uo";
+/** A string representing the access level for the given permission. */
+declare type ChmodPermissionsWhat =
+  | "read"
+  | "write"
+  | "execute"
+  | "readwrite"
+  | "none"
+  | "full"
+  | "r"
+  | "w"
+  | "x"
+  | "rw"
+  | "rx"
+  | "wx"
+  | "rwx";
 /**
- * Return the last component of a path string.
+ * Set the permission bits for the specified file.
+ *
+ * @param permissions The permission bits to set. This can be a number, a string containing an octal number, or an object.
+ * @param path The path to the file.
+ */
+declare function chmod(
+  permissions:
+    | number
+    | string
+    | Record<ChmodPermissionsWho, ChmodPermissionsWhat>,
+  path: string | Path
+): void;
+/**
+ * Removes the final component from a path string.
  *
  * Provides the same functionality as the unix binary of the same name.
  */
-declare function basename(path: string): string;
+declare function dirname(path: string | Path): string;
+/**
+ * Print one or more values to stdout.
+ */
+declare const echo: typeof console.log;
 /**
  * Returns the file extension of the file at a given path.
@@ -176,76 +495,60 @@ declare function basename(path: string): string;
  * Pass `{ full: true }` to get compound extensions, eg `.d.ts` or `.test.js` instead of just `.ts`/`.js`.
  */
 declare function extname(
-  pathOrFilename: string,
+  pathOrFilename: string | Path,
   options?: { full?: boolean }
 ): string;
 /**
- * A namespace object providing several path-string-related APIs.
+ * Return the contents of a directory, as absolute paths. `.` and `..` are
+ * omitted.
+ *
+ * Use the `relativePaths` option to get relative paths instead (relative to
+ * the parent directory).
  */
-declare const paths: {
-  /**
-   * The separator character the host operating system uses between path
-   * components, ie. the slashes in a filepath. On windows, it's a backslash, and
-   * on all other OSes, it's a forward slash.
-   */
-  OS_PATH_SEPARATOR: "/" | "\\";
-  /**
-   * Split a path string (or array of path strings) on / or \\, returning an
-   * Array of strings.
-   *
-   * Trailing slashes and duplicate path separators will be removed.
-   *
-   * If the path starts with `/`, the first string in the Array will be empty.
-   */
-  split(path: string | Array<string>): Array<string>;
-  /**
-   * Detect which path separator is present in the given path or array of
-   * paths: `\` or `/`.
-   *
-   * If neither is present, `/` will be returned.
-   */
-  detectSeparator(input: string | Array<string>): string;
+declare function ls(
+  dir?: string | Path,
+  options?: { relativePaths?: boolean }
+): Array<string>;
-  /**
-   * Create a path string from one or more path or path component strings.
-   * {@link paths.OS_PATH_SEPARATOR} will be used to combine parts.
-   *
-   * This function does not resolve `..` or `.`. Use {@link paths.resolve} for that.
-   */
-  join(...parts: Array<string>): string;
+/**
+ * Print data to stdout using C-style format specifiers.
+ */
+declare function printf(format: string, ...args: Array<any>): void;
-  /**
-   * Resolves all `..` and `.` components in a path, returning an absolute
-   * path.
-   *
-   * Use `from` to specify where leading `.` or `..` characters should be
-   * resolved relative to. If unspecified, it defaults to `pwd()`.
-   */
-  resolve(path: string, from?: string): string;
+/**
+ * Return the process's current working directory.
+ *
+ * Provides the same functionality as the shell builtin of the same name.
+ */
+declare function pwd(): string;
-  /**
-   * Returns whether the path starts with either a leading slash or a windows
-   * drive letter.
-   */
-  isAbsolute(path: string): boolean;
-};
+/**
+ * Read a symlink.
+ *
+ * Returns the target of the symlink, which may be absolute or relative.
+ *
+ * Provides the same functionality as the unix binary of the same name.
+ */
+declare function readlink(path: string | Path): string;
 /**
- * The absolute path to the current file (whether script or module).
+ * Get the absolute path given a relative path. Symlinks are also resolved.
  *
- * Behaves the same as in Node.js, except that it's present within ES modules.
+ * The path's target file/directory must exist.
+ *
+ * Provides the same functionality as the unix binary of the same name.
  */
-declare const __filename: string;
+declare function realpath(path: string | Path): string;
 /**
- * The absolute path to the directory the current file is inside of.
+ * If the file at `path` exists, update its creation/modification timestamps.
  *
- * Behaves the same as in Node.js, except that it's present within ES modules.
+ * Otherwise, create an empty file at that path.
+ *
+ * @param path The target path for the file.
  */
-declare const __dirname: string;
+declare function touch(path: string | Path): void;
 declare type BaseExecOptions = {
   /** Sets the current working directory for the child process. */
@@ -428,11 +731,6 @@ declare function glob(
   options?: GlobOptions
 ): Array<string>;
-/**
- * Print one or more values to stdout.
- */
-declare const echo: typeof console.log;
 /**
  * Remove ANSI control characters from a string.
  */
@@ -509,17 +807,272 @@ declare function hidden(input: string | number): string;
 /** Wrap a string with the ANSI control characters that will make it print with a horizontal line through its center. */
 declare function strikethrough(input: string | number): string;
-declare type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Uint8ClampedArray
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Float32Array
-  | Float64Array;
-declare type TypedArrayConstructor =
+/** Split `str` on newline and then return lines matching `pattern`. */
+declare const grepString: {
+  /** Split `str` on newline and then return lines matching `pattern`. */
+  (str: string, pattern: string | RegExp): Array<string>;
+  /** Split `str` on newline and then return lines matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: false }
+  ): Array<string>;
+  /** Split `str` on newline and then return lines NOT matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: true }
+  ): Array<string>;
+  /** Split `str` on newline and then return lines matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { details: false }
+  ): Array<string>;
+  /** Split `str` on newline and then return lines matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: false; details: false }
+  ): Array<string>;
+  /** Split `str` on newline and then return lines NOT matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: true; details: false }
+  ): Array<string>;
+  /** Split `str` on newline and then return info about lines matching `pattern`. */
+  (str: string, pattern: string | RegExp, options: { details: true }): Array<{
+    lineNumber: number;
+    lineContent: string;
+    matches: RegExpMatchArray;
+  }>;
+  /** Split `str` on newline and then return info about lines matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: false; details: true }
+  ): Array<string>;
+  /** Split `str` on newline and then return info about lines NOT matching `pattern`. */
+  (
+    str: string,
+    pattern: string | RegExp,
+    options: { inverse: true; details: true }
+  ): Array<string>;
+};
+/** 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>;
+  /** Read the content at `path`, split it on newline,  and then return lines matching `pattern`. */
+  (
+    path: string,
+    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,
+    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,
+    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,
+    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,
+    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<{
+    lineNumber: number;
+    lineContent: string;
+    matches: RegExpMatchArray;
+  }>;
+  /** Read the content at `path`, split it on newline,  and then return info about lines matching `pattern`. */
+  (
+    path: string,
+    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,
+    pattern: string | RegExp,
+    options: { inverse: true; details: true }
+  ): Array<string>;
+};
+interface String {
+  // Same as grepString but without the first argument.
+  grep: {
+    /** Split the string on newline and then return lines matching `pattern`. */
+    (pattern: string | RegExp): Array<string>;
+    /** Split the string on newline and then return lines matching `pattern`. */
+    (pattern: string | RegExp, options: { inverse: false }): Array<string>;
+    /** Split the string on newline and then return lines NOT matching `pattern`. */
+    (pattern: string | RegExp, options: { inverse: true }): Array<string>;
+    /** Split the string on newline and then return lines matching `pattern`. */
+    (pattern: string | RegExp, options: { details: false }): Array<string>;
+    /** Split the string on newline and then return lines matching `pattern`. */
+    (
+      pattern: string | RegExp,
+      options: { inverse: false; details: false }
+    ): Array<string>;
+    /** Split the string on newline and then return lines NOT matching `pattern`. */
+    (
+      pattern: string | RegExp,
+      options: { inverse: true; details: false }
+    ): Array<string>;
+    /** Split the string on newline and then return info about lines matching `pattern`. */
+    (pattern: string | RegExp, options: { details: true }): Array<{
+      lineNumber: number;
+      lineContent: string;
+      matches: RegExpMatchArray;
+    }>;
+    /** Split the string on newline and then return info about lines matching `pattern`. */
+    (
+      pattern: string | RegExp,
+      options: { inverse: false; details: true }
+    ): Array<string>;
+    /** Split the string on newline and then return info about lines NOT matching `pattern`. */
+    (
+      pattern: string | RegExp,
+      options: { inverse: true; details: true }
+    ): Array<string>;
+  };
+}
+declare type TypeValidator<T> = (value: any) => value is T;
+declare type CoerceToTypeValidator<V extends CoerceableToTypeValidator> =
+  V extends StringConstructor
+    ? TypeValidator<string>
+    : V extends NumberConstructor
+    ? TypeValidator<number>
+    : V extends BooleanConstructor
+    ? TypeValidator<boolean>
+    : V extends BigIntConstructor
+    ? TypeValidator<BigInt>
+    : V extends SymbolConstructor
+    ? TypeValidator<Symbol>
+    : V extends RegExpConstructor
+    ? TypeValidator<RegExp>
+    : V extends ArrayConstructor
+    ? TypeValidator<Array<unknown>>
+    : V extends SetConstructor
+    ? TypeValidator<Set<unknown>>
+    : V extends MapConstructor
+    ? TypeValidator<Map<unknown, unknown>>
+    : V extends ObjectConstructor
+    ? TypeValidator<{
+        [key: string | number | symbol]: unknown;
+      }>
+    : V extends DateConstructor
+    ? TypeValidator<Date>
+    : V extends FunctionConstructor
+    ? TypeValidator<Function>
+    : V extends ArrayBufferConstructor
+    ? TypeValidator<ArrayBuffer>
+    : V extends SharedArrayBufferConstructor
+    ? TypeValidator<SharedArrayBuffer>
+    : V extends DataViewConstructor
+    ? TypeValidator<DataView>
+    : V extends Int8ArrayConstructor
+    ? TypeValidator<Int8Array>
+    : V extends Uint8ArrayConstructor
+    ? TypeValidator<Uint8Array>
+    : V extends Uint8ClampedArrayConstructor
+    ? TypeValidator<Uint8ClampedArray>
+    : V extends Int16ArrayConstructor
+    ? TypeValidator<Int16Array>
+    : V extends Uint16ArrayConstructor
+    ? TypeValidator<Uint16Array>
+    : V extends Int32ArrayConstructor
+    ? TypeValidator<Int32Array>
+    : V extends Uint32ArrayConstructor
+    ? TypeValidator<Uint32Array>
+    : V extends Float32ArrayConstructor
+    ? TypeValidator<Float32Array>
+    : V extends Float64ArrayConstructor
+    ? TypeValidator<Float64Array>
+    : V extends RegExp
+    ? TypeValidator<string>
+    : V extends {}
+    ? TypeValidator<{
+        [key in keyof V]: CoerceToTypeValidator<V[key]>;
+      }>
+    : V extends []
+    ? TypeValidator<[]>
+    : V extends [any]
+    ? TypeValidator<Array<CoerceToTypeValidator<V[0]>>>
+    : V extends Array<any>
+    ? TypeValidator<Array<unknown>>
+    : V extends {
+        new (...args: any): any;
+      }
+    ? TypeValidator<InstanceType<V>>
+    : TypeValidator<V>;
+declare type CoerceableToTypeValidator =
+  | boolean
+  | number
+  | string
+  | bigint
+  | undefined
+  | null
+  | RegExp
+  | StringConstructor
+  | NumberConstructor
+  | BooleanConstructor
+  | BigIntConstructor
+  | SymbolConstructor
+  | RegExpConstructor
+  | ArrayConstructor
+  | SetConstructor
+  | MapConstructor
+  | ObjectConstructor
+  | DateConstructor
+  | FunctionConstructor
+  | ArrayBufferConstructor
+  | SharedArrayBufferConstructor
+  | DataViewConstructor
   | Int8ArrayConstructor
   | Uint8ArrayConstructor
   | Uint8ClampedArrayConstructor
@@ -528,89 +1081,1283 @@ declare type TypedArrayConstructor =
   | Int32ArrayConstructor
   | Uint32ArrayConstructor
   | Float32ArrayConstructor
-  | Float64ArrayConstructor;
+  | Float64ArrayConstructor
+  | {}
+  | []
+  | [any]
+  | Array<any>
+  | {
+      new (...args: any): any;
+    };
-declare const is: {
-  string(value: any): value is string;
-  String(value: any): value is string;
-  number(value: any): value is number;
-  Number(value: any): value is number;
-  boolean(value: any): value is boolean;
-  Boolean(value: any): value is boolean;
-  bigint(value: any): value is bigint;
-  BigInt(value: any): value is BigInt;
-  symbol(value: any): value is symbol;
-  Symbol(value: any): value is symbol;
-  null(value: any): value is null;
-  undefined(value: any): value is undefined;
-  void(value: any): value is null | undefined;
-  object(value: any): value is {
-    [key: string]: unknown;
-    [key: number]: unknown;
-    [key: symbol]: unknown;
+declare type UnwrapTypeFromCoerceableOrValidator<
+  V extends CoerceableToTypeValidator | TypeValidator<any> | unknown
+> = V extends TypeValidator<infer T>
+  ? T
+  : V extends CoerceableToTypeValidator
+  ? CoerceToTypeValidator<V> extends TypeValidator<infer T>
+    ? T
+    : never
+  : unknown;
+declare const types: {
+  // basic types
+  any: TypeValidator<any>;
+  unknown: TypeValidator<unknown>;
+  anyObject: TypeValidator<{
+    [key: string | number | symbol]: any;
+  }>;
+  unknownObject: TypeValidator<{}>;
+  object: TypeValidator<{}>;
+  Object: TypeValidator<{}>;
+  arrayOfAny: TypeValidator<Array<any>>;
+  arrayOfUnknown: TypeValidator<Array<unknown>>;
+  array: TypeValidator<Array<unknown>>;
+  Array: TypeValidator<unknown[]>;
+  anyArray: TypeValidator<Array<any>>;
+  boolean: TypeValidator<boolean>;
+  Boolean: TypeValidator<boolean>;
+  string: TypeValidator<string>;
+  String: TypeValidator<string>;
+  null: TypeValidator<null>;
+  undefined: TypeValidator<undefined>;
+  nullish: TypeValidator<null | undefined>;
+  void: TypeValidator<null | undefined>;
+  numberIncludingNanAndInfinities: TypeValidator<number>;
+  number: TypeValidator<number>;
+  Number: TypeValidator<number>;
+  NaN: TypeValidator<number>;
+  Infinity: TypeValidator<number>;
+  NegativeInfinity: TypeValidator<number>;
+  integer: TypeValidator<number>;
+  bigint: TypeValidator<bigint>;
+  BigInt: TypeValidator<bigint>;
+  never: TypeValidator<never>;
+  anyFunction: TypeValidator<(...args: any) => any>;
+  unknownFunction: TypeValidator<(...args: Array<unknown>) => unknown>;
+  Function: TypeValidator<(...args: Array<unknown>) => unknown>;
+  false: TypeValidator<false>;
+  true: TypeValidator<true>;
+  falsy: TypeValidator<false | null | undefined | "" | 0>;
+  truthy: <T>(target: false | "" | 0 | T | null | undefined) => target is T;
+  nonNullOrUndefined: <T>(target: T | null | undefined) => target is T;
+  Error: TypeValidator<Error>;
+  Symbol: TypeValidator<symbol>;
+  symbol: TypeValidator<symbol>;
+  RegExp: TypeValidator<RegExp>;
+  Date: TypeValidator<Date>;
+  anyMap: TypeValidator<Map<any, any>>;
+  unknownMap: TypeValidator<Map<unknown, unknown>>;
+  map: TypeValidator<Map<unknown, unknown>>;
+  Map: TypeValidator<Map<unknown, unknown>>;
+  anySet: TypeValidator<Set<any>>;
+  unknownSet: TypeValidator<Set<unknown>>;
+  set: TypeValidator<Set<unknown>>;
+  Set: TypeValidator<Set<unknown>>;
+  ArrayBuffer: TypeValidator<ArrayBuffer>;
+  SharedArrayBuffer: TypeValidator<SharedArrayBuffer>;
+  DataView: TypeValidator<DataView>;
+  TypedArray: TypeValidator<
+    | Int8Array
+    | Uint8Array
+    | Uint8ClampedArray
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Float32Array
+    | Float64Array
+  >;
+  Int8Array: TypeValidator<Int8Array>;
+  Uint8Array: TypeValidator<Uint8Array>;
+  Uint8ClampedArray: TypeValidator<Uint8ClampedArray>;
+  Int16Array: TypeValidator<Int16Array>;
+  Uint16Array: TypeValidator<Uint16Array>;
+  Int32Array: TypeValidator<Int32Array>;
+  Uint32Array: TypeValidator<Uint32Array>;
+  Float32Array: TypeValidator<Float32Array>;
+  Float64Array: TypeValidator<Float64Array>;
+  // type constructors
+  exactString<T extends string>(str: T): TypeValidator<T>;
+  exactNumber<T extends number>(num: T): TypeValidator<T>;
+  exactBigInt<T extends bigint>(num: T): TypeValidator<T>;
+  exactSymbol<T extends symbol>(sym: T): TypeValidator<T>;
+  hasClassName<Name extends string>(
+    name: Name
+  ): TypeValidator<{
+    constructor: Function & {
+      name: Name;
+    };
+  }>;
+  hasToStringTag(name: string): TypeValidator<any>;
+  instanceOf<
+    Klass extends Function & {
+      prototype: any;
+    }
+  >(
+    klass: Klass
+  ): TypeValidator<Klass["prototype"]>;
+  stringMatching(regexp: RegExp): TypeValidator<string>;
+  symbolFor(key: string): TypeValidator<symbol>;
+  arrayOf<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
+    typeValidator: T
+  ): TypeValidator<Array<UnwrapTypeFromCoerceableOrValidator<T>>>;
+  intersection: {
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth> &
+        UnwrapTypeFromCoerceableOrValidator<Ninth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth,
+      tenth: Tenth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth> &
+        UnwrapTypeFromCoerceableOrValidator<Ninth> &
+        UnwrapTypeFromCoerceableOrValidator<Tenth>
+    >;
   };
-  Object(value: any): value is {
-    [key: string]: unknown;
-    [key: number]: unknown;
-    [key: symbol]: unknown;
+  and: {
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth> &
+        UnwrapTypeFromCoerceableOrValidator<Ninth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth,
+      tenth: Tenth
+    ): TypeValidator<
+      UnwrapTypeFromCoerceableOrValidator<First> &
+        UnwrapTypeFromCoerceableOrValidator<Second> &
+        UnwrapTypeFromCoerceableOrValidator<Third> &
+        UnwrapTypeFromCoerceableOrValidator<Fourth> &
+        UnwrapTypeFromCoerceableOrValidator<Fifth> &
+        UnwrapTypeFromCoerceableOrValidator<Sixth> &
+        UnwrapTypeFromCoerceableOrValidator<Seventh> &
+        UnwrapTypeFromCoerceableOrValidator<Eighth> &
+        UnwrapTypeFromCoerceableOrValidator<Ninth> &
+        UnwrapTypeFromCoerceableOrValidator<Tenth>
+    >;
   };
-  Array(value: any): value is unknown[];
-  function(value: any): value is Function & {
-    [key: string]: unknown;
-    [key: number]: unknown;
-    [key: symbol]: unknown;
+  union: {
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+      | UnwrapTypeFromCoerceableOrValidator<Ninth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth,
+      tenth: Tenth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+      | UnwrapTypeFromCoerceableOrValidator<Ninth>
+      | UnwrapTypeFromCoerceableOrValidator<Tenth>
+    >;
   };
-  Function(value: any): value is Function & {
-    [key: string]: unknown;
-    [key: number]: unknown;
-    [key: symbol]: unknown;
+  or: {
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+      | UnwrapTypeFromCoerceableOrValidator<Ninth>
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth,
+      tenth: Tenth
+    ): TypeValidator<
+      | UnwrapTypeFromCoerceableOrValidator<First>
+      | UnwrapTypeFromCoerceableOrValidator<Second>
+      | UnwrapTypeFromCoerceableOrValidator<Third>
+      | UnwrapTypeFromCoerceableOrValidator<Fourth>
+      | UnwrapTypeFromCoerceableOrValidator<Fifth>
+      | UnwrapTypeFromCoerceableOrValidator<Sixth>
+      | UnwrapTypeFromCoerceableOrValidator<Seventh>
+      | UnwrapTypeFromCoerceableOrValidator<Eighth>
+      | UnwrapTypeFromCoerceableOrValidator<Ninth>
+      | UnwrapTypeFromCoerceableOrValidator<Tenth>
+    >;
   };
-  tagged(value: any, tag: string): boolean;
-  instanceOf<T>(value: any, klass: new (...args: any) => T): value is T;
-  Error(value: any): value is Error;
-  Infinity(value: any): value is number;
-  NegativeInfinity(value: any): value is number;
-  NaN(value: any): value is number;
-  Date(value: any): value is Date;
-  RegExp(value: any): value is RegExp;
-  Map(value: any): value is Map<unknown, unknown>;
-  Set(value: any): value is Set<unknown>;
-  WeakMap(value: any): value is Map<unknown, unknown>;
-  WeakSet(value: any): value is Set<unknown>;
-  ArrayBuffer(value: any): value is ArrayBuffer;
-  SharedArrayBuffer(value: any): value is SharedArrayBuffer;
-  DataView(value: any): value is DataView;
-  TypedArray(value: any): value is TypedArray;
-  Int8Array(value: any): value is Int8Array;
-  Uint8Array(value: any): value is Uint8Array;
-  Uint8ClampedArray(value: any): value is Uint8ClampedArray;
-  Int16Array(value: any): value is Int16Array;
-  Uint16Array(value: any): value is Uint16Array;
-  Int32Array(value: any): value is Int32Array;
-  Uint32Array(value: any): value is Uint32Array;
-  Float32Array(value: any): value is Float32Array;
-  Float64Array(value: any): value is Float64Array;
-  Promise(value: any): value is Promise<unknown>;
-  Generator(value: any): value is Generator<unknown, any, unknown>;
-  GeneratorFunction(value: any): value is GeneratorFunction;
-  AsyncFunction(value: any): value is ((...args: any) => Promise<unknown>) & {
-    [key: string]: unknown;
-    [key: number]: unknown;
-    [key: symbol]: unknown;
+  mapOf<
+    K extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+    V extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+  >(
+    keyType: K,
+    valueType: V
+  ): TypeValidator<
+    Map<
+      UnwrapTypeFromCoerceableOrValidator<K>,
+      UnwrapTypeFromCoerceableOrValidator<V>
+    >
+  >;
+  setOf<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
+    itemType: T
+  ): TypeValidator<Set<UnwrapTypeFromCoerceableOrValidator<T>>>;
+  maybe<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
+    itemType: T
+  ): TypeValidator<UnwrapTypeFromCoerceableOrValidator<T> | undefined | null>;
+  objectWithProperties<
+    T extends {
+      [key: string | number | symbol]:
+        | TypeValidator<any>
+        | CoerceableToTypeValidator
+        | unknown;
+    }
+  >(
+    properties: T
+  ): TypeValidator<{
+    [key in keyof T]: UnwrapTypeFromCoerceableOrValidator<T[key]>;
+  }>;
+  objectWithOnlyTheseProperties<
+    T extends {
+      [key: string | number | symbol]:
+        | TypeValidator<any>
+        | CoerceableToTypeValidator
+        | unknown;
+    }
+  >(
+    properties: T
+  ): TypeValidator<{
+    [key in keyof T]: UnwrapTypeFromCoerceableOrValidator<T[key]>;
+  }>;
+  mappingObjectOf<
+    Values extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+    Keys extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+  >(
+    keyType: Keys,
+    valueType: Values
+  ): TypeValidator<
+    Record<
+      UnwrapTypeFromCoerceableOrValidator<Keys> extends string | number | symbol
+        ? UnwrapTypeFromCoerceableOrValidator<Keys>
+        : never,
+      UnwrapTypeFromCoerceableOrValidator<Values>
+    >
+  >;
+  record<
+    Values extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+    Keys extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+  >(
+    keyType: Keys,
+    valueType: Values
+  ): TypeValidator<
+    Record<
+      UnwrapTypeFromCoerceableOrValidator<Keys> extends string | number | symbol
+        ? UnwrapTypeFromCoerceableOrValidator<Keys>
+        : never,
+      UnwrapTypeFromCoerceableOrValidator<Values>
+    >
+  >;
+  partialObjectWithProperties<
+    T extends {
+      [key: string | number | symbol]:
+        | TypeValidator<any>
+        | CoerceableToTypeValidator
+        | unknown;
+    }
+  >(
+    properties: T
+  ): TypeValidator<{
+    [key in keyof T]:
+      | UnwrapTypeFromCoerceableOrValidator<T[key]>
+      | null
+      | undefined;
+  }>;
+  tuple: {
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>,
+        UnwrapTypeFromCoerceableOrValidator<Sixth>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>,
+        UnwrapTypeFromCoerceableOrValidator<Sixth>,
+        UnwrapTypeFromCoerceableOrValidator<Seventh>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>,
+        UnwrapTypeFromCoerceableOrValidator<Sixth>,
+        UnwrapTypeFromCoerceableOrValidator<Seventh>,
+        UnwrapTypeFromCoerceableOrValidator<Eighth>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>,
+        UnwrapTypeFromCoerceableOrValidator<Sixth>,
+        UnwrapTypeFromCoerceableOrValidator<Seventh>,
+        UnwrapTypeFromCoerceableOrValidator<Eighth>,
+        UnwrapTypeFromCoerceableOrValidator<Ninth>
+      ]
+    >;
+    <
+      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
+      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown
+    >(
+      first: First,
+      second: Second,
+      third: Third,
+      fourth: Fourth,
+      fifth: Fifth,
+      sixth: Sixth,
+      seventh: Seventh,
+      eighth: Eighth,
+      ninth: Ninth,
+      tenth: Tenth
+    ): TypeValidator<
+      [
+        UnwrapTypeFromCoerceableOrValidator<First>,
+        UnwrapTypeFromCoerceableOrValidator<Second>,
+        UnwrapTypeFromCoerceableOrValidator<Third>,
+        UnwrapTypeFromCoerceableOrValidator<Fourth>,
+        UnwrapTypeFromCoerceableOrValidator<Fifth>,
+        UnwrapTypeFromCoerceableOrValidator<Sixth>,
+        UnwrapTypeFromCoerceableOrValidator<Seventh>,
+        UnwrapTypeFromCoerceableOrValidator<Eighth>,
+        UnwrapTypeFromCoerceableOrValidator<Ninth>,
+        UnwrapTypeFromCoerceableOrValidator<Tenth>
+      ]
+    >;
   };
-  AsyncGenerator(value: any): value is AsyncGenerator<unknown, any, unknown>;
-  AsyncGeneratorFunction(value: any): value is AsyncGeneratorFunction;
-  FILE(value: any): value is FILE;
+  coerce: <V extends CoerceableToTypeValidator | TypeValidator<any> | unknown>(
+    value: V
+  ) => TypeValidator<UnwrapTypeFromCoerceableOrValidator<V>>;
+  FILE: TypeValidator<FILE>;
+  Module: TypeValidator<{ [key: string]: unknown }>;
+  Path: TypeValidator<Path>;
   JSX: {
-    /** Returns whether `value` is a JSX Element object as created via JSX syntax. */
-    Element(value: any): value is JSX.Element;
-    /** Returns whether `value` is a JSX fragment element as created via JSX syntax. */
-    Fragment(value: any): value is JSX.Fragment;
+    unknownElement: TypeValidator<
+      JSX.Element<{ [key: string | symbol | number]: unknown }, unknown>
+    >;
+    anyElement: TypeValidator<JSX.Element<any, any>>;
+    Element: TypeValidator<
+      JSX.Element<{ [key: string | symbol | number]: unknown }, unknown>
+    >;
+    Fragment: TypeValidator<JSX.Fragment>;
   };
 };
+declare const is: <T extends TypeValidator<any> | CoerceableToTypeValidator>(
+  value: any,
+  type: T
+) => value is UnwrapTypeFromCoerceableOrValidator<T>;
+declare const assert: {
+  /**
+   * Throws an error if `value` is not truthy.
+   *
+   * @param value - The value to test for truthiness
+   * @param message - An optional error message to use. If unspecified, "Assertion failed" will be used.
+   */
+  <ValueType>(
+    value: ValueType,
+    message?: string
+  ): asserts value is ValueType extends null | undefined | false | 0 | ""
+    ? never
+    : ValueType;
+  /**
+   * Throws an error if `value` is not of the type `type`.
+   *
+   * `type` should be either a {@link TypeValidator}, or a value which can be coerced into one via {@link types.coerce}.
+   */
+  type: <T extends TypeValidator<any> | CoerceableToTypeValidator>(
+    value: any,
+    type: T,
+    optionalMessage?: string
+  ) => asserts value is UnwrapTypeFromCoerceableOrValidator<T>;
+};
 /**
  * The data source of a pipe operation; either an in-memory object, or a
  * file stream.
@@ -647,7 +2394,7 @@ declare type PipeSource =
  * - Use `intoNew` to put data into a new object.
  * - Use `path` or `fd` to create a new file handle and put data into it.
  */
-export type PipeDestination =
+declare type PipeDestination =
   | ArrayBuffer
   | SharedArrayBuffer
   | DataView
@@ -690,6 +2437,25 @@ declare function pipe<Dest extends PipeDestination>(
     : never;
 };
+/**
+ * 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;
 /**
  * Returns the absolute path to the root folder of the git/hg repo.
  *
@@ -738,10 +2504,10 @@ declare namespace JSX {
    * expression.
    *
    * Note that if you change this, you need to verify that the following
-   * expression always evaluates to `true` (by changing {@link is.JSX.Element}
-   * and {@link is.JSX.Fragment}):
+   * expression always evaluates to `true` (by changing {@link types.JSX.Element}
+   * and {@link types.JSX.Fragment}):
    * ```jsx
-   * is.JSX.Element(<a />) && is.JSX.Fragment(<></>)
+   * types.JSX.Element(<a />) && types.JSX.Fragment(<></>)
    * ```
    *
    * Failure to uphold this guarantee indicates a bug.
@@ -758,10 +2524,10 @@ declare namespace JSX {
    * expression.
    *
    * Note that if you change this, you need to verify that the following
-   * expression always evaluates to `true` (by changing {@link is.JSX.Element}
-   * and {@link is.JSX.Fragment}):
+   * expression always evaluates to `true` (by changing {@link types.JSX.Element}
+   * and {@link types.JSX.Fragment}):
    * ```jsx
-   * is.JSX.Element(<a />) && is.JSX.Fragment(<></>)
+   * types.JSX.Element(<a />) && types.JSX.Fragment(<></>)
    * ```
    *
    * Failure to uphold this guarantee indicates a bug.
@@ -825,6 +2591,51 @@ declare namespace JSX {
   };
 }
+declare const YAML: {
+  /**
+   * Parse a YAML document (`input`) into a JSON-compatible value.
+   */
+  parse(
+    input: string,
+    reviver?: (this: any, key: string, value: any) => any
+  ): any;
+  /**
+   * Convert a JSON-compatible value into a YAML document.
+   */
+  stringify(
+    input: any,
+    replacer?:
+      | ((this: any, key: string, value: any) => any)
+      | (number | string)[]
+      | null,
+    indent?: number
+  ): string;
+};
+declare const CSV: {
+  /**
+   * Parse a CSV string into an Array of Arrays of strings.
+   *
+   * The outer array holds the rows, and the inner arrays hold the items in
+   * each row.
+   */
+  parse(input: string): Array<Array<string>>;
+  /**
+   * Convert an Array of Arrays of strings into a CSV string.
+   *
+   * The outer array holds the rows, and the inner arrays hold the items in
+   * each row.
+   */
+  stringify(input: Array<Array<string>>): string;
+};
+interface RegExpConstructor {
+  /** See https://github.com/tc39/proposal-regex-escaping */
+  escape(str: any): string;
+}
 // prettier-ignore
 /** Any integer in the range [0, 255]. */
 declare type byte =
@@ -852,6 +2663,27 @@ declare var boolean: BooleanConstructor;
 declare var bigint: BigIntConstructor;
 declare var symbol: SymbolConstructor;
+declare type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array;
+declare type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Uint8ArrayConstructor
+  | Uint8ClampedArrayConstructor
+  | Int16ArrayConstructor
+  | Uint16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint32ArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor;
 // ==========================================
 // ------------------------------------------
 // QuickJS APIs, which YavaScript builds upon
@@ -915,7 +2747,7 @@ declare interface FILE {
   close(): void;
   /** Outputs the string with the UTF-8 encoding. */
-  puts(str: string): void;
+  puts(...strings: Array<string>): void;
   /**
    * Formatted printf.
@@ -974,7 +2806,7 @@ declare interface FILE {
   putByte(value: number): void;
 }
-declare module "std" {
+declare module "quickjs:std" {
   /**
    * Exit the process with the provided status code.
    *
@@ -1015,6 +2847,15 @@ declare module "std" {
     basename?: string
   ): { [key: string]: any };
+  /**
+   * Return the resolved path to a module.
+   *
+   * @param filename - The relative or absolute path to the file to import. Relative paths are resolved relative to the file calling `importModule`, or `basename` if present.
+   * @param basename - If present and `filename` is a relative path, `filename` will be resolved relative to this basename.
+   * @returns The resolved module path.
+   */
+  export function resolveModule(filename: string, basename?: string): string;
   /**
    * Load the file `filename` and return it as a string assuming UTF-8 encoding.
    *
@@ -1029,7 +2870,7 @@ declare module "std" {
    *
    * @param stackLevels - How many levels up the stack to search for a filename. Defaults to 0, which uses the current stack frame.
    */
-  export function getFileNameFromStack(stackLevels: number): string;
+  export function getFileNameFromStack(stackLevels?: number): string;
   /**
    * Return a boolean indicating whether the provided value is a FILE object.
@@ -1078,7 +2919,7 @@ declare module "std" {
   export function tmpfile(): FILE;
   /** Equivalent to `std.out.puts(str)`. */
-  export function puts(str: string): void;
+  export function puts(...strings: Array<string>): void;
   /** Equivalent to `std.out.printf(fmt, ...args)` */
   export function printf(fmt: string, ...args: Array<any>): void;
@@ -1240,7 +3081,7 @@ declare module "std" {
   export function parseExtJSON(str: string): any;
 }
-declare module "os" {
+declare module "quickjs:os" {
   /**
    * Open a file handle. Returns a number; the file descriptor.
    *
@@ -1533,16 +3374,19 @@ declare module "os" {
   /** Sleep for `delay_ms` milliseconds. */
   export function sleep(delay_ms: number): void;
-  export type Timer = number & { __is: "Timer" };
+  export type OSTimer = { [Symbol.toStringTag]: "OSTimer" };
   /** Call the function func after delay ms. Return a handle to the timer. */
-  export function setTimeout(func: () => void, delay: number): Timer;
+  export function setTimeout(
+    func: (...args: any) => any,
+    delay: number
+  ): OSTimer;
   /** Cancel a timer. */
-  export function clearTimeout(handle: Timer): void;
+  export function clearTimeout(handle: OSTimer): void;
-  /** Return a string representing the platform: "linux", "darwin", "win32" or "js". */
-  export var platform: "linux" | "darwin" | "win32" | "js";
+  /** Return a string representing the platform: "linux", "darwin", "win32", "freebsd", or "js" (emscripten). */
+  export var platform: "linux" | "darwin" | "win32" | "freebsd" | "js";
   /**
    * Things that can be put into Worker.postMessage.
@@ -1630,6 +3474,12 @@ declare module "os" {
   /** `access` Unix system call; checks if a file is readable, writable, executable, and/or exists (use {@link R_OK}, {@link W_OK}, {@link X_OK}, and/or {@link F_OK} for `accessMode`). Throws a descriptive error (with errno property) if the requested access is not available; otherwise, returns undefined. */
   export function access(path: string, accessMode: number): void;
+  /** gets the path to the executable which is executing this JS code. might be a relative path or symlink. */
+  export function execPath(): string;
+  /** changes the access permission bits of the file at `path` using the octal number `mode`. */
+  export function chmod(path: string, mode: number): void;
 }
 /**
@@ -1783,10 +3633,13 @@ declare class Module {
    *
    * The key for each property in this object should be a file extension
    * string with a leading dot, eg `".jsx"`. The value for each property should
-   * be a function which receives the filepath to a module, and should
-   * synchronously load that file, then return a string containing JavaScript
-   * code that corresponds to that module. In many cases, these functions will
-   * compile the contents of the file from one format into JavaScript.
+   * be a function which receives (1) the filepath to a module, and (2) that
+   * file's content as a UTF-8 string, and the function should return a string
+   * containing JavaScript code that corresponds to that module. In most cases,
+   * these functions will compile the contents of the file from one format into JavaScript.
+   *
+   * The function does not have to use the second 'content' argument it
+   * receives (ie. when loading binary files).
    *
    * By adding to this object, you can make it possible to import non-js
    * filetypes; compile-to-JS languages like JSX, TypeScript, and CoffeeScript
@@ -1797,8 +3650,7 @@ declare class Module {
    * ```js
    * import * as std from "std";
    *
-   * Module.compilers[".txt"] = (filename) => {
-   *   const content = std.loadFile(filename);
+   * Module.compilers[".txt"] = (filename, content) => {
    *   return `export default ${JSON.stringify(content)}`;
    * }
    * ```
@@ -1815,8 +3667,30 @@ declare class Module {
    * {@link Module.searchExtensions}.
    */
   static compilers: {
-    [extensionWithDot: string]: (filename: string) => string;
+    [extensionWithDot: string]: (filename: string, content: string) => string;
   };
+  /**
+   * 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;
+  /**
+   * Resolves a require/import request from `fromFile` into a canonicalized path.
+   *
+   * To change native module resolution behavior, replace this function with
+   * your own implementation.
+   */
+  static 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.
+   */
+  static read(modulePath: string): string;
 }
 /**
@@ -1851,4 +3725,110 @@ declare class Module {
  * 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) => Module;
+declare var require: ((source: string) => any) & {
+  /**
+   * Resolves the normalized path to a modules, relative to the calling file.
+   */
+  resolve: (source: string) => string;
+};
+declare var setTimeout: typeof import("quickjs:os").setTimeout;
+declare var clearTimeout: typeof import("quickjs:os").clearTimeout;
+declare type Interval = { [Symbol.toStringTag]: "Interval" };
+declare function setInterval(func: (...args: any) => any, ms: number): Interval;
+declare function clearInterval(interval: Interval): void;
+interface StringConstructor {
+  /**
+   * A no-op template literal tag.
+   *
+   * https://github.com/tc39/proposal-string-cooked
+   */
+  cooked(
+    strings: readonly string[] | ArrayLike<string>,
+    ...substitutions: any[]
+  ): string;
+  /**
+   * Remove leading minimum indentation from the string.
+   * The first line of the string must be empty.
+   *
+   * https://github.com/tc39/proposal-string-dedent
+   */
+  dedent: {
+    /**
+     * Remove leading minimum indentation from the string.
+     * The first line of the string must be empty.
+     *
+     * https://github.com/tc39/proposal-string-dedent
+     */
+    (input: string): string;
+    /**
+     * Remove leading minimum indentation from the template literal.
+     * The first line of the string must be empty.
+     *
+     * https://github.com/tc39/proposal-string-dedent
+     */
+    (
+      strings: readonly string[] | ArrayLike<string>,
+      ...substitutions: any[]
+    ): string;
+    /**
+     * Wrap another template tag function such that tagged literals
+     * become dedented before being passed to the wrapped function.
+     *
+     * https://www.npmjs.com/package/string-dedent#usage
+     */
+    <
+      Func extends (
+        strings: readonly string[] | ArrayLike<string>,
+        ...substitutions: any[]
+      ) => string
+    >(
+      input: Func
+    ): Func;
+  };
+}
+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;
+}
+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;
+}