diff --git a/src/sys/deno/deno-copy-tasks.ts b/src/sys/deno/deno-copy-tasks.ts
new file mode 100644
index 00000000000..71b8b29e6e6
--- /dev/null
+++ b/src/sys/deno/deno-copy-tasks.ts
@@ -0,0 +1,173 @@
+import type * as d from '../../declarations';
+import type { Deno } from '../../../types/lib.deno';
+import { buildError, catchError, flatOne, normalizePath, unique } from '@utils';
+import { basename, dirname, expandGlob, isGlob, isAbsolute, join, resolve } from './deps';
+
+export async function denoCopyTasks(deno: typeof Deno, copyTasks: Required<d.CopyTask>[], srcDir: string) {
+  const results: d.CopyResults = {
+    diagnostics: [],
+    dirPaths: [],
+    filePaths: [],
+  };
+
+  try {
+    copyTasks = flatOne(await Promise.all(copyTasks.map(task => processGlobs(task, srcDir))));
+
+    copyTasks = unique(copyTasks, task => task.dest);
+
+    const allCopyTasks: d.CopyTask[] = [];
+
+    // figure out all the file copy tasks we'll have
+    // by digging down through any directory copy tasks
+    while (copyTasks.length > 0) {
+      const tasks = copyTasks.splice(0, 100);
+
+      await Promise.all(tasks.map(copyTask => processCopyTask(deno, results, allCopyTasks, copyTask)));
+    }
+
+    // figure out which directories we'll need to make first
+    const mkDirs = ensureDirs(allCopyTasks);
+
+    try {
+      await Promise.all(mkDirs.map(dir => deno.mkdir(dir, { recursive: true })));
+    } catch (mkDirErr) {}
+
+    while (allCopyTasks.length > 0) {
+      const tasks = allCopyTasks.splice(0, 100);
+
+      await Promise.all(tasks.map(copyTask => deno.copyFile(copyTask.src, copyTask.dest)));
+    }
+  } catch (e) {
+    catchError(results.diagnostics, e);
+  }
+
+  return results;
+}
+
+async function processGlobs(copyTask: Required<d.CopyTask>, srcDir: string): Promise<Required<d.CopyTask>[]> {
+  return isGlob(copyTask.src)
+    ? await processGlobTask(copyTask, srcDir)
+    : [
+        {
+          src: getSrcAbsPath(srcDir, copyTask.src),
+          dest: copyTask.keepDirStructure ? join(copyTask.dest, copyTask.src) : copyTask.dest,
+          warn: copyTask.warn,
+          keepDirStructure: copyTask.keepDirStructure,
+        },
+      ];
+}
+
+function getSrcAbsPath(srcDir: string, src: string) {
+  if (isAbsolute(src)) {
+    return src;
+  }
+  return join(srcDir, src);
+}
+
+async function processGlobTask(copyTask: Required<d.CopyTask>, srcDir: string): Promise<Required<d.CopyTask>[]> {
+  const copyTasks: Required<d.CopyTask>[] = [];
+
+  for await (const walkEntry of expandGlob(copyTask.src, { root: srcDir })) {
+    const ct = createGlobCopyTask(copyTask, srcDir, walkEntry.name);
+    copyTasks.push(ct);
+  }
+  return copyTasks;
+}
+
+function createGlobCopyTask(copyTask: Required<d.CopyTask>, srcDir: string, globRelPath: string): Required<d.CopyTask> {
+  const dest = join(copyTask.dest, copyTask.keepDirStructure ? globRelPath : basename(globRelPath));
+  return {
+    src: join(srcDir, globRelPath),
+    dest,
+    warn: copyTask.warn,
+    keepDirStructure: copyTask.keepDirStructure,
+  };
+}
+
+async function processCopyTask(deno: typeof Deno, results: d.CopyResults, allCopyTasks: d.CopyTask[], copyTask: d.CopyTask) {
+  try {
+    copyTask.src = normalizePath(copyTask.src);
+    copyTask.dest = normalizePath(copyTask.dest);
+
+    // get the stats for this src to see if it's a directory or not
+    const stats = await deno.stat(copyTask.src);
+    if (stats.isDirectory) {
+      // still a directory, keep diggin down
+      if (!results.dirPaths.includes(copyTask.dest)) {
+        results.dirPaths.push(copyTask.dest);
+      }
+
+      await processCopyTaskDirectory(deno, results, allCopyTasks, copyTask);
+    } else if (!shouldIgnore(copyTask.src)) {
+      // this is a file we should copy
+      if (!results.filePaths.includes(copyTask.dest)) {
+        results.filePaths.push(copyTask.dest);
+      }
+
+      allCopyTasks.push(copyTask);
+    }
+  } catch (e) {
+    if (copyTask.warn !== false) {
+      const err = buildError(results.diagnostics);
+      err.messageText = e.message;
+    }
+  }
+}
+
+async function processCopyTaskDirectory(deno: typeof Deno, results: d.CopyResults, allCopyTasks: d.CopyTask[], copyTask: d.CopyTask) {
+  try {
+    for await (const dirEntry of deno.readDir(copyTask.src)) {
+      const subCopyTask: d.CopyTask = {
+        src: join(copyTask.src, dirEntry.name),
+        dest: join(copyTask.dest, dirEntry.name),
+        warn: copyTask.warn,
+      };
+
+      await processCopyTask(deno, results, allCopyTasks, subCopyTask);
+    }
+  } catch (e) {
+    catchError(results.diagnostics, e);
+  }
+}
+
+function ensureDirs(copyTasks: d.CopyTask[]) {
+  const mkDirs: string[] = [];
+
+  copyTasks.forEach(copyTask => {
+    addMkDir(mkDirs, dirname(copyTask.dest));
+  });
+
+  mkDirs.sort((a, b) => {
+    const partsA = a.split('/').length;
+    const partsB = b.split('/').length;
+
+    if (partsA < partsB) return -1;
+    if (partsA > partsB) return 1;
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  });
+
+  return mkDirs;
+}
+
+function addMkDir(mkDirs: string[], destDir: string) {
+  destDir = normalizePath(destDir);
+
+  if (destDir === ROOT_DIR || destDir + '/' === ROOT_DIR || destDir === '') {
+    return;
+  }
+
+  if (!mkDirs.includes(destDir)) {
+    mkDirs.push(destDir);
+  }
+}
+
+const ROOT_DIR = normalizePath(resolve('/'));
+
+function shouldIgnore(filePath: string) {
+  filePath = filePath.trim().toLowerCase();
+  return IGNORE.some(ignoreFile => filePath.endsWith(ignoreFile));
+}
+
+const IGNORE = ['.ds_store', '.gitignore', 'desktop.ini', 'thumbs.db'];
diff --git a/src/sys/deno/deno-load-typescript.ts b/src/sys/deno/deno-load-typescript.ts
new file mode 100644
index 00000000000..1c50df37979
--- /dev/null
+++ b/src/sys/deno/deno-load-typescript.ts
@@ -0,0 +1,101 @@
+import type * as d from '../../declarations';
+import type TypeScript from 'typescript';
+import { dependencies } from '../../compiler/sys/dependencies';
+import { dirname, resolve } from 'path';
+import { noop } from '@utils';
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+export const denoLoadTypeScript = (sys: d.CompilerSystem, rootDir: string, typeScriptPath: string): any =>
+  new Promise(async (promiseResolve, promiseReject) => {
+    if (!sys) {
+      promiseReject(`Unable to load TypeScript without Deno sys`);
+    } else {
+      try {
+        const tsDep = dependencies.find(dep => dep.name === 'typescript');
+
+        const tsFilePath = typeScriptPath || sys.getLocalModulePath({ rootDir: rootDir, moduleId: tsDep.name, path: tsDep.main });
+
+        try {
+          Deno.statSync(tsFilePath);
+        } catch (e) {
+          const tsUrl = sys.getRemoteModuleUrl({ moduleId: tsDep.name, version: tsDep.version, path: tsDep.main });
+          const rsp = await fetch(tsUrl);
+          if (rsp.ok) {
+            try {
+              Deno.mkdirSync(dirname(tsFilePath), { recursive: true });
+            } catch (e) {}
+
+            const content = await rsp.clone().text();
+            const encoder = new TextEncoder();
+            await Deno.writeFile(tsFilePath, encoder.encode(content));
+          } else {
+            promiseReject(`unable to fetch: ${tsUrl}`);
+            return;
+          }
+        }
+
+        // ensure typescript compiler doesn't think it's nodejs
+        (globalThis as any).process.browser = true;
+
+        // fake cjs module.exports so typescript import gets added to it
+        const orgModule = (globalThis as any).module;
+        (globalThis as any).module = { exports: {} };
+        await import(tsFilePath);
+
+        // get the typescript export from the fake cjs module.exports
+        const importedTs = (globalThis as any).module.exports;
+
+        if (orgModule) {
+          (globalThis as any).module = orgModule;
+        } else {
+          delete (globalThis as any).module;
+        }
+
+        // create half-baked sys just to get us going
+        // later on we'll wire up ts sys w/ the actual stencil sys
+        const tsSys: TypeScript.System = {
+          args: [],
+          createDirectory: noop,
+          directoryExists: p => {
+            try {
+              const s = Deno.statSync(p);
+              return s.isDirectory;
+            } catch (e) {}
+            return false;
+          },
+          exit: Deno.exit,
+          fileExists: p => {
+            try {
+              const s = Deno.statSync(p);
+              return s.isFile;
+            } catch (e) {}
+            return false;
+          },
+          getCurrentDirectory: Deno.cwd,
+          getDirectories: () => [],
+          getExecutingFilePath: () => tsFilePath,
+          newLine: '\n',
+          readDirectory: () => [],
+          readFile: (p, encoding) => {
+            try {
+              const decoder = new TextDecoder(encoding);
+              const data = Deno.readFileSync(p);
+              return decoder.decode(data);
+            } catch (e) {}
+            return undefined;
+          },
+          resolvePath: p => resolve(p),
+          useCaseSensitiveFileNames: Deno.build.os !== 'windows',
+          write: noop,
+          writeFile: noop,
+        };
+        importedTs.sys = tsSys;
+
+        promiseResolve(importedTs);
+      } catch (e) {
+        promiseReject(e);
+      }
+    }
+  });
+
+declare const Deno: typeof DenoTypes;
diff --git a/src/sys/deno/deno-logger.ts b/src/sys/deno/deno-logger.ts
new file mode 100644
index 00000000000..75ce87e8b38
--- /dev/null
+++ b/src/sys/deno/deno-logger.ts
@@ -0,0 +1,72 @@
+import { createTerminalLogger, ColorType, TerminalLoggerSys } from '../../compiler/sys/logger/terminal-logger';
+import { bgRed, blue, bold, cyan, dim, gray, green, magenta, red, yellow } from './deps';
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+export const createDenoLogger = (c: { Deno: any }) => {
+  let useColors = true;
+  const deno: typeof DenoTypes = c.Deno;
+  const minColumns = 60;
+  const maxColumns = 120;
+
+  const color = (msg: string, colorType: ColorType) => {
+    if (useColors && !deno.noColor) {
+      switch (colorType) {
+        case 'bgRed':
+          return bgRed(msg);
+        case 'blue':
+          return blue(msg);
+        case 'bold':
+          return bold(msg);
+        case 'cyan':
+          return cyan(msg);
+        case 'dim':
+          return dim(msg);
+        case 'gray':
+          return gray(msg);
+        case 'green':
+          return green(msg);
+        case 'magenta':
+          return magenta(msg);
+        case 'red':
+          return red(msg);
+        case 'yellow':
+          return yellow(msg);
+      }
+    }
+    return msg;
+  };
+
+  const cwd = () => deno.cwd();
+
+  const emoji = (e: string) => (deno.build.os !== 'windows' ? e : '');
+
+  const enableColors = (enableClrs: boolean) => (useColors = enableClrs);
+
+  const getColumns = () => {
+    const terminalWidth = (deno.stdout && (deno.stdout as any).columns) || 80;
+    return Math.max(Math.min(maxColumns, terminalWidth), minColumns);
+  };
+
+  const memoryUsage = () => -1;
+
+  const relativePath = (_from: string, to: string) => to;
+
+  const writeLogs = (logFilePath: string, log: string, append: boolean) => {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(log);
+    deno.writeFileSync(logFilePath, data, { append });
+  };
+
+  const loggerSys: TerminalLoggerSys = {
+    color,
+    cwd,
+    emoji,
+    enableColors,
+    getColumns,
+    memoryUsage,
+    relativePath,
+    writeLogs,
+  };
+
+  return createTerminalLogger(loggerSys);
+};
diff --git a/src/sys/deno/deno-node-compat.ts b/src/sys/deno/deno-node-compat.ts
new file mode 100644
index 00000000000..5ae6479c8ec
--- /dev/null
+++ b/src/sys/deno/deno-node-compat.ts
@@ -0,0 +1,45 @@
+import { createRequire } from 'https://deno.land/std/node/module.ts';
+import { join } from 'https://deno.land/std/path/mod.ts';
+import * as nodeFs from 'https://deno.land/std/node/fs.ts';
+import process from './deno-node-process';
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+
+// idk why the node compat doesn't come with stat and statSync on it??
+// https://deno.land/std/node/fs.ts
+
+Object.assign(nodeFs, {
+  stat: (...args: any[]) => {
+    const path: string = args[0];
+    const cb = args.length > 2 ? args[2] : args[1]
+    try {
+      const s = Deno.statSync(path);
+      cb && cb(null, {
+        isFile: () => s.isFile,
+        isDirectory: () => s.isDirectory,
+        isSymbolicLink: () => s.isSymlink,
+        size: s.size,
+      });
+    } catch (e) {
+      cb && cb(e);
+    }
+  },
+  statSync: (path: string) => {
+    const s = Deno.statSync(path);
+    return {
+      isFile: () => s.isFile,
+      isDirectory: () => s.isDirectory,
+      isSymbolicLink: () => s.isSymlink,
+      size: s.size,
+    };
+  }
+});
+
+export const applyNodeCompat = (opts: { fromDir: string }) => {
+  (globalThis as any).process = process;
+
+  const nodeRequire = createRequire(join(opts.fromDir, 'noop.js'));
+  (globalThis as any).require = nodeRequire;
+};
+
+declare const Deno: typeof DenoTypes;
\ No newline at end of file
diff --git a/src/sys/deno/deno-node-process.ts b/src/sys/deno/deno-node-process.ts
new file mode 100644
index 00000000000..347a588e1cf
--- /dev/null
+++ b/src/sys/deno/deno-node-process.ts
@@ -0,0 +1,39 @@
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+export const arch = Deno.build.arch;
+
+export const chdir = Deno.chdir;
+
+export const cwd = Deno.cwd;
+
+export const exit = Deno.exit;
+
+export const pid = Deno.pid;
+
+export const platform = Deno.build.os === 'windows' ? 'win32' : Deno.build.os;
+
+export const version = `v12.0.0`;
+
+export const versions = {
+  node: version,
+  ...Deno.version,
+};
+
+const process = {
+  arch,
+  chdir,
+  cwd,
+  exit,
+  pid,
+  platform,
+  version: 'v12.0.0',
+  versions,
+
+  on() {},
+  env: {},
+  argv: ['deno', ...Deno.args],
+};
+
+declare const Deno: typeof DenoTypes;
+
+export default process;
diff --git a/src/sys/deno/deno-sys.ts b/src/sys/deno/deno-sys.ts
new file mode 100644
index 00000000000..2fc7f255bb0
--- /dev/null
+++ b/src/sys/deno/deno-sys.ts
@@ -0,0 +1,567 @@
+import type {
+  CompilerFsStats,
+  CompilerSystem,
+  CompilerSystemMakeDirectoryResults,
+  CompilerSystemRealpathResults,
+  CompilerSystemRemoveDirectoryResults,
+  CompilerSystemRenameResults,
+  CompilerSystemUnlinkResults,
+  CompilerSystemWriteFileResults,
+  Logger,
+  PackageJsonData,
+  TranspileOnlyResults,
+} from '../../declarations';
+import { basename, delimiter, dirname, ensureDirSync, extname, isAbsolute, join, normalize, parse, relative, resolve, sep, win32, posix } from './deps';
+import { createDenoWorkerMainController } from './deno-worker-main';
+import { denoCopyTasks } from './deno-copy-tasks';
+import { normalizePath, catchError } from '@utils';
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+export function createDenoSys(c: { Deno: any; logger: Logger }) {
+  let tmpDir: string = null;
+  const deno: typeof DenoTypes = c.Deno;
+  const logger = c.logger;
+  const destroys = new Set<() => Promise<void> | void>();
+  const hardwareConcurrency = 4;
+
+  const getLocalModulePath = (opts: { rootDir: string; moduleId: string; path: string }) => join(opts.rootDir, 'node_modules', opts.moduleId, opts.path);
+
+  const getRemoteModuleUrl = (module: { moduleId: string; path: string; version?: string }) => {
+    const npmBaseUrl = 'https://cdn.jsdelivr.net/npm/';
+    const path = `${module.moduleId}${module.version ? '@' + module.version : ''}/${module.path}`;
+    return new URL(path, npmBaseUrl).href;
+  };
+
+  const fetchAndWrite = async (opts: { url: string; filePath: string }) => {
+    try {
+      await deno.stat(opts.filePath);
+      return;
+    } catch (e) {}
+
+    try {
+      const rsp = await fetch(opts.url);
+      if (rsp.ok) {
+        ensureDirSync(dirname(opts.filePath));
+
+        const content = await rsp.clone().text();
+        const encoder = new TextEncoder();
+        await deno.writeFile(opts.filePath, encoder.encode(content));
+        c.logger.debug('fetch', opts.url, opts.filePath);
+      } else {
+        c.logger.warn('fetch', opts.url, rsp.status);
+      }
+    } catch (e) {
+      c.logger.error(e);
+    }
+  };
+
+  const sys: CompilerSystem = {
+    name: 'deno',
+    version: deno.version.deno,
+    async access(p) {
+      try {
+        await deno.stat(p);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    accessSync(p) {
+      try {
+        deno.statSync(p);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    addDestory(cb) {
+      destroys.add(cb);
+    },
+    removeDestory(cb) {
+      destroys.delete(cb);
+    },
+    async copyFile(src, dst) {
+      try {
+        await deno.copyFile(src, dst);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    createWorkerController: maxConcurrentWorkers => createDenoWorkerMainController(sys, logger, maxConcurrentWorkers),
+    async destroy() {
+      const waits: Promise<void>[] = [];
+      destroys.forEach(cb => {
+        try {
+          const rtn = cb();
+          if (rtn && rtn.then) {
+            waits.push(rtn);
+          }
+        } catch (e) {
+          console.error(`node sys destroy: ${e}`);
+        }
+      });
+      await Promise.all(waits);
+      destroys.clear();
+    },
+    dynamicImport(p) {
+      return import(p);
+    },
+    encodeToBase64(str) {
+      return Buffer.from(str).toString('base64');
+    },
+    async ensureDependencies(opts) {
+      const tsDep = opts.dependencies.find(dep => dep.name === 'typescript');
+
+      try {
+        const decoder = new TextDecoder('utf-8');
+        const pkgContent = await deno.readFile(sys.getLocalModulePath({ rootDir: opts.rootDir, moduleId: tsDep.name, path: tsDep.main }));
+        const pkgData: PackageJsonData = JSON.parse(decoder.decode(pkgContent));
+        if (pkgData.version === tsDep.version) {
+          return;
+        }
+      } catch (e) {}
+
+      const timespace = logger.createTimeSpan(`ensureDependencies start`, true);
+
+      const deps = tsDep.resources.map(p => ({
+        url: sys.getRemoteModuleUrl({ moduleId: tsDep.name, version: tsDep.version, path: p }),
+        filePath: sys.getLocalModulePath({ rootDir: opts.rootDir, moduleId: tsDep.name, path: p }),
+      }));
+
+      await Promise.all(deps.map(fetchAndWrite));
+
+      timespace.finish(`ensureDependencies end`);
+    },
+    exit(exitCode) {
+      deno.exit(exitCode);
+    },
+    hardwareConcurrency,
+    getCompilerExecutingPath() {
+      const current = new URL('../../compiler/stencil.js', import.meta.url);
+      return normalizePath(current.pathname);
+    },
+    getCurrentDirectory() {
+      return normalizePath(deno.cwd());
+    },
+    getEnvironmentVar(key) {
+      return deno.env.get(key);
+    },
+    getLocalModulePath,
+    getRemoteModuleUrl,
+    glob(_pattern, _opts) {
+      return null;
+    },
+    async isSymbolicLink(p) {
+      try {
+        const stat = await deno.stat(p);
+        return stat.isSymlink;
+      } catch (e) {
+        return false;
+      }
+    },
+    async mkdir(p, opts) {
+      const results: CompilerSystemMakeDirectoryResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        newDirs: [],
+        error: null,
+      };
+      try {
+        await deno.mkdir(p, opts);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    mkdirSync(p, opts) {
+      const results: CompilerSystemMakeDirectoryResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        newDirs: [],
+        error: null,
+      };
+      try {
+        deno.mkdirSync(p, opts);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    nextTick(cb) {
+      // https://doc.deno.land/https/github.com/denoland/deno/releases/latest/download/lib.deno.d.ts#queueMicrotask
+      queueMicrotask(cb);
+    },
+    normalizePath,
+    platformPath: {
+      basename,
+      dirname,
+      extname,
+      isAbsolute,
+      join,
+      normalize,
+      parse,
+      relative,
+      resolve,
+      sep,
+      delimiter,
+      posix,
+      win32,
+    },
+    async readdir(p) {
+      const dirEntries: string[] = [];
+      try {
+        for await (const dirEntry of deno.readDir(p)) {
+          dirEntries.push(normalizePath(join(p, dirEntry.name)));
+        }
+      } catch (e) {}
+      return dirEntries;
+    },
+    readdirSync(p) {
+      const dirEntries: string[] = [];
+      try {
+        for (const dirEntry of deno.readDirSync(p)) {
+          dirEntries.push(normalizePath(join(p, dirEntry.name)));
+        }
+      } catch (e) {}
+      return dirEntries;
+    },
+    async readFile(p) {
+      try {
+        const decoder = new TextDecoder('utf-8');
+        const data = await deno.readFile(p);
+        return decoder.decode(data);
+      } catch (e) {}
+      return undefined;
+    },
+    readFileSync(p) {
+      try {
+        const decoder = new TextDecoder('utf-8');
+        const data = deno.readFileSync(p);
+        return decoder.decode(data);
+      } catch (e) {}
+      return undefined;
+    },
+    async realpath(p) {
+      const results: CompilerSystemRealpathResults = {
+        error: null,
+        path: undefined,
+      };
+      try {
+        results.path = await deno.realPath(p);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    realpathSync(p) {
+      const results: CompilerSystemRealpathResults = {
+        error: null,
+        path: undefined,
+      };
+      try {
+        results.path = deno.realPathSync(p);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    async rename(oldPath, newPath) {
+      const results: CompilerSystemRenameResults = {
+        oldPath,
+        newPath,
+        error: null,
+        oldDirs: [],
+        oldFiles: [],
+        newDirs: [],
+        newFiles: [],
+        renamed: [],
+        isFile: false,
+        isDirectory: false,
+      };
+      try {
+        await deno.rename(oldPath, newPath);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    resolvePath(p) {
+      return normalizePath(p);
+    },
+    async rmdir(p, opts) {
+      const results: CompilerSystemRemoveDirectoryResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        removedDirs: [],
+        removedFiles: [],
+        error: null,
+      };
+      try {
+        await deno.remove(p, opts);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    rmdirSync(p, opts) {
+      const results: CompilerSystemRemoveDirectoryResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        removedDirs: [],
+        removedFiles: [],
+        error: null,
+      };
+      try {
+        deno.removeSync(p, opts);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    async stat(p) {
+      try {
+        // deno hangs when using `stat()`!?!?!
+        // idk why compilerCtx.fs.emptyDirs(cleanDirs) will hang when stat is async
+        const stat = deno.statSync(p);
+        const results: CompilerFsStats = {
+          isFile: () => stat.isFile,
+          isDirectory: () => stat.isDirectory,
+          isSymbolicLink: () => stat.isSymlink,
+          size: stat.size,
+        };
+        return results;
+      } catch (e) {}
+      return undefined;
+    },
+    statSync(p) {
+      try {
+        const stat = deno.statSync(p);
+        const results: CompilerFsStats = {
+          isFile: () => stat.isFile,
+          isDirectory: () => stat.isDirectory,
+          isSymbolicLink: () => stat.isSymlink,
+          size: stat.size,
+        };
+        return results;
+      } catch (e) {}
+      return undefined;
+    },
+    tmpdir() {
+      if (tmpDir == null) {
+        tmpDir = deno.makeTempDirSync();
+      }
+      return tmpDir;
+    },
+    async transpile(input, filePath, compilerOptions) {
+      const results: TranspileOnlyResults = {
+        diagnostics: [],
+        output: input,
+        sourceMap: null,
+      };
+
+      try {
+        Object.assign(compilerOptions, {
+          sourceMap: false,
+          allowJs: true,
+          declaration: false,
+          target: 'es5',
+          module: 'esnext',
+          removeComments: false,
+          isolatedModules: true,
+          skipLibCheck: true,
+          noLib: true,
+          noResolve: true,
+          suppressOutputPathCheck: true,
+          allowNonTsExtensions: true,
+          composite: false,
+        });
+        const [, emitted] = await (deno as any).compile(
+          filePath,
+          {
+            [filePath]: input,
+          },
+          compilerOptions,
+        );
+
+        results.output = emitted[filePath.replace('.ts', '.js')];
+      } catch (e) {
+        catchError(results.diagnostics, e);
+      }
+
+      return results;
+    },
+    async unlink(p) {
+      const results: CompilerSystemUnlinkResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        error: null,
+      };
+      try {
+        await deno.remove(p);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    unlinkSync(p) {
+      const results: CompilerSystemUnlinkResults = {
+        basename: basename(p),
+        dirname: dirname(p),
+        path: p,
+        error: null,
+      };
+      try {
+        deno.removeSync(p);
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    async writeFile(p, content) {
+      const results: CompilerSystemWriteFileResults = {
+        path: p,
+        error: null,
+      };
+      try {
+        const encoder = new TextEncoder();
+        await deno.writeFile(p, encoder.encode(content));
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    writeFileSync(p, content) {
+      const results: CompilerSystemWriteFileResults = {
+        path: p,
+        error: null,
+      };
+      try {
+        const encoder = new TextEncoder();
+        deno.writeFileSync(p, encoder.encode(content));
+      } catch (e) {
+        results.error = e;
+      }
+      return results;
+    },
+    watchDirectory(p, callback, recursive) {
+      const fsWatcher = deno.watchFs(p, { recursive });
+
+      const dirWatcher = async () => {
+        try {
+          for await (const fsEvent of fsWatcher) {
+            for (const fsPath of fsEvent.paths) {
+              const fileName = normalizePath(fsPath);
+
+              if (fsEvent.kind === 'create') {
+                callback(fileName, 'dirAdd');
+                sys.events.emit('dirAdd', fileName);
+              } else if (fsEvent.kind === 'modify') {
+                callback(fileName, 'fileUpdate');
+                sys.events.emit('fileUpdate', fileName);
+              } else if (fsEvent.kind === 'remove') {
+                callback(fileName, 'dirDelete');
+                sys.events.emit('dirDelete', fileName);
+              }
+            }
+          }
+        } catch (e) {
+          // todo
+          // swallows "BadResource: Bad resource ID at unwrapResponse"??
+        }
+      };
+      dirWatcher();
+
+      const close = async () => {
+        try {
+          await fsWatcher.return();
+        } catch (e) {
+          // todo
+          // swallows "BadResource: Bad resource ID at unwrapResponse"??
+        }
+      };
+      sys.addDestory(close);
+
+      return {
+        close,
+      };
+    },
+    watchFile(p, callback) {
+      const fsWatcher = deno.watchFs(p, { recursive: false });
+
+      const fileWatcher = async () => {
+        try {
+          for await (const fsEvent of fsWatcher) {
+            for (const fsPath of fsEvent.paths) {
+              const fileName = normalizePath(fsPath);
+
+              if (fsEvent.kind === 'create') {
+                callback(fileName, 'fileAdd');
+                sys.events.emit('fileAdd', fileName);
+              } else if (fsEvent.kind === 'modify') {
+                callback(fileName, 'fileUpdate');
+                sys.events.emit('fileUpdate', fileName);
+              } else if (fsEvent.kind === 'remove') {
+                callback(fileName, 'fileDelete');
+                sys.events.emit('fileDelete', fileName);
+              }
+            }
+          }
+        } catch (e) {
+          // todo
+          // swallows "BadResource: Bad resource ID at unwrapResponse"??
+        }
+      };
+      fileWatcher();
+
+      const close = async () => {
+        try {
+          await fsWatcher.return();
+        } catch (e) {
+          // todo
+          // swallows "BadResource: Bad resource ID at unwrapResponse"??
+        }
+      };
+      sys.addDestory(close);
+
+      return {
+        close,
+      };
+    },
+    async generateContentHash(content) {
+      // https://github.com/denoland/deno/issues/1891
+      // https://jsperf.com/hashcodelordvlad/121
+      const len = content.length;
+      if (len === 0) return '';
+      let hash = 0;
+      for (let i = 0; i < len; i++) {
+        hash = (hash << 5) - hash + content.charCodeAt(i);
+        hash |= 0; // Convert to 32bit integer
+      }
+      if (hash < 0) {
+        hash = hash * -1;
+      }
+      return hash + '';
+    },
+    copy: (copyTasks, srcDir) => denoCopyTasks(deno, copyTasks, srcDir),
+    details: {
+      // https://github.com/denoland/deno/issues/3802
+      cpuModel: 'cpu-model',
+      freemem: () => 0,
+      platform: deno.build.os,
+      release: deno.build.vendor,
+      totalmem: 0,
+    },
+    applyGlobalPatch: async fromDir => {
+      const { applyNodeCompat } = await import('@deno-node-compat');
+      applyNodeCompat({ fromDir });
+    },
+  };
+
+  return sys;
+}
diff --git a/src/sys/deno/deno-worker-main.ts b/src/sys/deno/deno-worker-main.ts
new file mode 100644
index 00000000000..a1adc9ce0f3
--- /dev/null
+++ b/src/sys/deno/deno-worker-main.ts
@@ -0,0 +1,160 @@
+import type * as d from '../../declarations';
+import { TASK_CANCELED_MSG } from '@utils';
+
+export const createDenoWorkerMainController = (sys: d.CompilerSystem, logger: d.Logger, maxConcurrentWorkers: number): d.WorkerMainController => {
+  let msgIds = 0;
+  let isDestroyed = false;
+  let isQueued = false;
+  let workerIds = 0;
+  const tasks = new Map<number, d.CompilerWorkerTask>();
+  const queuedSendMsgs: d.MsgToWorker[] = [];
+  const workers: WorkerChild[] = [];
+  const maxWorkers = Math.max(Math.min(maxConcurrentWorkers, sys.hardwareConcurrency), 2) - 1;
+
+  const times = new Map();
+
+  const onMsgsFromWorker = (worker: WorkerChild, ev: MessageEvent) => {
+    if (!isDestroyed) {
+      const msgsFromWorker: d.MsgFromWorker[] = ev.data;
+      if (Array.isArray(msgsFromWorker)) {
+        for (const msgFromWorker of msgsFromWorker) {
+          if (msgFromWorker) {
+            const task = tasks.get(msgFromWorker.stencilId);
+            if (task) {
+              tasks.delete(msgFromWorker.stencilId);
+              if (msgFromWorker.stencilRtnError) {
+                task.reject(msgFromWorker.stencilRtnError);
+              } else {
+                task.resolve(msgFromWorker.stencilRtnValue);
+              }
+
+              worker.activeTasks--;
+              if (worker.activeTasks < 0 || worker.activeTasks > 50) {
+                worker.activeTasks = 0;
+              }
+            } else if (msgFromWorker.stencilRtnError) {
+              logger.error(msgFromWorker.stencilRtnError);
+            }
+          }
+        }
+      }
+    }
+  };
+
+  const onWorkerError = (e: ErrorEvent) => logger.error(e);
+
+  const createWorkerMain = () => {
+    const workerUrl = new URL('./worker.js', import.meta.url).href;
+
+    const workerOpts: any = {
+      name: `stencil.worker.${workerIds++}`,
+      type: `module`,
+      // https://github.com/denoland/deno/pull/4784/files#diff-dd54e4bec687ba9ed5ee965039de9fbbR1083
+      deno: true,
+    };
+
+    const worker = new Worker(workerUrl, workerOpts);
+
+    const workerChild: WorkerChild = {
+      worker,
+      activeTasks: 0,
+      sendQueue: [],
+    };
+    worker.onerror = onWorkerError;
+    worker.onmessage = ev => onMsgsFromWorker(workerChild, ev);
+
+    return workerChild;
+  };
+
+  const sendMsgsToWorkers = (w: WorkerChild) => {
+    if (w.sendQueue.length > 0) {
+      w.worker.postMessage(w.sendQueue);
+      w.sendQueue.length = 0;
+    }
+  };
+
+  const queueMsgToWorker = (msg: d.MsgToWorker) => {
+    let theChosenOne: WorkerChild;
+
+    if (workers.length > 0) {
+      theChosenOne = workers[0];
+
+      if (maxWorkers > 1) {
+        for (const worker of workers) {
+          if (worker.activeTasks < theChosenOne.activeTasks) {
+            theChosenOne = worker;
+          }
+        }
+
+        if (theChosenOne.activeTasks > 0 && workers.length < maxWorkers) {
+          theChosenOne = createWorkerMain();
+          workers.push(theChosenOne);
+        }
+      }
+    } else {
+      theChosenOne = createWorkerMain();
+      workers.push(theChosenOne);
+    }
+
+    theChosenOne.activeTasks++;
+    theChosenOne.sendQueue.push(msg);
+  };
+
+  const flushSendQueue = () => {
+    isQueued = false;
+    queuedSendMsgs.forEach(queueMsgToWorker);
+    queuedSendMsgs.length = 0;
+    workers.forEach(sendMsgsToWorkers);
+  };
+
+  const send = (...args: any[]) =>
+    new Promise<any>((resolve, reject) => {
+      if (isDestroyed) {
+        reject(TASK_CANCELED_MSG);
+      } else {
+        const msg: d.MsgToWorker = {
+          stencilId: msgIds++,
+          args,
+        };
+        queuedSendMsgs.push(msg);
+        times.set(msg.stencilId, Date.now());
+
+        tasks.set(msg.stencilId, {
+          resolve,
+          reject,
+        });
+
+        if (!isQueued) {
+          isQueued = true;
+          queueMicrotask(flushSendQueue);
+        }
+      }
+    });
+
+  const destroy = () => {
+    isDestroyed = true;
+    tasks.forEach(t => t.reject(TASK_CANCELED_MSG));
+    tasks.clear();
+    workers.forEach(w => w.worker.terminate());
+    workers.length = 0;
+  };
+
+  const handler = (name: string) => {
+    return function (...args: any[]) {
+      return send(name, ...args);
+    };
+  };
+
+  return {
+    send,
+    destroy,
+    handler,
+    maxWorkers,
+  };
+};
+
+interface WorkerChild {
+  worker: Worker;
+  activeTasks: number;
+  sendQueue: d.MsgToWorker[];
+}
diff --git a/src/sys/deno/deno-worker-thread.ts b/src/sys/deno/deno-worker-thread.ts
new file mode 100644
index 00000000000..f24daf43e20
--- /dev/null
+++ b/src/sys/deno/deno-worker-thread.ts
@@ -0,0 +1,71 @@
+import type { MsgFromWorker, MsgToWorker, WorkerMsgHandler } from '../../declarations';
+
+export const initDenoWorkerThread = (glbl: any, msgHandler: WorkerMsgHandler) => {
+  let isQueued = false;
+
+  const msgsFromWorkerQueue: MsgFromWorker[] = [];
+
+  const drainMsgQueueFromWorkerToMain = () => {
+    isQueued = false;
+    glbl.postMessage(msgsFromWorkerQueue);
+    msgsFromWorkerQueue.length = 0;
+  };
+
+  const queueMsgFromWorkerToMain = (msgFromWorkerToMain: MsgFromWorker) => {
+    msgsFromWorkerQueue.push(msgFromWorkerToMain);
+    if (!isQueued) {
+      isQueued = true;
+      queueMicrotask(drainMsgQueueFromWorkerToMain);
+    }
+  };
+
+  const error = (stencilMsgId: number, err: any) => {
+    const errMsgFromWorkerToMain: MsgFromWorker = {
+      stencilId: stencilMsgId,
+      stencilRtnValue: null,
+      stencilRtnError: 'Error',
+    };
+    if (typeof err === 'string') {
+      errMsgFromWorkerToMain.stencilRtnError += ': ' + err;
+    } else if (err) {
+      if (err.stack) {
+        errMsgFromWorkerToMain.stencilRtnError += ': ' + err.stack;
+      } else if (err.message) {
+        errMsgFromWorkerToMain.stencilRtnError += ': ' + err.message;
+      }
+    }
+    queueMsgFromWorkerToMain(errMsgFromWorkerToMain);
+  };
+
+  const receiveMsgFromMainToWorker = async (msgToWorker: MsgToWorker) => {
+    if (msgToWorker && typeof msgToWorker.stencilId === 'number') {
+      try {
+        // run the handler to get the data
+        const msgFromWorkerToMain: MsgFromWorker = {
+          stencilId: msgToWorker.stencilId,
+          stencilRtnValue: await msgHandler(msgToWorker),
+          stencilRtnError: null,
+        };
+        queueMsgFromWorkerToMain(msgFromWorkerToMain);
+      } catch (e) {
+        // error occurred while running the task
+        error(msgToWorker.stencilId, e);
+      }
+    }
+  };
+
+  glbl.onmessage = (ev: MessageEvent) => {
+    // message from the main thread
+    const msgsFromMainToWorker: MsgToWorker[] = ev.data;
+    if (Array.isArray(msgsFromMainToWorker)) {
+      for (const msgFromMainToWorker of msgsFromMainToWorker) {
+        receiveMsgFromMainToWorker(msgFromMainToWorker);
+      }
+    }
+  };
+
+  glbl.onerror = (e: any) => {
+    // uncaught error occurred on the worker thread
+    error(-1, e);
+  };
+};
diff --git a/src/sys/deno/deps.ts b/src/sys/deno/deps.ts
new file mode 100644
index 00000000000..4f192f74087
--- /dev/null
+++ b/src/sys/deno/deps.ts
@@ -0,0 +1,3 @@
+export { basename, delimiter, dirname, extname, win32, posix, isAbsolute, isGlob, join, normalize, parse, relative, resolve, sep } from 'https://deno.land/std/path/mod.ts';
+export { bgRed, blue, bold, cyan, dim, gray, green, magenta, red, yellow } from 'https://deno.land/std/fmt/colors.ts';
+export { ensureDirSync, expandGlob } from 'https://deno.land/std/fs/mod.ts';
diff --git a/src/sys/deno/index.ts b/src/sys/deno/index.ts
new file mode 100644
index 00000000000..80835557888
--- /dev/null
+++ b/src/sys/deno/index.ts
@@ -0,0 +1,2 @@
+export { createDenoLogger } from './deno-logger';
+export { createDenoSys } from './deno-sys';
diff --git a/src/sys/deno/worker.ts b/src/sys/deno/worker.ts
new file mode 100644
index 00000000000..0663cc9fdfd
--- /dev/null
+++ b/src/sys/deno/worker.ts
@@ -0,0 +1,13 @@
+import '@stencil/core/compiler';
+import { initDenoWorkerThread } from './deno-worker-thread';
+import { createDenoSys, createDenoLogger } from '@sys-api-deno';
+import type { Deno as DenoTypes } from '../../../types/lib.deno';
+
+declare const Deno: typeof DenoTypes;
+
+const coreCompiler = (globalThis as any).stencil as typeof import('@stencil/core/compiler');
+const denoLogger = createDenoLogger({ Deno });
+const denoSys = createDenoSys({ Deno, logger: denoLogger });
+const msgHandler = coreCompiler.createWorkerMessageHandler(denoSys);
+
+initDenoWorkerThread(globalThis, msgHandler);
diff --git a/types/deno-deps.d.ts b/types/deno-deps.d.ts
new file mode 100644
index 00000000000..7d008afa3b6
--- /dev/null
+++ b/types/deno-deps.d.ts
@@ -0,0 +1,59 @@
+declare module 'https://deno.land/std/fs/mod.ts' {
+  export interface WalkEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+    path: string;
+  }
+  export function ensureDirSync(dir: string): Promise<void>;
+  export function expandGlob(
+    glob: string,
+    opts?: {
+      root?: string;
+      exclude?: string[];
+      includeDirs?: boolean;
+      extended?: boolean;
+      globstar?: boolean;
+    },
+  ): AsyncIterableIterator<WalkEntry>;
+}
+
+declare module 'https://deno.land/std/path/mod.ts' {
+  export function isGlob(p: string): boolean;
+  export function normalize(p: string): string;
+  export function join(...paths: string[]): string;
+  export function resolve(...pathSegments: string[]): string;
+  export function isAbsolute(p: string): boolean;
+  export function relative(from: string, to: string): string;
+  export function dirname(p: string): string;
+  export function basename(p: string, ext?: string): string;
+  export function extname(p: string): string;
+  export function parse(p: string): any;
+  export const sep: string;
+  export const delimiter: string;
+  export const posix: any;
+  export const win32: any;
+}
+
+declare module 'https://deno.land/std/node/fs.ts' {
+  export default function nodeFs(): any;
+}
+
+declare module 'https://deno.land/std/fmt/colors.ts' {
+  export function bgRed(str: string): string;
+  export function blue(str: string): string;
+  export function bold(str: string): string;
+  export function cyan(str: string): string;
+  export function dim(str: string): string;
+  export function gray(str: string): string;
+  export function green(str: string): string;
+  export function magenta(str: string): string;
+  export function red(str: string): string;
+  export function yellow(str: string): string;
+}
+
+declare module 'https://deno.land/std/node/module.ts' {
+  export const builtinModules: string[];
+  export function createRequire(filename: string | URL): any;
+}
diff --git a/types/lib.deno.d.ts b/types/lib.deno.d.ts
new file mode 100644
index 00000000000..3bfe3a50598
--- /dev/null
+++ b/types/lib.deno.d.ts
@@ -0,0 +1,3351 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+/// <reference lib="esnext" />
+
+export namespace Deno {
+  /** A set of error constructors that are raised by Deno APIs. */
+  export const errors: {
+    NotFound: ErrorConstructor;
+    PermissionDenied: ErrorConstructor;
+    ConnectionRefused: ErrorConstructor;
+    ConnectionReset: ErrorConstructor;
+    ConnectionAborted: ErrorConstructor;
+    NotConnected: ErrorConstructor;
+    AddrInUse: ErrorConstructor;
+    AddrNotAvailable: ErrorConstructor;
+    BrokenPipe: ErrorConstructor;
+    AlreadyExists: ErrorConstructor;
+    InvalidData: ErrorConstructor;
+    TimedOut: ErrorConstructor;
+    Interrupted: ErrorConstructor;
+    WriteZero: ErrorConstructor;
+    UnexpectedEof: ErrorConstructor;
+    BadResource: ErrorConstructor;
+    Http: ErrorConstructor;
+    Busy: ErrorConstructor;
+  };
+
+  /** The current process id of the runtime. */
+  export const pid: number;
+
+  /** Reflects the `NO_COLOR` environment variable.
+   *
+   * See: https://no-color.org/ */
+  export const noColor: boolean;
+
+  export interface TestDefinition {
+    fn: () => void | Promise<void>;
+    name: string;
+    ignore?: boolean;
+    /** Check that the number of async completed ops after the test is the same
+     * as number of dispatched ops. Defaults to true.*/
+    sanitizeOps?: boolean;
+    /** Ensure the test case does not "leak" resources - ie. the resource table
+     * after the test has exactly the same contents as before the test. Defaults
+     * to true. */
+    sanitizeResources?: boolean;
+  }
+
+  /** Register a test which will be run when `deno test` is used on the command
+   * line and the containing module looks like a test module.
+   * `fn` can be async if required.
+   * ```ts
+   * import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
+   *
+   * Deno.test({
+   *   name: "example test",
+   *   fn(): void {
+   *     assertEquals("world", "world");
+   *   },
+   * });
+   *
+   * Deno.test({
+   *   name: "example ignored test",
+   *   ignore: Deno.build.os === "windows",
+   *   fn(): void {
+   *     // This test is ignored only on Windows machines
+   *   },
+   * });
+   *
+   * Deno.test({
+   *   name: "example async test",
+   *   async fn() {
+   *     const decoder = new TextDecoder("utf-8");
+   *     const data = await Deno.readFile("hello_world.txt");
+   *     assertEquals(decoder.decode(data), "Hello world");
+   *   }
+   * });
+   * ```
+   */
+  export function test(t: TestDefinition): void;
+
+  /** Register a test which will be run when `deno test` is used on the command
+   * line and the containing module looks like a test module.
+   * `fn` can be async if required.
+   *
+   * ```ts
+   * import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
+   *
+   * Deno.test("My test description", ():void => {
+   *   assertEquals("hello", "hello");
+   * });
+   *
+   * Deno.test("My async test description", async ():Promise<void> => {
+   *   const decoder = new TextDecoder("utf-8");
+   *   const data = await Deno.readFile("hello_world.txt");
+   *   assertEquals(decoder.decode(data), "Hello world");
+   * });
+   * ```
+   * */
+  export function test(name: string, fn: () => void | Promise<void>): void;
+
+  /** Exit the Deno process with optional exit code. If no exit code is supplied
+   * then Deno will exit with return code of 0.
+   *
+   * ```ts
+   * Deno.exit(5);
+   * ```
+   */
+  export function exit(code?: number): never;
+
+  export const env: {
+    /** Retrieve the value of an environment variable. Returns undefined if that
+     * key doesn't exist.
+     *
+     * ```ts
+     * console.log(Deno.env.get("HOME"));  // e.g. outputs "/home/alice"
+     * console.log(Deno.env.get("MADE_UP_VAR"));  // outputs "Undefined"
+     * ```
+     * Requires `allow-env` permission. */
+    get(key: string): string | undefined;
+
+    /** Set the value of an environment variable.
+     *
+     * ```ts
+     * Deno.env.set("SOME_VAR", "Value"));
+     * Deno.env.get("SOME_VAR");  // outputs "Value"
+     * ```
+     *
+     * Requires `allow-env` permission. */
+    set(key: string, value: string): void;
+
+    /** Returns a snapshot of the environment variables at invocation.
+     *
+     * ```ts
+     * Deno.env.set("TEST_VAR", "A");
+     * const myEnv = Deno.env.toObject();
+     * console.log(myEnv.SHELL);
+     * Deno.env.set("TEST_VAR", "B");
+     * console.log(myEnv.TEST_VAR);  // outputs "A"
+     * ```
+     *
+     * Requires `allow-env` permission. */
+    toObject(): { [index: string]: string };
+  };
+
+  /**
+   * Returns the path to the current deno executable.
+   *
+   * ```ts
+   * console.log(Deno.execPath());  // e.g. "/home/alice/.local/bin/deno"
+   * ```
+   *
+   * Requires `allow-read` permission.
+   */
+  export function execPath(): string;
+
+  /**
+   * Change the current working directory to the specified path.
+   *
+   * ```ts
+   * Deno.chdir("/home/userA");
+   * Deno.chdir("../userB");
+   * Deno.chdir("C:\\Program Files (x86)\\Java");
+   * ```
+   *
+   * Throws `Deno.errors.NotFound` if directory not found.
+   * Throws `Deno.errors.PermissionDenied` if the user does not have access
+   * rights
+   *
+   * Requires --allow-read.
+   */
+  export function chdir(directory: string): void;
+
+  /**
+   * Return a string representing the current working directory.
+   *
+   * If the current directory can be reached via multiple paths (due to symbolic
+   * links), `cwd()` may return any one of them.
+   *
+   * ```ts
+   * const currentWorkingDirectory = Deno.cwd();
+   * ```
+   *
+   * Throws `Deno.errors.NotFound` if directory not available.
+   *
+   * Requires --allow-read
+   */
+  export function cwd(): string;
+
+  export enum SeekMode {
+    Start = 0,
+    Current = 1,
+    End = 2,
+  }
+
+  export interface Reader {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
+     * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
+     * use all of `p` as scratch space during the call. If some data is
+     * available but not `p.byteLength` bytes, `read()` conventionally resolves
+     * to what is available instead of waiting for more.
+     *
+     * When `read()` encounters end-of-file condition, it resolves to EOF
+     * (`null`).
+     *
+     * When `read()` encounters an error, it rejects with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that
+     * happen after reading some bytes and also both of the allowed EOF
+     * behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use Deno.iter() to turn a Reader into an AsyncIterator.
+     */
+    read(p: Uint8Array): Promise<number | null>;
+  }
+
+  export interface ReaderSync {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
+     * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
+     * all of `p` as scratch space during the call. If some data is available
+     * but not `p.byteLength` bytes, `read()` conventionally returns what is
+     * available instead of waiting for more.
+     *
+     * When `readSync()` encounters end-of-file condition, it returns EOF
+     * (`null`).
+     *
+     * When `readSync()` encounters an error, it throws with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
+     * after reading some bytes and also both of the allowed EOF behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use Deno.iterSync() to turn a ReaderSync into an Iterator.
+     */
+    readSync(p: Uint8Array): number | null;
+  }
+
+  export interface Writer {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
+     * resolves to the number of bytes written from `p` (`0` <= `n` <=
+     * `p.byteLength`) or reject with the error encountered that caused the
+     * write to stop early. `write()` must reject with a non-null error if
+     * would resolve to `n` < `p.byteLength`. `write()` must not modify the
+     * slice data, even temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    write(p: Uint8Array): Promise<number>;
+  }
+
+  export interface WriterSync {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data
+     * stream. It returns the number of bytes written from `p` (`0` <= `n`
+     * <= `p.byteLength`) and any error encountered that caused the write to
+     * stop early. `writeSync()` must throw a non-null error if it returns `n` <
+     * `p.byteLength`. `writeSync()` must not modify the slice data, even
+     * temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    writeSync(p: Uint8Array): number;
+  }
+
+  export interface Closer {
+    close(): void;
+  }
+
+  export interface Seeker {
+    /** Seek sets the offset for the next `read()` or `write()` to offset,
+     * interpreted according to `whence`: `Start` means relative to the
+     * start of the file, `Current` means relative to the current offset,
+     * and `End` means relative to the end. Seek resolves to the new offset
+     * relative to the start of the file.
+     *
+     * Seeking to an offset before the start of the file is an error. Seeking to
+     * any positive offset is legal, but the behavior of subsequent I/O
+     * operations on the underlying object is implementation-dependent.
+     * It returns the number of cursor position.
+     */
+    seek(offset: number, whence: SeekMode): Promise<number>;
+  }
+
+  export interface SeekerSync {
+    /** Seek sets the offset for the next `readSync()` or `writeSync()` to
+     * offset, interpreted according to `whence`: `Start` means relative
+     * to the start of the file, `Current` means relative to the current
+     * offset, and `End` means relative to the end.
+     *
+     * Seeking to an offset before the start of the file is an error. Seeking to
+     * any positive offset is legal, but the behavior of subsequent I/O
+     * operations on the underlying object is implementation-dependent.
+     */
+    seekSync(offset: number, whence: SeekMode): number;
+  }
+
+  /** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or
+   * an error occurs. It resolves to the number of bytes copied or rejects with
+   * the first error encountered while copying.
+   *
+   * ```ts
+   * const source = await Deno.open("my_file.txt");
+   * const buffer = new Deno.Buffer()
+   * const bytesCopied1 = await Deno.copy(source, Deno.stdout);
+   * const bytesCopied2 = await Deno.copy(source, buffer);
+   * ```
+   *
+   * @param src The source to copy from
+   * @param dst The destination to copy to
+   * @param options Can be used to tune size of the buffer. Default size is 32kB
+   */
+  export function copy(
+    src: Reader,
+    dst: Writer,
+    options?: {
+      bufSize?: number;
+    },
+  ): Promise<number>;
+
+  /** Turns a Reader, `r`, into an async iterator.
+   *
+   * ```ts
+   * let f = await Deno.open("/etc/passwd");
+   * for await (const chunk of Deno.iter(f)) {
+   *   console.log(chunk);
+   * }
+   * f.close();
+   * ```
+   *
+   * Second argument can be used to tune size of a buffer.
+   * Default size of the buffer is 32kB.
+   *
+   * ```ts
+   * let f = await Deno.open("/etc/passwd");
+   * const iter = Deno.iter(f, {
+   *   bufSize: 1024 * 1024
+   * });
+   * for await (const chunk of iter) {
+   *   console.log(chunk);
+   * }
+   * f.close();
+   * ```
+   *
+   * Iterator uses an internal buffer of fixed size for efficiency; it returns
+   * a view on that buffer on each iteration. It is therefore caller's
+   * responsibility to copy contents of the buffer if needed; otherwise the
+   * next iteration will overwrite contents of previously returned chunk.
+   */
+  export function iter(
+    r: Reader,
+    options?: {
+      bufSize?: number;
+    },
+  ): AsyncIterableIterator<Uint8Array>;
+
+  /** Turns a ReaderSync, `r`, into an iterator.
+   *
+   * ```ts
+   * let f = Deno.openSync("/etc/passwd");
+   * for (const chunk of Deno.iterSync(f)) {
+   *   console.log(chunk);
+   * }
+   * f.close();
+   * ```
+   *
+   * Second argument can be used to tune size of a buffer.
+   * Default size of the buffer is 32kB.
+   *
+   * ```ts
+   * let f = await Deno.open("/etc/passwd");
+   * const iter = Deno.iterSync(f, {
+   *   bufSize: 1024 * 1024
+   * });
+   * for (const chunk of iter) {
+   *   console.log(chunk);
+   * }
+   * f.close();
+   * ```
+   *
+   * Iterator uses an internal buffer of fixed size for efficiency; it returns
+   * a view on that buffer on each iteration. It is therefore caller's
+   * responsibility to copy contents of the buffer if needed; otherwise the
+   * next iteration will overwrite contents of previously returned chunk.
+   */
+  export function iterSync(
+    r: ReaderSync,
+    options?: {
+      bufSize?: number;
+    },
+  ): IterableIterator<Uint8Array>;
+
+  /** Synchronously open a file and return an instance of `Deno.File`.  The
+   * file does not need to previously exist if using the `create` or `createNew`
+   * open options.  It is the callers responsibility to close the file when finished
+   * with it.
+   *
+   * ```ts
+   * const file = Deno.openSync("/foo/bar.txt", { read: true, write: true });
+   * // Do work with file
+   * Deno.close(file.rid);
+   * ```
+   *
+   * Requires `allow-read` and/or `allow-write` permissions depending on options.
+   */
+  export function openSync(path: string, options?: OpenOptions): File;
+
+  /** Open a file and resolve to an instance of `Deno.File`.  The
+   * file does not need to previously exist if using the `create` or `createNew`
+   * open options.  It is the callers responsibility to close the file when finished
+   * with it.
+   *
+   * ```ts
+   * const file = await Deno.open("/foo/bar.txt", { read: true, write: true });
+   * // Do work with file
+   * Deno.close(file.rid);
+   * ```
+   *
+   * Requires `allow-read` and/or `allow-write` permissions depending on options.
+   */
+  export function open(path: string, options?: OpenOptions): Promise<File>;
+
+  /** Creates a file if none exists or truncates an existing file and returns
+   *  an instance of `Deno.File`.
+   *
+   * ```ts
+   * const file = Deno.createSync("/foo/bar.txt");
+   * ```
+   *
+   * Requires `allow-read` and `allow-write` permissions.
+   */
+  export function createSync(path: string): File;
+
+  /** Creates a file if none exists or truncates an existing file and resolves to
+   *  an instance of `Deno.File`.
+   *
+   * ```ts
+   * const file = await Deno.create("/foo/bar.txt");
+   * ```
+   *
+   * Requires `allow-read` and `allow-write` permissions.
+   */
+  export function create(path: string): Promise<File>;
+
+  /** Synchronously read from a resource ID (`rid`) into an array buffer (`buffer`).
+   *
+   * Returns either the number of bytes read during the operation or EOF
+   * (`null`) if there was nothing more to read.
+   *
+   * It is possible for a read to successfully return with `0` bytes. This does
+   * not indicate EOF.
+   *
+   * This function is one of the lowest level APIs and most users should not
+   * work with this directly, but rather use Deno.readAllSync() instead.
+   *
+   * **It is not guaranteed that the full buffer will be read in a single call.**
+   *
+   * ```ts
+   * // if "/foo/bar.txt" contains the text "hello world":
+   * const file = Deno.openSync("/foo/bar.txt");
+   * const buf = new Uint8Array(100);
+   * const numberOfBytesRead = Deno.readSync(file.rid, buf); // 11 bytes
+   * const text = new TextDecoder().decode(buf);  // "hello world"
+   * Deno.close(file.rid);
+   * ```
+   */
+  export function readSync(rid: number, buffer: Uint8Array): number | null;
+
+  /** Read from a resource ID (`rid`) into an array buffer (`buffer`).
+   *
+   * Resolves to either the number of bytes read during the operation or EOF
+   * (`null`) if there was nothing more to read.
+   *
+   * It is possible for a read to successfully return with `0` bytes. This does
+   * not indicate EOF.
+   *
+   * This function is one of the lowest level APIs and most users should not
+   * work with this directly, but rather use Deno.readAll() instead.
+   *
+   * **It is not guaranteed that the full buffer will be read in a single call.**
+   *
+   * ```ts
+   * // if "/foo/bar.txt" contains the text "hello world":
+   * const file = await Deno.open("/foo/bar.txt");
+   * const buf = new Uint8Array(100);
+   * const numberOfBytesRead = await Deno.read(file.rid, buf); // 11 bytes
+   * const text = new TextDecoder().decode(buf);  // "hello world"
+   * Deno.close(file.rid);
+   * ```
+   */
+  export function read(rid: number, buffer: Uint8Array): Promise<number | null>;
+
+  /** Synchronously write to the resource ID (`rid`) the contents of the array
+   * buffer (`data`).
+   *
+   * Returns the number of bytes written.  This function is one of the lowest
+   * level APIs and most users should not work with this directly, but rather use
+   * Deno.writeAllSync() instead.
+   *
+   * **It is not guaranteed that the full buffer will be written in a single
+   * call.**
+   *
+   * ```ts
+   * const encoder = new TextEncoder();
+   * const data = encoder.encode("Hello world");
+   * const file = Deno.openSync("/foo/bar.txt", {write: true});
+   * const bytesWritten = Deno.writeSync(file.rid, data); // 11
+   * Deno.close(file.rid);
+   * ```
+   */
+  export function writeSync(rid: number, data: Uint8Array): number;
+
+  /** Write to the resource ID (`rid`) the contents of the array buffer (`data`).
+   *
+   * Resolves to the number of bytes written.  This function is one of the lowest
+   * level APIs and most users should not work with this directly, but rather use
+   * Deno.writeAll() instead.
+   *
+   * **It is not guaranteed that the full buffer will be written in a single
+   * call.**
+   *
+   * ```ts
+   * const encoder = new TextEncoder();
+   * const data = encoder.encode("Hello world");
+   * const file = await Deno.open("/foo/bar.txt", { write: true });
+   * const bytesWritten = await Deno.write(file.rid, data); // 11
+   * Deno.close(file.rid);
+   * ```
+   */
+  export function write(rid: number, data: Uint8Array): Promise<number>;
+
+  /** Synchronously seek a resource ID (`rid`) to the given `offset` under mode
+   * given by `whence`.  The new position within the resource (bytes from the
+   * start) is returned.
+   *
+   * ```ts
+   * const file = Deno.openSync('hello.txt', {read: true, write: true, truncate: true, create: true});
+   * Deno.writeSync(file.rid, new TextEncoder().encode("Hello world"));
+   * // advance cursor 6 bytes
+   * const cursorPosition = Deno.seekSync(file.rid, 6, Deno.SeekMode.Start);
+   * console.log(cursorPosition);  // 6
+   * const buf = new Uint8Array(100);
+   * file.readSync(buf);
+   * console.log(new TextDecoder().decode(buf)); // "world"
+   * ```
+   *
+   * The seek modes work as follows:
+   *
+   * ```ts
+   * // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
+   * // Seek 6 bytes from the start of the file
+   * console.log(Deno.seekSync(file.rid, 6, Deno.SeekMode.Start)); // "6"
+   * // Seek 2 more bytes from the current position
+   * console.log(Deno.seekSync(file.rid, 2, Deno.SeekMode.Current)); // "8"
+   * // Seek backwards 2 bytes from the end of the file
+   * console.log(Deno.seekSync(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
+   * ```
+   */
+  export function seekSync(rid: number, offset: number, whence: SeekMode): number;
+
+  /** Seek a resource ID (`rid`) to the given `offset` under mode given by `whence`.
+   * The call resolves to the new position within the resource (bytes from the start).
+   *
+   * ```ts
+   * const file = await Deno.open('hello.txt', {read: true, write: true, truncate: true, create: true});
+   * await Deno.write(file.rid, new TextEncoder().encode("Hello world"));
+   * // advance cursor 6 bytes
+   * const cursorPosition = await Deno.seek(file.rid, 6, Deno.SeekMode.Start);
+   * console.log(cursorPosition);  // 6
+   * const buf = new Uint8Array(100);
+   * await file.read(buf);
+   * console.log(new TextDecoder().decode(buf)); // "world"
+   * ```
+   *
+   * The seek modes work as follows:
+   *
+   * ```ts
+   * // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
+   * // Seek 6 bytes from the start of the file
+   * console.log(await Deno.seek(file.rid, 6, Deno.SeekMode.Start)); // "6"
+   * // Seek 2 more bytes from the current position
+   * console.log(await Deno.seek(file.rid, 2, Deno.SeekMode.Current)); // "8"
+   * // Seek backwards 2 bytes from the end of the file
+   * console.log(await Deno.seek(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
+   * ```
+   */
+  export function seek(rid: number, offset: number, whence: SeekMode): Promise<number>;
+
+  /** Close the given resource ID (rid) which has been previously opened, such
+   * as via opening or creating a file.  Closing a file when you are finished
+   * with it is important to avoid leaking resources.
+   *
+   * ```ts
+   * const file = await Deno.open("my_file.txt");
+   * // do work with "file" object
+   * Deno.close(file.rid);
+   * ````
+   */
+  export function close(rid: number): void;
+
+  /** The Deno abstraction for reading and writing files. */
+  export class File implements Reader, ReaderSync, Writer, WriterSync, Seeker, SeekerSync, Closer {
+    readonly rid: number;
+    constructor(rid: number);
+    write(p: Uint8Array): Promise<number>;
+    writeSync(p: Uint8Array): number;
+    read(p: Uint8Array): Promise<number | null>;
+    readSync(p: Uint8Array): number | null;
+    seek(offset: number, whence: SeekMode): Promise<number>;
+    seekSync(offset: number, whence: SeekMode): number;
+    close(): void;
+  }
+
+  /** A handle for `stdin`. */
+  export const stdin: Reader & ReaderSync & Closer & { rid: number };
+  /** A handle for `stdout`. */
+  export const stdout: Writer & WriterSync & Closer & { rid: number };
+  /** A handle for `stderr`. */
+  export const stderr: Writer & WriterSync & Closer & { rid: number };
+
+  export interface OpenOptions {
+    /** Sets the option for read access. This option, when `true`, means that the
+     * file should be read-able if opened. */
+    read?: boolean;
+    /** Sets the option for write access. This option, when `true`, means that
+     * the file should be write-able if opened. If the file already exists,
+     * any write calls on it will overwrite its contents, by default without
+     * truncating it. */
+    write?: boolean;
+    /**Sets the option for the append mode. This option, when `true`, means that
+     * writes will append to a file instead of overwriting previous contents.
+     * Note that setting `{ write: true, append: true }` has the same effect as
+     * setting only `{ append: true }`. */
+    append?: boolean;
+    /** Sets the option for truncating a previous file. If a file is
+     * successfully opened with this option set it will truncate the file to `0`
+     * size if it already exists. The file must be opened with write access
+     * for truncate to work. */
+    truncate?: boolean;
+    /** Sets the option to allow creating a new file, if one doesn't already
+     * exist at the specified path. Requires write or append access to be
+     * used. */
+    create?: boolean;
+    /** Defaults to `false`. If set to `true`, no file, directory, or symlink is
+     * allowed to exist at the target location. Requires write or append
+     * access to be used. When createNew is set to `true`, create and truncate
+     * are ignored. */
+    createNew?: boolean;
+    /** Permissions to use if creating the file (defaults to `0o666`, before
+     * the process's umask).
+     * Ignored on Windows. */
+    mode?: number;
+  }
+
+  /**
+   *
+   *  Check if a given resource id (`rid`) is a TTY.
+   *
+   * ```ts
+   * // This example is system and context specific
+   * const nonTTYRid = Deno.openSync("my_file.txt").rid;
+   * const ttyRid = Deno.openSync("/dev/tty6").rid;
+   * console.log(Deno.isatty(nonTTYRid)); // false
+   * console.log(Deno.isatty(ttyRid)); // true
+   * Deno.close(nonTTYRid);
+   * Deno.close(ttyRid);
+   * ```
+   */
+  export function isatty(rid: number): boolean;
+
+  /** A variable-sized buffer of bytes with `read()` and `write()` methods.
+   *
+   * Deno.Buffer is almost always used with some I/O like files and sockets. It
+   * allows one to buffer up a download from a socket. Buffer grows and shrinks
+   * as necessary.
+   *
+   * Deno.Buffer is NOT the same thing as Node's Buffer. Node's Buffer was
+   * created in 2009 before JavaScript had the concept of ArrayBuffers. It's
+   * simply a non-standard ArrayBuffer.
+   *
+   * ArrayBuffer is a fixed memory allocation. Deno.Buffer is implemented on top
+   * of ArrayBuffer.
+   *
+   * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */
+  export class Buffer implements Reader, ReaderSync, Writer, WriterSync {
+    constructor(ab?: ArrayBuffer);
+    /** Returns a slice holding the unread portion of the buffer.
+     *
+     * The slice is valid for use only until the next buffer modification (that
+     * is, only until the next call to a method like `read()`, `write()`,
+     * `reset()`, or `truncate()`). The slice aliases the buffer content at
+     * least until the next buffer modification, so immediate changes to the
+     * slice will affect the result of future reads. */
+    bytes(): Uint8Array;
+    /** Returns whether the unread portion of the buffer is empty. */
+    empty(): boolean;
+    /** A read only number of bytes of the unread portion of the buffer. */
+    readonly length: number;
+    /** The read only capacity of the buffer's underlying byte slice, that is,
+     * the total space allocated for the buffer's data. */
+    readonly capacity: number;
+    /** Discards all but the first `n` unread bytes from the buffer but
+     * continues to use the same allocated storage. It throws if `n` is
+     * negative or greater than the length of the buffer. */
+    truncate(n: number): void;
+    /** Resets the buffer to be empty, but it retains the underlying storage for
+     * use by future writes. `.reset()` is the same as `.truncate(0)`. */
+    reset(): void;
+    /** Reads the next `p.length` bytes from the buffer or until the buffer is
+     * drained. Returns the number of bytes read. If the buffer has no data to
+     * return, the return is EOF (`null`). */
+    readSync(p: Uint8Array): number | null;
+    /** Reads the next `p.length` bytes from the buffer or until the buffer is
+     * drained. Resolves to the number of bytes read. If the buffer has no
+     * data to return, resolves to EOF (`null`).
+     *
+     * NOTE: This methods reads bytes sychronously; it's provided for
+     * compatibility with `Reader` interfaces.
+     */
+    read(p: Uint8Array): Promise<number | null>;
+    writeSync(p: Uint8Array): number;
+    /** NOTE: This methods writes bytes sychronously; it's provided for
+     * compatibility with `Writer` interface. */
+    write(p: Uint8Array): Promise<number>;
+    /** Grows the buffer's capacity, if necessary, to guarantee space for
+     * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
+     * the buffer without another allocation. If `n` is negative, `.grow()` will
+     * throw. If the buffer can't grow it will throw an error.
+     *
+     * Based on Go Lang's
+     * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */
+    grow(n: number): void;
+    /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
+     * growing the buffer as needed. It resolves to the number of bytes read.
+     * If the buffer becomes too large, `.readFrom()` will reject with an error.
+     *
+     * Based on Go Lang's
+     * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
+    readFrom(r: Reader): Promise<number>;
+    /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
+     * growing the buffer as needed. It returns the number of bytes read. If the
+     * buffer becomes too large, `.readFromSync()` will throw an error.
+     *
+     * Based on Go Lang's
+     * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
+    readFromSync(r: ReaderSync): number;
+  }
+
+  /** Read Reader `r` until EOF (`null`) and resolve to the content as
+   * Uint8Array`.
+   *
+   * ```ts
+   * // Example from stdin
+   * const stdinContent = await Deno.readAll(Deno.stdin);
+   *
+   * // Example from file
+   * const file = await Deno.open("my_file.txt", {read: true});
+   * const myFileContent = await Deno.readAll(file);
+   * Deno.close(file.rid);
+   *
+   * // Example from buffer
+   * const myData = new Uint8Array(100);
+   * // ... fill myData array with data
+   * const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
+   * const bufferContent = await Deno.readAll(reader);
+   * ```
+   */
+  export function readAll(r: Reader): Promise<Uint8Array>;
+
+  /** Synchronously reads Reader `r` until EOF (`null`) and returns the content
+   * as `Uint8Array`.
+   *
+   * ```ts
+   * // Example from stdin
+   * const stdinContent = Deno.readAllSync(Deno.stdin);
+   *
+   * // Example from file
+   * const file = Deno.openSync("my_file.txt", {read: true});
+   * const myFileContent = Deno.readAllSync(file);
+   * Deno.close(file.rid);
+   *
+   * // Example from buffer
+   * const myData = new Uint8Array(100);
+   * // ... fill myData array with data
+   * const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
+   * const bufferContent = Deno.readAllSync(reader);
+   * ```
+   */
+  export function readAllSync(r: ReaderSync): Uint8Array;
+
+  /** Write all the content of the array buffer (`arr`) to the writer (`w`).
+   *
+   * ```ts
+   * // Example writing to stdout
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * await Deno.writeAll(Deno.stdout, contentBytes);
+   *
+   * // Example writing to file
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * const file = await Deno.open('test.file', {write: true});
+   * await Deno.writeAll(file, contentBytes);
+   * Deno.close(file.rid);
+   *
+   * // Example writing to buffer
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * const writer = new Deno.Buffer();
+   * await Deno.writeAll(writer, contentBytes);
+   * console.log(writer.bytes().length);  // 11
+   * ```
+   */
+  export function writeAll(w: Writer, arr: Uint8Array): Promise<void>;
+
+  /** Synchronously write all the content of the array buffer (`arr`) to the
+   * writer (`w`).
+   *
+   * ```ts
+   * // Example writing to stdout
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * Deno.writeAllSync(Deno.stdout, contentBytes);
+   *
+   * // Example writing to file
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * const file = Deno.openSync('test.file', {write: true});
+   * Deno.writeAllSync(file, contentBytes);
+   * Deno.close(file.rid);
+   *
+   * // Example writing to buffer
+   * const contentBytes = new TextEncoder().encode("Hello World");
+   * const writer = new Deno.Buffer();
+   * Deno.writeAllSync(writer, contentBytes);
+   * console.log(writer.bytes().length);  // 11
+   * ```
+   */
+  export function writeAllSync(w: WriterSync, arr: Uint8Array): void;
+
+  export interface MkdirOptions {
+    /** Defaults to `false`. If set to `true`, means that any intermediate
+     * directories will also be created (as with the shell command `mkdir -p`).
+     * Intermediate directories are created with the same permissions.
+     * When recursive is set to `true`, succeeds silently (without changing any
+     * permissions) if a directory already exists at the path, or if the path
+     * is a symlink to an existing directory. */
+    recursive?: boolean;
+    /** Permissions to use when creating the directory (defaults to `0o777`,
+     * before the process's umask).
+     * Ignored on Windows. */
+    mode?: number;
+  }
+
+  /** Synchronously creates a new directory with the specified path.
+   *
+   * ```ts
+   * Deno.mkdirSync("new_dir");
+   * Deno.mkdirSync("nested/directories", { recursive: true });
+   * Deno.mkdirSync("restricted_access_dir", { mode: 0o700 });
+   * ```
+   *
+   * Defaults to throwing error if the directory already exists.
+   *
+   * Requires `allow-write` permission. */
+  export function mkdirSync(path: string, options?: MkdirOptions): void;
+
+  /** Creates a new directory with the specified path.
+   *
+   * ```ts
+   * await Deno.mkdir("new_dir");
+   * await Deno.mkdir("nested/directories", { recursive: true });
+   * await Deno.mkdir("restricted_access_dir", { mode: 0o700 });
+   * ```
+   *
+   * Defaults to throwing error if the directory already exists.
+   *
+   * Requires `allow-write` permission. */
+  export function mkdir(path: string, options?: MkdirOptions): Promise<void>;
+
+  export interface MakeTempOptions {
+    /** Directory where the temporary directory should be created (defaults to
+     * the env variable TMPDIR, or the system's default, usually /tmp).
+     *
+     * Note that if the passed `dir` is relative, the path returned by
+     * makeTempFile() and makeTempDir() will also be relative. Be mindful of
+     * this when changing working directory. */
+    dir?: string;
+    /** String that should precede the random portion of the temporary
+     * directory's name. */
+    prefix?: string;
+    /** String that should follow the random portion of the temporary
+     * directory's name. */
+    suffix?: string;
+  }
+
+  /** Synchronously creates a new temporary directory in the default directory
+   * for temporary files (see also `Deno.dir("temp")`), unless `dir` is specified.
+   * Other optional options include prefixing and suffixing the directory name
+   * with `prefix` and `suffix` respectively.
+   *
+   * The full path to the newly created directory is returned.
+   *
+   * Multiple programs calling this function simultaneously will create different
+   * directories. It is the caller's responsibility to remove the directory when
+   * no longer needed.
+   *
+   * ```ts
+   * const tempDirName0 = Deno.makeTempDirSync();  // e.g. /tmp/2894ea76
+   * const tempDirName1 = Deno.makeTempDirSync({ prefix: 'my_temp' });  // e.g. /tmp/my_temp339c944d
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  // TODO(ry) Doesn't check permissions.
+  export function makeTempDirSync(options?: MakeTempOptions): string;
+
+  /** Creates a new temporary directory in the default directory for temporary
+   * files (see also `Deno.dir("temp")`), unless `dir` is specified.  Other
+   * optional options include prefixing and suffixing the directory name with
+   * `prefix` and `suffix` respectively.
+   *
+   * This call resolves to the full path to the newly created directory.
+   *
+   * Multiple programs calling this function simultaneously will create different
+   * directories. It is the caller's responsibility to remove the directory when
+   * no longer needed.
+   *
+   * ```ts
+   * const tempDirName0 = await Deno.makeTempDir();  // e.g. /tmp/2894ea76
+   * const tempDirName1 = await Deno.makeTempDir({ prefix: 'my_temp' }); // e.g. /tmp/my_temp339c944d
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  // TODO(ry) Doesn't check permissions.
+  export function makeTempDir(options?: MakeTempOptions): Promise<string>;
+
+  /** Synchronously creates a new temporary file in the default directory for
+   * temporary files (see also `Deno.dir("temp")`), unless `dir` is specified.
+   * Other optional options include prefixing and suffixing the directory name
+   * with `prefix` and `suffix` respectively.
+   *
+   * The full path to the newly created file is returned.
+   *
+   * Multiple programs calling this function simultaneously will create different
+   * files. It is the caller's responsibility to remove the file when no longer
+   * needed.
+   *
+   * ```ts
+   * const tempFileName0 = Deno.makeTempFileSync(); // e.g. /tmp/419e0bf2
+   * const tempFileName1 = Deno.makeTempFileSync({ prefix: 'my_temp' });  // e.g. /tmp/my_temp754d3098
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  export function makeTempFileSync(options?: MakeTempOptions): string;
+
+  /** Creates a new temporary file in the default directory for temporary
+   * files (see also `Deno.dir("temp")`), unless `dir` is specified.  Other
+   * optional options include prefixing and suffixing the directory name with
+   * `prefix` and `suffix` respectively.
+   *
+   * This call resolves to the full path to the newly created file.
+   *
+   * Multiple programs calling this function simultaneously will create different
+   * files. It is the caller's responsibility to remove the file when no longer
+   * needed.
+   *
+   * ```ts
+   * const tmpFileName0 = await Deno.makeTempFile();  // e.g. /tmp/419e0bf2
+   * const tmpFileName1 = await Deno.makeTempFile({ prefix: 'my_temp' });  // e.g. /tmp/my_temp754d3098
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  export function makeTempFile(options?: MakeTempOptions): Promise<string>;
+
+  /** Synchronously changes the permission of a specific file/directory of
+   * specified path.  Ignores the process's umask.
+   *
+   * ```ts
+   * Deno.chmodSync("/path/to/file", 0o666);
+   * ```
+   *
+   * For a full description, see [chmod](#chmod)
+   *
+   * NOTE: This API currently throws on Windows
+   *
+   * Requires `allow-write` permission. */
+  export function chmodSync(path: string, mode: number): void;
+
+  /** Changes the permission of a specific file/directory of specified path.
+   * Ignores the process's umask.
+   *
+   * ```ts
+   * await Deno.chmod("/path/to/file", 0o666);
+   * ```
+   *
+   * The mode is a sequence of 3 octal numbers.  The first/left-most number
+   * specifies the permissions for the owner.  The second number specifies the
+   * permissions for the group. The last/right-most number specifies the
+   * permissions for others.  For example, with a mode of 0o764, the owner (7) can
+   * read/write/execute, the group (6) can read/write and everyone else (4) can
+   * read only.
+   *
+   * | Number | Description |
+   * | ------ | ----------- |
+   * | 7      | read, write, and execute |
+   * | 6      | read and write |
+   * | 5      | read and execute |
+   * | 4      | read only |
+   * | 3      | write and execute |
+   * | 2      | write only |
+   * | 1      | execute only |
+   * | 0      | no permission |
+   *
+   * NOTE: This API currently throws on Windows
+   *
+   * Requires `allow-write` permission. */
+  export function chmod(path: string, mode: number): Promise<void>;
+
+  /** Synchronously change owner of a regular file or directory. This functionality
+   * is not available on Windows.
+   *
+   * ```ts
+   * Deno.chownSync("myFile.txt", 1000, 1002);
+   * ```
+   *
+   * Requires `allow-write` permission.
+   *
+   * Throws Error (not implemented) if executed on Windows
+   *
+   * @param path path to the file
+   * @param uid user id (UID) of the new owner
+   * @param gid group id (GID) of the new owner
+   */
+  export function chownSync(path: string, uid: number, gid: number): void;
+
+  /** Change owner of a regular file or directory. This functionality
+   * is not available on Windows.
+   *
+   * ```ts
+   * await Deno.chown("myFile.txt", 1000, 1002);
+   * ```
+   *
+   * Requires `allow-write` permission.
+   *
+   * Throws Error (not implemented) if executed on Windows
+   *
+   * @param path path to the file
+   * @param uid user id (UID) of the new owner
+   * @param gid group id (GID) of the new owner
+   */
+  export function chown(path: string, uid: number, gid: number): Promise<void>;
+
+  export interface RemoveOptions {
+    /** Defaults to `false`. If set to `true`, path will be removed even if
+     * it's a non-empty directory. */
+    recursive?: boolean;
+  }
+
+  /** Synchronously removes the named file or directory.
+   *
+   * ```ts
+   * Deno.removeSync("/path/to/empty_dir/or/file");
+   * Deno.removeSync("/path/to/populated_dir/or/file", { recursive: true });
+   * ```
+   *
+   * Throws error if permission denied, path not found, or path is a non-empty
+   * directory and the `recursive` option isn't set to `true`.
+   *
+   * Requires `allow-write` permission. */
+  export function removeSync(path: string, options?: RemoveOptions): void;
+
+  /** Removes the named file or directory.
+   *
+   * ```ts
+   * await Deno.remove("/path/to/empty_dir/or/file");
+   * await Deno.remove("/path/to/populated_dir/or/file", { recursive: true });
+   * ```
+   *
+   * Throws error if permission denied, path not found, or path is a non-empty
+   * directory and the `recursive` option isn't set to `true`.
+   *
+   * Requires `allow-write` permission. */
+  export function remove(path: string, options?: RemoveOptions): Promise<void>;
+
+  /** Synchronously renames (moves) `oldpath` to `newpath`. Paths may be files or
+   * directories.  If `newpath` already exists and is not a directory,
+   * `renameSync()` replaces it. OS-specific restrictions may apply when
+   * `oldpath` and `newpath` are in different directories.
+   *
+   * ```ts
+   * Deno.renameSync("old/path", "new/path");
+   * ```
+   *
+   * On Unix, this operation does not follow symlinks at either path.
+   *
+   * It varies between platforms when the operation throws errors, and if so what
+   * they are. It's always an error to rename anything to a non-empty directory.
+   *
+   * Requires `allow-read` and `allow-write` permissions. */
+  export function renameSync(oldpath: string, newpath: string): void;
+
+  /** Renames (moves) `oldpath` to `newpath`.  Paths may be files or directories.
+   * If `newpath` already exists and is not a directory, `rename()` replaces it.
+   * OS-specific restrictions may apply when `oldpath` and `newpath` are in
+   * different directories.
+   *
+   * ```ts
+   * await Deno.rename("old/path", "new/path");
+   * ```
+   *
+   * On Unix, this operation does not follow symlinks at either path.
+   *
+   * It varies between platforms when the operation throws errors, and if so what
+   * they are. It's always an error to rename anything to a non-empty directory.
+   *
+   * Requires `allow-read` and `allow-write` permission. */
+  export function rename(oldpath: string, newpath: string): Promise<void>;
+
+  /** Synchronously reads and returns the entire contents of a file as utf8 encoded string
+   *  encoded string. Reading a directory returns an empty string.
+   *
+   * ```ts
+   * const data = Deno.readTextFileSync("hello.txt");
+   * console.log(data);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function readTextFileSync(path: string): string;
+
+  /** Asynchronously reads and returns the entire contents of a file as a utf8
+   *  encoded string. Reading a directory returns an empty data array.
+   *
+   * ```ts
+   * const data = await Deno.readTextFile("hello.txt");
+   * console.log(data);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function readTextFile(path: string): Promise<string>;
+
+  /** Synchronously reads and returns the entire contents of a file as an array
+   * of bytes. `TextDecoder` can be used to transform the bytes to string if
+   * required.  Reading a directory returns an empty data array.
+   *
+   * ```ts
+   * const decoder = new TextDecoder("utf-8");
+   * const data = Deno.readFileSync("hello.txt");
+   * console.log(decoder.decode(data));
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function readFileSync(path: string): Uint8Array;
+
+  /** Reads and resolves to the entire contents of a file as an array of bytes.
+   * `TextDecoder` can be used to transform the bytes to string if required.
+   * Reading a directory returns an empty data array.
+   *
+   * ```ts
+   * const decoder = new TextDecoder("utf-8");
+   * const data = await Deno.readFile("hello.txt");
+   * console.log(decoder.decode(data));
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function readFile(path: string): Promise<Uint8Array>;
+
+  /** A FileInfo describes a file and is returned by `stat`, `lstat`,
+   * `statSync`, `lstatSync`. */
+  export interface FileInfo {
+    /** True if this is info for a regular file. Mutually exclusive to
+     * `FileInfo.isDirectory` and `FileInfo.isSymlink`. */
+    isFile: boolean;
+    /** True if this is info for a regular directory. Mutually exclusive to
+     * `FileInfo.isFile` and `FileInfo.isSymlink`. */
+    isDirectory: boolean;
+    /** True if this is info for a symlink. Mutually exclusive to
+     * `FileInfo.isFile` and `FileInfo.isDirectory`. */
+    isSymlink: boolean;
+    /** The size of the file, in bytes. */
+    size: number;
+    /** The last modification time of the file. This corresponds to the `mtime`
+     * field from `stat` on Linux/Mac OS and `ftLastWriteTime` on Windows. This
+     * may not be available on all platforms. */
+    mtime: Date | null;
+    /** The last access time of the file. This corresponds to the `atime`
+     * field from `stat` on Unix and `ftLastAccessTime` on Windows. This may not
+     * be available on all platforms. */
+    atime: Date | null;
+    /** The creation time of the file. This corresponds to the `birthtime`
+     * field from `stat` on Mac/BSD and `ftCreationTime` on Windows. This may
+     * not be available on all platforms. */
+    birthtime: Date | null;
+    /** ID of the device containing the file.
+     *
+     * _Linux/Mac OS only._ */
+    dev: number | null;
+    /** Inode number.
+     *
+     * _Linux/Mac OS only._ */
+    ino: number | null;
+    /** **UNSTABLE**: Match behavior with Go on Windows for `mode`.
+     *
+     * The underlying raw `st_mode` bits that contain the standard Unix
+     * permissions for this file/directory. */
+    mode: number | null;
+    /** Number of hard links pointing to this file.
+     *
+     * _Linux/Mac OS only._ */
+    nlink: number | null;
+    /** User ID of the owner of this file.
+     *
+     * _Linux/Mac OS only._ */
+    uid: number | null;
+    /** Group ID of the owner of this file.
+     *
+     * _Linux/Mac OS only._ */
+    gid: number | null;
+    /** Device ID of this file.
+     *
+     * _Linux/Mac OS only._ */
+    rdev: number | null;
+    /** Blocksize for filesystem I/O.
+     *
+     * _Linux/Mac OS only._ */
+    blksize: number | null;
+    /** Number of blocks allocated to the file, in 512-byte units.
+     *
+     * _Linux/Mac OS only._ */
+    blocks: number | null;
+  }
+
+  /** Returns absolute normalized path, with symbolic links resolved.
+   *
+   * ```ts
+   * // e.g. given /home/alice/file.txt and current directory /home/alice
+   * Deno.symlinkSync("file.txt", "symlink_file.txt");
+   * const realPath = Deno.realPathSync("./file.txt");
+   * const realSymLinkPath = Deno.realPathSync("./symlink_file.txt");
+   * console.log(realPath);  // outputs "/home/alice/file.txt"
+   * console.log(realSymLinkPath);  // outputs "/home/alice/file.txt"
+   * ```
+   *
+   * Requires `allow-read` permission for the target path.
+   * Also requires `allow-read` permission for the CWD if the target path is
+   * relative.*/
+  export function realPathSync(path: string): string;
+
+  /** Resolves to the absolute normalized path, with symbolic links resolved.
+   *
+   * ```ts
+   * // e.g. given /home/alice/file.txt and current directory /home/alice
+   * await Deno.symlink("file.txt", "symlink_file.txt");
+   * const realPath = await Deno.realPath("./file.txt");
+   * const realSymLinkPath = await Deno.realPath("./symlink_file.txt");
+   * console.log(realPath);  // outputs "/home/alice/file.txt"
+   * console.log(realSymLinkPath);  // outputs "/home/alice/file.txt"
+   * ```
+   *
+   * Requires `allow-read` permission for the target path.
+   * Also requires `allow-read` permission for the CWD if the target path is
+   * relative.*/
+  export function realPath(path: string): Promise<string>;
+
+  export interface DirEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+  }
+
+  /** Synchronously reads the directory given by `path` and returns an iterable
+   * of `Deno.DirEntry`.
+   *
+   * ```ts
+   * for (const dirEntry of Deno.readDirSync("/")) {
+   *   console.log(dirEntry.name);
+   * }
+   * ```
+   *
+   * Throws error if `path` is not a directory.
+   *
+   * Requires `allow-read` permission. */
+  export function readDirSync(path: string): Iterable<DirEntry>;
+
+  /** Reads the directory given by `path` and returns an async iterable of
+   * `Deno.DirEntry`.
+   *
+   * ```ts
+   * for await (const dirEntry of Deno.readDir("/")) {
+   *   console.log(dirEntry.name);
+   * }
+   * ```
+   *
+   * Throws error if `path` is not a directory.
+   *
+   * Requires `allow-read` permission. */
+  export function readDir(path: string): AsyncIterable<DirEntry>;
+
+  /** Synchronously copies the contents and permissions of one file to another
+   * specified path, by default creating a new file if needed, else overwriting.
+   * Fails if target path is a directory or is unwritable.
+   *
+   * ```ts
+   * Deno.copyFileSync("from.txt", "to.txt");
+   * ```
+   *
+   * Requires `allow-read` permission on fromPath.
+   * Requires `allow-write` permission on toPath. */
+  export function copyFileSync(fromPath: string, toPath: string): void;
+
+  /** Copies the contents and permissions of one file to another specified path,
+   * by default creating a new file if needed, else overwriting. Fails if target
+   * path is a directory or is unwritable.
+   *
+   * ```ts
+   * await Deno.copyFile("from.txt", "to.txt");
+   * ```
+   *
+   * Requires `allow-read` permission on fromPath.
+   * Requires `allow-write` permission on toPath. */
+  export function copyFile(fromPath: string, toPath: string): Promise<void>;
+
+  /** Returns the full path destination of the named symbolic link.
+   *
+   * ```ts
+   * Deno.symlinkSync("./test.txt", "./test_link.txt");
+   * const target = Deno.readLinkSync("./test_link.txt"); // full path of ./test.txt
+   * ```
+   *
+   * Throws TypeError if called with a hard link
+   *
+   * Requires `allow-read` permission. */
+  export function readLinkSync(path: string): string;
+
+  /** Resolves to the full path destination of the named symbolic link.
+   *
+   * ```ts
+   * await Deno.symlink("./test.txt", "./test_link.txt");
+   * const target = await Deno.readLink("./test_link.txt"); // full path of ./test.txt
+   * ```
+   *
+   * Throws TypeError if called with a hard link
+   *
+   * Requires `allow-read` permission. */
+  export function readLink(path: string): Promise<string>;
+
+  /** Resolves to a `Deno.FileInfo` for the specified `path`. If `path` is a
+   * symlink, information for the symlink will be returned instead of what it
+   * points to.
+   *
+   * ```ts
+   * import { assert } from "https://deno.land/std/testing/asserts.ts";
+   * const fileInfo = await Deno.lstat("hello.txt");
+   * assert(fileInfo.isFile);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function lstat(path: string): Promise<FileInfo>;
+
+  /** Synchronously returns a `Deno.FileInfo` for the specified `path`. If
+   * `path` is a symlink, information for the symlink will be returned instead of
+   * what it points to..
+   *
+   * ```ts
+   * const fileInfo = Deno.lstatSync("hello.txt");
+   * assert(fileInfo.isFile);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function lstatSync(path: string): FileInfo;
+
+  /** Resolves to a `Deno.FileInfo` for the specified `path`. Will always
+   * follow symlinks.
+   *
+   * ```ts
+   * import { assert } from "https://deno.land/std/testing/asserts.ts";
+   * const fileInfo = await Deno.stat("hello.txt");
+   * assert(fileInfo.isFile);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function stat(path: string): Promise<FileInfo>;
+
+  /** Synchronously returns a `Deno.FileInfo` for the specified `path`. Will
+   * always follow symlinks.
+   *
+   * ```ts
+   * import { assert } from "https://deno.land/std/testing/asserts.ts";
+   * const fileInfo = Deno.statSync("hello.txt");
+   * assert(fileInfo.isFile);
+   * ```
+   *
+   * Requires `allow-read` permission. */
+  export function statSync(path: string): FileInfo;
+
+  /** Options for writing to a file. */
+  export interface WriteFileOptions {
+    /** Defaults to `false`. If set to `true`, will append to a file instead of
+     * overwriting previous contents. */
+    append?: boolean;
+    /** Sets the option to allow creating a new file, if one doesn't already
+     * exist at the specified path (defaults to `true`). */
+    create?: boolean;
+    /** Permissions always applied to file. */
+    mode?: number;
+  }
+
+  /** Synchronously write `data` to the given `path`, by default creating a new
+   * file if needed, else overwriting.
+   *
+   * ```ts
+   * const encoder = new TextEncoder();
+   * const data = encoder.encode("Hello world\n");
+   * Deno.writeFileSync("hello1.txt", data);  // overwrite "hello1.txt" or create it
+   * Deno.writeFileSync("hello2.txt", data, {create: false});  // only works if "hello2.txt" exists
+   * Deno.writeFileSync("hello3.txt", data, {mode: 0o777});  // set permissions on new file
+   * Deno.writeFileSync("hello4.txt", data, {append: true});  // add data to the end of the file
+   * ```
+   *
+   * Requires `allow-write` permission, and `allow-read` if `options.create` is
+   * `false`.
+   */
+  export function writeFileSync(path: string, data: Uint8Array, options?: WriteFileOptions): void;
+
+  /** Write `data` to the given `path`, by default creating a new file if needed,
+   * else overwriting.
+   *
+   * ```ts
+   * const encoder = new TextEncoder();
+   * const data = encoder.encode("Hello world\n");
+   * await Deno.writeFile("hello1.txt", data);  // overwrite "hello1.txt" or create it
+   * await Deno.writeFile("hello2.txt", data, {create: false});  // only works if "hello2.txt" exists
+   * await Deno.writeFile("hello3.txt", data, {mode: 0o777});  // set permissions on new file
+   * await Deno.writeFile("hello4.txt", data, {append: true});  // add data to the end of the file
+   * ```
+   *
+   * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
+   */
+  export function writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+
+  /** Synchronously write string `data` to the given `path`, by default creating a new file if needed,
+   * else overwriting.
+   *
+   * ```ts
+   * await Deno.writeTextFileSync("hello1.txt", "Hello world\n");  // overwrite "hello1.txt" or create it
+   * ```
+   *
+   * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
+   */
+  export function writeTextFileSync(path: string, data: string): void;
+
+  /** Asynchronously write string `data` to the given `path`, by default creating a new file if needed,
+   * else overwriting.
+   *
+   * ```ts
+   * await Deno.writeTextFile("hello1.txt", "Hello world\n");  // overwrite "hello1.txt" or create it
+   * ```
+   *
+   * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
+   */
+  export function writeTextFile(path: string, data: string): Promise<void>;
+
+  /** Synchronously truncates or extends the specified file, to reach the
+   * specified `len`.  If `len` is not specified then the entire file contents
+   * are truncated.
+   *
+   * ```ts
+   * // truncate the entire file
+   * Deno.truncateSync("my_file.txt");
+   *
+   * // truncate part of the file
+   * const file = Deno.makeTempFileSync();
+   * Deno.writeFileSync(file, new TextEncoder().encode("Hello World"));
+   * Deno.truncateSync(file, 7);
+   * const data = Deno.readFileSync(file);
+   * console.log(new TextDecoder().decode(data));
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  export function truncateSync(name: string, len?: number): void;
+
+  /** Truncates or extends the specified file, to reach the specified `len`. If
+   * `len` is not specified then the entire file contents are truncated.
+   *
+   * ```ts
+   * // truncate the entire file
+   * await Deno.truncate("my_file.txt");
+   *
+   * // truncate part of the file
+   * const file = await Deno.makeTempFile();
+   * await Deno.writeFile(file, new TextEncoder().encode("Hello World"));
+   * await Deno.truncate(file, 7);
+   * const data = await Deno.readFile(file);
+   * console.log(new TextDecoder().decode(data));  // "Hello W"
+   * ```
+   *
+   * Requires `allow-write` permission. */
+  export function truncate(name: string, len?: number): Promise<void>;
+
+  export interface NetAddr {
+    transport: 'tcp' | 'udp';
+    hostname: string;
+    port: number;
+  }
+
+  export interface UnixAddr {
+    transport: 'unix' | 'unixpacket';
+    path: string;
+  }
+
+  export type Addr = NetAddr | UnixAddr;
+
+  /** A generic network listener for stream-oriented protocols. */
+  export interface Listener extends AsyncIterable<Conn> {
+    /** Waits for and resolves to the next connection to the `Listener`. */
+    accept(): Promise<Conn>;
+    /** Close closes the listener. Any pending accept promises will be rejected
+     * with errors. */
+    close(): void;
+    /** Return the address of the `Listener`. */
+    readonly addr: Addr;
+
+    [Symbol.asyncIterator](): AsyncIterableIterator<Conn>;
+  }
+
+  export interface Conn extends Reader, Writer, Closer {
+    /** The local address of the connection. */
+    readonly localAddr: Addr;
+    /** The remote address of the connection. */
+    readonly remoteAddr: Addr;
+    /** The resource ID of the connection. */
+    readonly rid: number;
+    /** Shuts down (`shutdown(2)`) the writing side of the TCP connection. Most
+     * callers should just use `close()`.
+     *
+     * **Unstable** because of lack of testing and because Deno.shutdown is also
+     * unstable.
+     * */
+    closeWrite(): void;
+  }
+
+  export interface ListenOptions {
+    /** The port to listen on. */
+    port: number;
+    /** A literal IP address or host name that can be resolved to an IP address.
+     * If not specified, defaults to `0.0.0.0`. */
+    hostname?: string;
+  }
+
+  /** Listen announces on the local transport address.
+   *
+   * ```ts
+   * const listener1 = Deno.listen({ port: 80 })
+   * const listener2 = Deno.listen({ hostname: "192.0.2.1", port: 80 })
+   * const listener3 = Deno.listen({ hostname: "[2001:db8::1]", port: 80 });
+   * const listener4 = Deno.listen({ hostname: "golang.org", port: 80, transport: "tcp" });
+   * ```
+   *
+   * Requires `allow-net` permission. */
+  export function listen(options: ListenOptions & { transport?: 'tcp' }): Listener;
+
+  export interface ListenTlsOptions extends ListenOptions {
+    /** Server certificate file. */
+    certFile: string;
+    /** Server public key file. */
+    keyFile: string;
+
+    transport?: 'tcp';
+  }
+
+  /** Listen announces on the local transport address over TLS (transport layer
+   * security).
+   *
+   * ```ts
+   * const lstnr = Deno.listenTls({ port: 443, certFile: "./server.crt", keyFile: "./server.key" });
+   * ```
+   *
+   * Requires `allow-net` permission. */
+  export function listenTls(options: ListenTlsOptions): Listener;
+
+  export interface ConnectOptions {
+    /** The port to connect to. */
+    port: number;
+    /** A literal IP address or host name that can be resolved to an IP address.
+     * If not specified, defaults to `127.0.0.1`. */
+    hostname?: string;
+    transport?: 'tcp';
+  }
+
+  /**
+   * Connects to the hostname (default is "127.0.0.1") and port on the named
+   * transport (default is "tcp"), and resolves to the connection (`Conn`).
+   *
+   * ```ts
+   * const conn1 = await Deno.connect({ port: 80 });
+   * const conn2 = await Deno.connect({ hostname: "192.0.2.1", port: 80 });
+   * const conn3 = await Deno.connect({ hostname: "[2001:db8::1]", port: 80 });
+   * const conn4 = await Deno.connect({ hostname: "golang.org", port: 80, transport: "tcp" });
+   * ```
+   *
+   * Requires `allow-net` permission for "tcp". */
+  export function connect(options: ConnectOptions): Promise<Conn>;
+
+  export interface ConnectTlsOptions {
+    /** The port to connect to. */
+    port: number;
+    /** A literal IP address or host name that can be resolved to an IP address.
+     * If not specified, defaults to `127.0.0.1`. */
+    hostname?: string;
+    /** Server certificate file. */
+    certFile?: string;
+  }
+
+  /** Establishes a secure connection over TLS (transport layer security) using
+   * an optional cert file, hostname (default is "127.0.0.1") and port.  The
+   * cert file is optional and if not included Mozilla's root certificates will
+   * be used (see also https://github.com/ctz/webpki-roots for specifics)
+   *
+   * ```ts
+   * const conn1 = await Deno.connectTls({ port: 80 });
+   * const conn2 = await Deno.connectTls({ certFile: "./certs/my_custom_root_CA.pem", hostname: "192.0.2.1", port: 80 });
+   * const conn3 = await Deno.connectTls({ hostname: "[2001:db8::1]", port: 80 });
+   * const conn4 = await Deno.connectTls({ certFile: "./certs/my_custom_root_CA.pem", hostname: "golang.org", port: 80});
+   * ```
+   *
+   * Requires `allow-net` permission.
+   */
+  export function connectTls(options: ConnectTlsOptions): Promise<Conn>;
+
+  export interface Metrics {
+    opsDispatched: number;
+    opsDispatchedSync: number;
+    opsDispatchedAsync: number;
+    opsDispatchedAsyncUnref: number;
+    opsCompleted: number;
+    opsCompletedSync: number;
+    opsCompletedAsync: number;
+    opsCompletedAsyncUnref: number;
+    bytesSentControl: number;
+    bytesSentData: number;
+    bytesReceived: number;
+  }
+
+  /** Receive metrics from the privileged side of Deno. This is primarily used
+   * in the development of Deno. 'Ops', also called 'bindings', are the go-between
+   * between Deno JavaScript and Deno Rust.
+   *
+   *      > console.table(Deno.metrics())
+   *      ┌─────────────────────────┬────────┐
+   *      │         (index)         │ Values │
+   *      ├─────────────────────────┼────────┤
+   *      │      opsDispatched      │   3    │
+   *      │    opsDispatchedSync    │   2    │
+   *      │   opsDispatchedAsync    │   1    │
+   *      │ opsDispatchedAsyncUnref │   0    │
+   *      │      opsCompleted       │   3    │
+   *      │    opsCompletedSync     │   2    │
+   *      │    opsCompletedAsync    │   1    │
+   *      │ opsCompletedAsyncUnref  │   0    │
+   *      │    bytesSentControl     │   73   │
+   *      │      bytesSentData      │   0    │
+   *      │      bytesReceived      │  375   │
+   *      └─────────────────────────┴────────┘
+   */
+  export function metrics(): Metrics;
+
+  interface ResourceMap {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [rid: number]: any;
+  }
+
+  /** Returns a map of open resource ids (rid) along with their string
+   * representations. This is an internal API and as such resource
+   * representation has `any` type; that means it can change any time.
+   *
+   * ```ts
+   * console.log(Deno.resources());
+   * // { 0: "stdin", 1: "stdout", 2: "stderr" }
+   * Deno.openSync('../test.file');
+   * console.log(Deno.resources());
+   * // { 0: "stdin", 1: "stdout", 2: "stderr", 3: "fsFile" }
+   * ```
+   */
+  export function resources(): ResourceMap;
+
+  export interface FsEvent {
+    kind: 'any' | 'access' | 'create' | 'modify' | 'remove';
+    paths: string[];
+  }
+
+  /** Watch for file system events against one or more `paths`, which can be files
+   * or directories.  These paths must exist already.  One user action (e.g.
+   * `touch test.file`) can  generate multiple file system events.  Likewise,
+   * one user action can result in multiple file paths in one event (e.g. `mv
+   * old_name.txt new_name.txt`).  Recursive option is `true` by default and,
+   * for directories, will watch the specified directory and all sub directories.
+   * Note that the exact ordering of the events can vary between operating systems.
+   *
+   * ```ts
+   * const watcher = Deno.watchFs("/");
+   * for await (const event of watcher) {
+   *    console.log(">>>> event", event);
+   *    // { kind: "create", paths: [ "/foo.txt" ] }
+   * }
+   *```
+   *
+   * Requires `allow-read` permission.
+   */
+  export function watchFs(paths: string | string[], options?: { recursive: boolean }): AsyncIterableIterator<FsEvent>;
+
+  export class Process {
+    readonly rid: number;
+    readonly pid: number;
+    readonly stdin?: Writer & Closer;
+    readonly stdout?: Reader & Closer;
+    readonly stderr?: Reader & Closer;
+    /** Resolves to the current status of the process. */
+    status(): Promise<ProcessStatus>;
+    /** Buffer the stdout until EOF and return it as `Uint8Array`.
+     *
+     * You must set stdout to `"piped"` when creating the process.
+     *
+     * This calls `close()` on stdout after its done. */
+    output(): Promise<Uint8Array>;
+    /** Buffer the stderr until EOF and return it as `Uint8Array`.
+     *
+     * You must set stderr to `"piped"` when creating the process.
+     *
+     * This calls `close()` on stderr after its done. */
+    stderrOutput(): Promise<Uint8Array>;
+    close(): void;
+
+    /** **UNSTABLE**: The `signo` argument may change to require the Deno.Signal
+     * enum.
+     *
+     * Send a signal to process. This functionality currently only works on
+     * Linux and Mac OS.
+     */
+    kill(signo: number): void;
+  }
+
+  export type ProcessStatus =
+    | {
+        success: true;
+        code: 0;
+        signal?: undefined;
+      }
+    | {
+        success: false;
+        code: number;
+        signal?: number;
+      };
+
+  export interface RunOptions {
+    /** Arguments to pass. Note, the first element needs to be a path to the
+     * binary */
+    cmd: string[];
+    cwd?: string;
+    env?: {
+      [key: string]: string;
+    };
+    stdout?: 'inherit' | 'piped' | 'null' | number;
+    stderr?: 'inherit' | 'piped' | 'null' | number;
+    stdin?: 'inherit' | 'piped' | 'null' | number;
+  }
+
+  /** Spawns new subprocess.  RunOptions must contain at a minimum the `opt.cmd`,
+   * an array of program arguments, the first of which is the binary.
+   *
+   * ```ts
+   * const p = Deno.run({
+   *   cmd: ["echo", "hello"],
+   * });
+   * ```
+   *
+   * Subprocess uses same working directory as parent process unless `opt.cwd`
+   * is specified.
+   *
+   * Environmental variables for subprocess can be specified using `opt.env`
+   * mapping.
+   *
+   * By default subprocess inherits stdio of parent process. To change that
+   * `opt.stdout`, `opt.stderr` and `opt.stdin` can be specified independently -
+   * they can be set to either an rid of open file or set to "inherit" "piped"
+   * or "null":
+   *
+   * `"inherit"` The default if unspecified. The child inherits from the
+   * corresponding parent descriptor.
+   *
+   * `"piped"` A new pipe should be arranged to connect the parent and child
+   * sub-processes.
+   *
+   * `"null"` This stream will be ignored. This is the equivalent of attaching
+   * the stream to `/dev/null`.
+   *
+   * Details of the spawned process are returned.
+   *
+   * Requires `allow-run` permission. */
+  export function run(opt: RunOptions): Process;
+
+  interface InspectOptions {
+    depth?: number;
+  }
+
+  /** Converts the input into a string that has the same format as printed by
+   * `console.log()`.
+   *
+   * ```ts
+   * const obj = {};
+   * obj.propA = 10;
+   * obj.propB = "hello";
+   * const objAsString = Deno.inspect(obj); // { propA: 10, propB: "hello" }
+   * console.log(obj);  // prints same value as objAsString, e.g. { propA: 10, propB: "hello" }
+   * ```
+   *
+   * You can also register custom inspect functions, via the `customInspect` Deno
+   * symbol on objects, to control and customize the output.
+   *
+   * ```ts
+   * class A {
+   *   x = 10;
+   *   y = "hello";
+   *   [Deno.customInspect](): string {
+   *     return "x=" + this.x + ", y=" + this.y;
+   *   }
+   * }
+   * ```
+   *
+   *      const inStringFormat = Deno.inspect(new A()); // "x=10, y=hello"
+   *      console.log(inStringFormat);  // prints "x=10, y=hello"
+   *
+   * Finally, a number of output options are also available.
+   *
+   *      const out = Deno.inspect(obj, {showHidden: true, depth: 4, colors: true, indentLevel: 2});
+   *
+   */
+  export function inspect(value: unknown, options?: InspectOptions): string;
+
+  /** Build related information. */
+  export const build: {
+    /** The LLVM target triple */
+    target: string;
+    /** Instruction set architecture */
+    arch: 'x86_64';
+    /** Operating system */
+    os: 'darwin' | 'linux' | 'windows';
+    /** Computer vendor */
+    vendor: string;
+    /** Optional environment */
+    env?: string;
+  };
+
+  interface Version {
+    deno: string;
+    v8: string;
+    typescript: string;
+  }
+  /** Version related information. */
+  export const version: Version;
+
+  /** Returns the script arguments to the program. If for example we run a
+   * program:
+   *
+   * deno run --allow-read https://deno.land/std/examples/cat.ts /etc/passwd
+   *
+   * Then `Deno.args` will contain:
+   *
+   * [ "/etc/passwd" ]
+   */
+  export const args: string[];
+
+  /** A symbol which can be used as a key for a custom method which will be
+   * called when `Deno.inspect()` is called, or when the object is logged to
+   * the console. */
+  export const customInspect: unique symbol;
+}
+
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, no-var */
+
+/// <reference no-default-lib="true" />
+/// <reference lib="esnext" />
+
+// This follows the WebIDL at: https://webassembly.github.io/spec/js-api/
+// and: https://webassembly.github.io/spec/web-api/
+declare namespace WebAssembly {
+  interface WebAssemblyInstantiatedSource {
+    module: Module;
+    instance: Instance;
+  }
+
+  /** Compiles a `WebAssembly.Module` from WebAssembly binary code.  This
+   * function is useful if it is necessary to a compile a module before it can
+   * be instantiated (otherwise, the `WebAssembly.instantiate()` function
+   * should be used). */
+  function compile(bufferSource: BufferSource): Promise<Module>;
+
+  /** Compiles a `WebAssembly.Module` directly from a streamed underlying
+   * source. This function is useful if it is necessary to a compile a module
+   * before it can be instantiated (otherwise, the
+   * `WebAssembly.instantiateStreaming()` function should be used). */
+  function compileStreaming(source: Promise<Response>): Promise<Module>;
+
+  /** Takes the WebAssembly binary code, in the form of a typed array or
+   * `ArrayBuffer`, and performs both compilation and instantiation in one step.
+   * The returned `Promise` resolves to both a compiled `WebAssembly.Module` and
+   * its first `WebAssembly.Instance`. */
+  function instantiate(bufferSource: BufferSource, importObject?: object): Promise<WebAssemblyInstantiatedSource>;
+
+  /** Takes an already-compiled `WebAssembly.Module` and returns a `Promise`
+   * that resolves to an `Instance` of that `Module`. This overload is useful if
+   * the `Module` has already been compiled. */
+  function instantiate(module: Module, importObject?: object): Promise<Instance>;
+
+  /** Compiles and instantiates a WebAssembly module directly from a streamed
+   * underlying source. This is the most efficient, optimized way to load wasm
+   * code. */
+  function instantiateStreaming(source: Promise<Response>, importObject?: object): Promise<WebAssemblyInstantiatedSource>;
+
+  /** Validates a given typed array of WebAssembly binary code, returning
+   * whether the bytes form a valid wasm module (`true`) or not (`false`). */
+  function validate(bufferSource: BufferSource): boolean;
+
+  type ImportExportKind = 'function' | 'table' | 'memory' | 'global';
+
+  interface ModuleExportDescriptor {
+    name: string;
+    kind: ImportExportKind;
+  }
+  interface ModuleImportDescriptor {
+    module: string;
+    name: string;
+    kind: ImportExportKind;
+  }
+
+  class Module {
+    constructor(bufferSource: BufferSource);
+
+    /** Given a `Module` and string, returns a copy of the contents of all
+     * custom sections in the module with the given string name. */
+    static customSections(moduleObject: Module, sectionName: string): ArrayBuffer;
+
+    /** Given a `Module`, returns an array containing descriptions of all the
+     * declared exports. */
+    static exports(moduleObject: Module): ModuleExportDescriptor[];
+
+    /** Given a `Module`, returns an array containing descriptions of all the
+     * declared imports. */
+    static imports(moduleObject: Module): ModuleImportDescriptor[];
+  }
+
+  class Instance<T extends object = { [key: string]: any }> {
+    constructor(module: Module, importObject?: object);
+
+    /** An object containing as its members all the functions exported from the
+     * WebAssembly module instance, to allow them to be accessed and used by
+     * JavaScript. */
+    readonly exports: T;
+  }
+
+  interface MemoryDescriptor {
+    initial: number;
+    maximum?: number;
+  }
+
+  class Memory {
+    constructor(descriptor: MemoryDescriptor);
+
+    /** An accessor property that returns the buffer contained in the memory. */
+    readonly buffer: ArrayBuffer;
+
+    /** Increases the size of the memory instance by a specified number of
+     * WebAssembly pages (each one is 64KB in size). */
+    grow(delta: number): number;
+  }
+
+  type TableKind = 'anyfunc';
+
+  interface TableDescriptor {
+    element: TableKind;
+    initial: number;
+    maximum?: number;
+  }
+
+  class Table {
+    constructor(descriptor: TableDescriptor);
+
+    /** Returns the length of the table, i.e. the number of elements. */
+    readonly length: number;
+
+    /** Accessor function — gets the element stored at a given index. */
+    get(index: number): (...args: any[]) => any;
+
+    /** Increases the size of the Table instance by a specified number of
+     * elements. */
+    grow(delta: number): number;
+
+    /** Sets an element stored at a given index to a given value. */
+    set(index: number, value: (...args: any[]) => any): void;
+  }
+
+  type ValueType = 'i32' | 'i64' | 'f32' | 'f64';
+
+  interface GlobalDescriptor {
+    value: ValueType;
+    mutable?: boolean;
+  }
+
+  /** Represents a global variable instance, accessible from both JavaScript and
+   * importable/exportable across one or more `WebAssembly.Module` instances.
+   * This allows dynamic linking of multiple modules. */
+  class Global {
+    constructor(descriptor: GlobalDescriptor, value?: any);
+
+    /** Old-style method that returns the value contained inside the global
+     * variable. */
+    valueOf(): any;
+
+    /** The value contained inside the global variable — this can be used to
+     * directly set and get the global's value. */
+    value: any;
+  }
+
+  /** Indicates an error during WebAssembly decoding or validation */
+  class CompileError extends Error {
+    constructor(message: string, fileName?: string, lineNumber?: string);
+  }
+
+  /** Indicates an error during module instantiation (besides traps from the
+   * start function). */
+  class LinkError extends Error {
+    constructor(message: string, fileName?: string, lineNumber?: string);
+  }
+
+  /** Is thrown whenever WebAssembly specifies a trap. */
+  class RuntimeError extends Error {
+    constructor(message: string, fileName?: string, lineNumber?: string);
+  }
+}
+
+/** Sets a timer which executes a function once after the timer expires. Returns
+ * an id which may be used to cancel the timeout.
+ *
+ *     setTimeout(() => { console.log('hello'); }, 500);
+ */
+declare function setTimeout(
+  /** callback function to execute when timer expires */
+  cb: (...args: any[]) => void,
+  /** delay in ms */
+  delay?: number,
+  /** arguments passed to callback function */
+  ...args: any[]
+): number;
+
+/** Repeatedly calls a function , with a fixed time delay between each call.
+ *
+ *     // Outputs 'hello' to the console every 500ms
+ *     setInterval(() => { console.log('hello'); }, 500);
+ */
+declare function setInterval(
+  /** callback function to execute when timer expires */
+  cb: (...args: any[]) => void,
+  /** delay in ms */
+  delay?: number,
+  /** arguments passed to callback function */
+  ...args: any[]
+): number;
+
+/** Cancels a timed, repeating action which was previously started by a call
+ * to `setInterval()`
+ *
+ *     const id = setInterval(()= > {console.log('hello');}, 500);
+ *     ...
+ *     clearInterval(id);
+ */
+declare function clearInterval(id?: number): void;
+
+/** Cancels a scheduled action initiated by `setTimeout()`
+ *
+ *     const id = setTimeout(()= > {console.log('hello');}, 500);
+ *     ...
+ *     clearTimeout(id);
+ */
+declare function clearTimeout(id?: number): void;
+
+/** A microtask is a short function which is executed after the function or
+ * module which created it exits and only if the JavaScript execution stack is
+ * empty, but before returning control to the event loop being used to drive the
+ * script's execution environment. This event loop may be either the main event
+ * loop or the event loop driving a web worker.
+ *
+ *     queueMicrotask(() => { console.log('This event loop stack is complete'); });
+ */
+declare function queueMicrotask(func: Function): void;
+
+// declare var console: Console;
+declare var crypto: Crypto;
+
+/** Registers an event listener in the global scope, which will be called
+ * synchronously whenever the event `type` is dispatched.
+ *
+ *     addEventListener('unload', () => { console.log('All finished!'); });
+ *     ...
+ *     dispatchEvent(new Event('unload'));
+ */
+declare function addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
+
+/** Dispatches an event in the global scope, synchronously invoking any
+ * registered event listeners for this event in the appropriate order. Returns
+ * false if event is cancelable and at least one of the event handlers which
+ * handled this event called Event.preventDefault(). Otherwise it returns true.
+ *
+ *     dispatchEvent(new Event('unload'));
+ */
+declare function dispatchEvent(event: Event): boolean;
+
+/** Remove a previously registered event listener from the global scope
+ *
+ *     const lstnr = () => { console.log('hello'); };
+ *     addEventListener('load', lstnr);
+ *     removeEventListener('load', lstnr);
+ */
+declare function removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
+
+declare interface ImportMeta {
+  url: string;
+  main: boolean;
+}
+
+interface DomIterable<K, V> {
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  forEach(callback: (value: V, key: K, parent: this) => void, thisArg?: any): void;
+}
+
+interface ReadableStreamReadDoneResult<T> {
+  done: true;
+  value?: T;
+}
+
+interface ReadableStreamReadValueResult<T> {
+  done: false;
+  value: T;
+}
+
+type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
+
+interface ReadableStreamDefaultReader<R = any> {
+  readonly closed: Promise<void>;
+  cancel(reason?: any): Promise<void>;
+  read(): Promise<ReadableStreamReadResult<R>>;
+  releaseLock(): void;
+}
+
+interface ReadableStreamReader<R = any> {
+  cancel(): Promise<void>;
+  read(): Promise<ReadableStreamReadResult<R>>;
+  releaseLock(): void;
+}
+
+interface ReadableByteStreamControllerCallback {
+  (controller: ReadableByteStreamController): void | PromiseLike<void>;
+}
+
+interface UnderlyingByteSource {
+  autoAllocateChunkSize?: number;
+  cancel?: ReadableStreamErrorCallback;
+  pull?: ReadableByteStreamControllerCallback;
+  start?: ReadableByteStreamControllerCallback;
+  type: 'bytes';
+}
+
+interface UnderlyingSource<R = any> {
+  cancel?: ReadableStreamErrorCallback;
+  pull?: ReadableStreamDefaultControllerCallback<R>;
+  start?: ReadableStreamDefaultControllerCallback<R>;
+  type?: undefined;
+}
+
+interface ReadableStreamErrorCallback {
+  (reason: any): void | PromiseLike<void>;
+}
+
+interface ReadableStreamDefaultControllerCallback<R> {
+  (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
+}
+
+interface ReadableStreamDefaultController<R = any> {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk: R): void;
+  error(error?: any): void;
+}
+
+interface ReadableByteStreamController {
+  readonly byobRequest: undefined;
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk: ArrayBufferView): void;
+  error(error?: any): void;
+}
+
+interface PipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
+  preventClose?: boolean;
+  signal?: AbortSignal;
+}
+
+interface QueuingStrategySizeCallback<T = any> {
+  (chunk: T): number;
+}
+
+interface QueuingStrategy<T = any> {
+  highWaterMark?: number;
+  size?: QueuingStrategySizeCallback<T>;
+}
+
+/** This Streams API interface provides a built-in byte length queuing strategy
+ * that can be used when constructing streams. */
+declare class CountQueuingStrategy implements QueuingStrategy {
+  constructor(options: { highWaterMark: number });
+  highWaterMark: number;
+  size(chunk: any): 1;
+}
+
+declare class ByteLengthQueuingStrategy implements QueuingStrategy<ArrayBufferView> {
+  constructor(options: { highWaterMark: number });
+  highWaterMark: number;
+  size(chunk: ArrayBufferView): number;
+}
+
+/** This Streams API interface represents a readable stream of byte data. The
+ * Fetch API offers a concrete instance of a ReadableStream through the body
+ * property of a Response object. */
+interface ReadableStream<R = any> {
+  readonly locked: boolean;
+  cancel(reason?: any): Promise<void>;
+  getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+  // getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
+  getReader(): ReadableStreamDefaultReader<R>;
+  pipeThrough<T>(
+    {
+      writable,
+      readable,
+    }: {
+      writable: WritableStream<R>;
+      readable: ReadableStream<T>;
+    },
+    options?: PipeOptions,
+  ): ReadableStream<T>;
+  pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+  [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+}
+
+declare var ReadableStream: {
+  prototype: ReadableStream;
+  new (underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined }): ReadableStream<Uint8Array>;
+  new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+};
+
+interface WritableStreamDefaultControllerCloseCallback {
+  (): void | PromiseLike<void>;
+}
+
+interface WritableStreamDefaultControllerStartCallback {
+  (controller: WritableStreamDefaultController): void | PromiseLike<void>;
+}
+
+interface WritableStreamDefaultControllerWriteCallback<W> {
+  (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
+}
+
+interface WritableStreamErrorCallback {
+  (reason: any): void | PromiseLike<void>;
+}
+
+interface UnderlyingSink<W = any> {
+  abort?: WritableStreamErrorCallback;
+  close?: WritableStreamDefaultControllerCloseCallback;
+  start?: WritableStreamDefaultControllerStartCallback;
+  type?: undefined;
+  write?: WritableStreamDefaultControllerWriteCallback<W>;
+}
+
+/** This Streams API interface provides a standard abstraction for writing
+ * streaming data to a destination, known as a sink. This object comes with
+ * built-in backpressure and queuing. */
+declare class WritableStream<W = any> {
+  constructor(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>);
+  readonly locked: boolean;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): WritableStreamDefaultWriter<W>;
+}
+
+/** This Streams API interface represents a controller allowing control of a
+ * WritableStream's state. When constructing a WritableStream, the underlying
+ * sink is given a corresponding WritableStreamDefaultController instance to
+ * manipulate. */
+interface WritableStreamDefaultController {
+  error(error?: any): void;
+}
+
+/** This Streams API interface is the object returned by
+ * WritableStream.getWriter() and once created locks the < writer to the
+ * WritableStream ensuring that no other streams can write to the underlying
+ * sink. */
+interface WritableStreamDefaultWriter<W = any> {
+  readonly closed: Promise<void>;
+  readonly desiredSize: number | null;
+  readonly ready: Promise<void>;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  releaseLock(): void;
+  write(chunk: W): Promise<void>;
+}
+
+declare class TransformStream<I = any, O = any> {
+  constructor(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>);
+  readonly readable: ReadableStream<O>;
+  readonly writable: WritableStream<I>;
+}
+
+interface TransformStreamDefaultController<O = any> {
+  readonly desiredSize: number | null;
+  enqueue(chunk: O): void;
+  error(reason?: any): void;
+  terminate(): void;
+}
+
+interface Transformer<I = any, O = any> {
+  flush?: TransformStreamDefaultControllerCallback<O>;
+  readableType?: undefined;
+  start?: TransformStreamDefaultControllerCallback<O>;
+  transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
+  writableType?: undefined;
+}
+
+interface TransformStreamDefaultControllerCallback<O> {
+  (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+}
+
+interface TransformStreamDefaultControllerTransformCallback<I, O> {
+  (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+}
+
+interface DOMStringList {
+  /** Returns the number of strings in strings. */
+  readonly length: number;
+  /** Returns true if strings contains string, and false otherwise. */
+  contains(string: string): boolean;
+  /** Returns the string with index index from strings. */
+  item(index: number): string | null;
+  [index: number]: string;
+}
+
+declare class DOMException extends Error {
+  constructor(message?: string, name?: string);
+  readonly name: string;
+  readonly message: string;
+}
+
+type BufferSource = ArrayBufferView | ArrayBuffer;
+type BlobPart = BufferSource | Blob | string;
+
+interface BlobPropertyBag {
+  type?: string;
+  ending?: 'transparent' | 'native';
+}
+
+/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
+interface Blob {
+  readonly size: number;
+  readonly type: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  slice(start?: number, end?: number, contentType?: string): Blob;
+  stream(): ReadableStream;
+  text(): Promise<string>;
+}
+
+declare const Blob: {
+  prototype: Blob;
+  new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+};
+
+interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}
+
+/** Provides information about files and allows JavaScript in a web page to
+ * access their content. */
+interface File extends Blob {
+  readonly lastModified: number;
+  readonly name: string;
+}
+
+declare const File: {
+  prototype: File;
+  new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+};
+
+declare const isConsoleInstance: unique symbol;
+
+// declare class Console {
+//   indentLevel: number;
+//   [isConsoleInstance]: boolean;
+//   /** Writes the arguments to stdout */
+//   log: (...args: unknown[]) => void;
+//   /** Writes the arguments to stdout */
+//   debug: (...args: unknown[]) => void;
+//   /** Writes the arguments to stdout */
+//   info: (...args: unknown[]) => void;
+//   /** Writes the properties of the supplied `obj` to stdout */
+//   dir: (
+//     obj: unknown,
+//     options?: Partial<{
+//       depth: number;
+//       indentLevel: number;
+//     }>
+//   ) => void;
+
+//   /** From MDN:
+//    * Displays an interactive tree of the descendant elements of
+//    * the specified XML/HTML element. If it is not possible to display
+//    * as an element the JavaScript Object view is shown instead.
+//    * The output is presented as a hierarchical listing of expandable
+//    * nodes that let you see the contents of child nodes.
+//    *
+//    * Since we write to stdout, we can't display anything interactive
+//    * we just fall back to `console.dir`.
+//    */
+//   dirxml: (
+//     obj: unknown,
+//     options?: Partial<{
+//       showHidden: boolean;
+//       depth: number;
+//       colors: boolean;
+//       indentLevel: number;
+//     }>
+//   ) => void;
+
+//   /** Writes the arguments to stdout */
+//   warn: (...args: unknown[]) => void;
+//   /** Writes the arguments to stdout */
+//   error: (...args: unknown[]) => void;
+//   /** Writes an error message to stdout if the assertion is `false`. If the
+//    * assertion is `true`, nothing happens.
+//    *
+//    * ref: https://console.spec.whatwg.org/#assert
+//    */
+//   assert: (condition?: boolean, ...args: unknown[]) => void;
+//   count: (label?: string) => void;
+//   countReset: (label?: string) => void;
+//   table: (data: unknown, properties?: string[] | undefined) => void;
+//   time: (label?: string) => void;
+//   timeLog: (label?: string, ...args: unknown[]) => void;
+//   timeEnd: (label?: string) => void;
+//   group: (...label: unknown[]) => void;
+//   groupCollapsed: (...label: unknown[]) => void;
+//   groupEnd: () => void;
+//   clear: () => void;
+//   trace: (...args: unknown[]) => void;
+//   static [Symbol.hasInstance](instance: Console): boolean;
+// }
+
+declare interface Crypto {
+  readonly subtle: null;
+  getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(
+    array: T,
+  ): T;
+}
+
+type FormDataEntryValue = File | string;
+
+/** Provides a way to easily construct a set of key/value pairs representing
+ * form fields and their values, which can then be easily sent using the
+ * XMLHttpRequest.send() method. It uses the same format a form would use if the
+ * encoding type were set to "multipart/form-data". */
+interface FormData extends DomIterable<string, FormDataEntryValue> {
+  append(name: string, value: string | Blob, fileName?: string): void;
+  delete(name: string): void;
+  get(name: string): FormDataEntryValue | null;
+  getAll(name: string): FormDataEntryValue[];
+  has(name: string): boolean;
+  set(name: string, value: string | Blob, fileName?: string): void;
+}
+
+declare const FormData: {
+  prototype: FormData;
+  // TODO(ry) FormData constructor is non-standard.
+  // new(form?: HTMLFormElement): FormData;
+  new (): FormData;
+};
+
+interface Body {
+  /** A simple getter used to expose a `ReadableStream` of the body contents. */
+  readonly body: ReadableStream<Uint8Array> | null;
+  /** Stores a `Boolean` that declares whether the body has been used in a
+   * response yet.
+   */
+  readonly bodyUsed: boolean;
+  /** Takes a `Response` stream and reads it to completion. It returns a promise
+   * that resolves with an `ArrayBuffer`.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Takes a `Response` stream and reads it to completion. It returns a promise
+   * that resolves with a `Blob`.
+   */
+  blob(): Promise<Blob>;
+  /** Takes a `Response` stream and reads it to completion. It returns a promise
+   * that resolves with a `FormData` object.
+   */
+  formData(): Promise<FormData>;
+  /** Takes a `Response` stream and reads it to completion. It returns a promise
+   * that resolves with the result of parsing the body text as JSON.
+   */
+  json(): Promise<any>;
+  /** Takes a `Response` stream and reads it to completion. It returns a promise
+   * that resolves with a `USVString` (text).
+   */
+  text(): Promise<string>;
+}
+
+type HeadersInit = Headers | string[][] | Record<string, string>;
+
+/** This Fetch API interface allows you to perform various actions on HTTP
+ * request and response headers. These actions include retrieving, setting,
+ * adding to, and removing. A Headers object has an associated header list,
+ * which is initially empty and consists of zero or more name and value pairs.
+ *  You can add to this using methods like append() (see Examples.) In all
+ * methods of this interface, header names are matched by case-insensitive byte
+ * sequence. */
+interface Headers {
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  get(name: string): string | null;
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+}
+
+interface Headers extends DomIterable<string, string> {
+  /** Appends a new value onto an existing header inside a `Headers` object, or
+   * adds the header if it does not already exist.
+   */
+  append(name: string, value: string): void;
+  /** Deletes a header from a `Headers` object. */
+  delete(name: string): void;
+  /** Returns an iterator allowing to go through all key/value pairs
+   * contained in this Headers object. The both the key and value of each pairs
+   * are ByteString objects.
+   */
+  entries(): IterableIterator<[string, string]>;
+  /** Returns a `ByteString` sequence of all the values of a header within a
+   * `Headers` object with a given name.
+   */
+  get(name: string): string | null;
+  /** Returns a boolean stating whether a `Headers` object contains a certain
+   * header.
+   */
+  has(name: string): boolean;
+  /** Returns an iterator allowing to go through all keys contained in
+   * this Headers object. The keys are ByteString objects.
+   */
+  keys(): IterableIterator<string>;
+  /** Sets a new value for an existing header inside a Headers object, or adds
+   * the header if it does not already exist.
+   */
+  set(name: string, value: string): void;
+  /** Returns an iterator allowing to go through all values contained in
+   * this Headers object. The values are ByteString objects.
+   */
+  values(): IterableIterator<string>;
+  forEach(callbackfn: (value: string, key: string, parent: this) => void, thisArg?: any): void;
+  /** The Symbol.iterator well-known symbol specifies the default
+   * iterator for this Headers object
+   */
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+declare const Headers: {
+  prototype: Headers;
+  new (init?: HeadersInit): Headers;
+};
+
+type RequestInfo = Request | string;
+type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+type RequestCredentials = 'include' | 'omit' | 'same-origin';
+type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin';
+type RequestRedirect = 'error' | 'follow' | 'manual';
+type ReferrerPolicy =
+  | ''
+  | 'no-referrer'
+  | 'no-referrer-when-downgrade'
+  | 'origin'
+  | 'origin-when-cross-origin'
+  | 'same-origin'
+  | 'strict-origin'
+  | 'strict-origin-when-cross-origin'
+  | 'unsafe-url';
+type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
+type RequestDestination =
+  | ''
+  | 'audio'
+  | 'audioworklet'
+  | 'document'
+  | 'embed'
+  | 'font'
+  | 'image'
+  | 'manifest'
+  | 'object'
+  | 'paintworklet'
+  | 'report'
+  | 'script'
+  | 'sharedworker'
+  | 'style'
+  | 'track'
+  | 'video'
+  | 'worker'
+  | 'xslt';
+
+interface RequestInit {
+  /**
+   * A BodyInit object or null to set request's body.
+   */
+  body?: BodyInit | null;
+  /**
+   * A string indicating how the request will interact with the browser's cache
+   * to set request's cache.
+   */
+  cache?: RequestCache;
+  /**
+   * A string indicating whether credentials will be sent with the request
+   * always, never, or only when sent to a same-origin URL. Sets request's
+   * credentials.
+   */
+  credentials?: RequestCredentials;
+  /**
+   * A Headers object, an object literal, or an array of two-item arrays to set
+   * request's headers.
+   */
+  headers?: HeadersInit;
+  /**
+   * A cryptographic hash of the resource to be fetched by request. Sets
+   * request's integrity.
+   */
+  integrity?: string;
+  /**
+   * A boolean to set request's keepalive.
+   */
+  keepalive?: boolean;
+  /**
+   * A string to set request's method.
+   */
+  method?: string;
+  /**
+   * A string to indicate whether the request will use CORS, or will be
+   * restricted to same-origin URLs. Sets request's mode.
+   */
+  mode?: RequestMode;
+  /**
+   * A string indicating whether request follows redirects, results in an error
+   * upon encountering a redirect, or returns the redirect (in an opaque
+   * fashion). Sets request's redirect.
+   */
+  redirect?: RequestRedirect;
+  /**
+   * A string whose value is a same-origin URL, "about:client", or the empty
+   * string, to set request's referrer.
+   */
+  referrer?: string;
+  /**
+   * A referrer policy to set request's referrerPolicy.
+   */
+  referrerPolicy?: ReferrerPolicy;
+  /**
+   * An AbortSignal to set request's signal.
+   */
+  signal?: AbortSignal | null;
+  /**
+   * Can only be null. Used to disassociate request from any Window.
+   */
+  window?: any;
+}
+
+/** This Fetch API interface represents a resource request. */
+interface Request extends Body {
+  /**
+   * Returns the cache mode associated with request, which is a string
+   * indicating how the request will interact with the browser's cache when
+   * fetching.
+   */
+  readonly cache: RequestCache;
+  /**
+   * Returns the credentials mode associated with request, which is a string
+   * indicating whether credentials will be sent with the request always, never,
+   * or only when sent to a same-origin URL.
+   */
+  readonly credentials: RequestCredentials;
+  /**
+   * Returns the kind of resource requested by request, e.g., "document" or "script".
+   */
+  readonly destination: RequestDestination;
+  /**
+   * Returns a Headers object consisting of the headers associated with request.
+   * Note that headers added in the network layer by the user agent will not be
+   * accounted for in this object, e.g., the "Host" header.
+   */
+  readonly headers: Headers;
+  /**
+   * Returns request's subresource integrity metadata, which is a cryptographic
+   * hash of the resource being fetched. Its value consists of multiple hashes
+   * separated by whitespace. [SRI]
+   */
+  readonly integrity: string;
+  /**
+   * Returns a boolean indicating whether or not request is for a history
+   * navigation (a.k.a. back-forward navigation).
+   */
+  readonly isHistoryNavigation: boolean;
+  /**
+   * Returns a boolean indicating whether or not request is for a reload
+   * navigation.
+   */
+  readonly isReloadNavigation: boolean;
+  /**
+   * Returns a boolean indicating whether or not request can outlive the global
+   * in which it was created.
+   */
+  readonly keepalive: boolean;
+  /**
+   * Returns request's HTTP method, which is "GET" by default.
+   */
+  readonly method: string;
+  /**
+   * Returns the mode associated with request, which is a string indicating
+   * whether the request will use CORS, or will be restricted to same-origin
+   * URLs.
+   */
+  readonly mode: RequestMode;
+  /**
+   * Returns the redirect mode associated with request, which is a string
+   * indicating how redirects for the request will be handled during fetching. A
+   * request will follow redirects by default.
+   */
+  readonly redirect: RequestRedirect;
+  /**
+   * Returns the referrer of request. Its value can be a same-origin URL if
+   * explicitly set in init, the empty string to indicate no referrer, and
+   * "about:client" when defaulting to the global's default. This is used during
+   * fetching to determine the value of the `Referer` header of the request
+   * being made.
+   */
+  readonly referrer: string;
+  /**
+   * Returns the referrer policy associated with request. This is used during
+   * fetching to compute the value of the request's referrer.
+   */
+  readonly referrerPolicy: ReferrerPolicy;
+  /**
+   * Returns the signal associated with request, which is an AbortSignal object
+   * indicating whether or not request has been aborted, and its abort event
+   * handler.
+   */
+  readonly signal: AbortSignal;
+  /**
+   * Returns the URL of request as a string.
+   */
+  readonly url: string;
+  clone(): Request;
+}
+
+declare const Request: {
+  prototype: Request;
+  new (input: RequestInfo, init?: RequestInit): Request;
+};
+
+interface ResponseInit {
+  headers?: HeadersInit;
+  status?: number;
+  statusText?: string;
+}
+
+type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+
+/** This Fetch API interface represents the response to a request. */
+interface Response extends Body {
+  readonly headers: Headers;
+  readonly ok: boolean;
+  readonly redirected: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly trailer: Promise<Headers>;
+  readonly type: ResponseType;
+  readonly url: string;
+  clone(): Response;
+}
+
+declare const Response: {
+  prototype: Response;
+  new (body?: BodyInit | null, init?: ResponseInit): Response;
+  error(): Response;
+  redirect(url: string, status?: number): Response;
+};
+
+/** Fetch a resource from the network. It returns a Promise that resolves to the
+ * Response to that request, whether it is successful or not.
+ *
+ *     const response = await fetch("http://my.json.host/data.json");
+ *     console.log(response.status);  // e.g. 200
+ *     console.log(response.statusText); // e.g. "OK"
+ *     const jsonData = await response.json();
+ */
+declare function fetch(input: Request | URL | string, init?: RequestInit): Promise<Response>;
+
+/** Decodes a string of data which has been encoded using base-64 encoding.
+ *
+ *     console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
+ */
+declare function atob(s: string): string;
+
+/** Creates a base-64 ASCII encoded string from the input string.
+ *
+ *     console.log(btoa("hello world"));  // outputs "aGVsbG8gd29ybGQ="
+ */
+declare function btoa(s: string): string;
+
+declare class TextDecoder {
+  /** Returns encoding's name, lowercased. */
+  readonly encoding: string;
+  /** Returns `true` if error mode is "fatal", and `false` otherwise. */
+  readonly fatal: boolean;
+  /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
+  readonly ignoreBOM = false;
+  constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+  /** Returns the result of running encoding's decoder. */
+  decode(input?: BufferSource, options?: { stream?: false }): string;
+  readonly [Symbol.toStringTag]: string;
+}
+
+declare class TextEncoder {
+  /** Returns "utf-8". */
+  readonly encoding = 'utf-8';
+  /** Returns the result of running UTF-8's encoder. */
+  encode(input?: string): Uint8Array;
+  encodeInto(input: string, dest: Uint8Array): { read: number; written: number };
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface URLSearchParams {
+  /** Appends a specified key/value pair as a new search parameter.
+   *
+   * ```ts
+   * let searchParams = new URLSearchParams();
+   * searchParams.append('name', 'first');
+   * searchParams.append('name', 'second');
+   * ```
+   */
+  append(name: string, value: string): void;
+
+  /** Deletes the given search parameter and its associated value,
+   * from the list of all search parameters.
+   *
+   * ```ts
+   * let searchParams = new URLSearchParams([['name', 'value']]);
+   * searchParams.delete('name');
+   * ```
+   */
+  delete(name: string): void;
+
+  /** Returns all the values associated with a given search parameter
+   * as an array.
+   *
+   * ```ts
+   * searchParams.getAll('name');
+   * ```
+   */
+  getAll(name: string): string[];
+
+  /** Returns the first value associated to the given search parameter.
+   *
+   * ```ts
+   * searchParams.get('name');
+   * ```
+   */
+  get(name: string): string | null;
+
+  /** Returns a Boolean that indicates whether a parameter with the
+   * specified name exists.
+   *
+   * ```ts
+   * searchParams.has('name');
+   * ```
+   */
+  has(name: string): boolean;
+
+  /** Sets the value associated with a given search parameter to the
+   * given value. If there were several matching values, this method
+   * deletes the others. If the search parameter doesn't exist, this
+   * method creates it.
+   *
+   * ```ts
+   * searchParams.set('name', 'value');
+   * ```
+   */
+  set(name: string, value: string): void;
+
+  /** Sort all key/value pairs contained in this object in place and
+   * return undefined. The sort order is according to Unicode code
+   * points of the keys.
+   *
+   * ```ts
+   * searchParams.sort();
+   * ```
+   */
+  sort(): void;
+
+  /** Calls a function for each element contained in this object in
+   * place and return undefined. Optionally accepts an object to use
+   * as this when executing callback as second argument.
+   *
+   * ```ts
+   * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
+   * params.forEach((value, key, parent) => {
+   *   console.log(value, key, parent);
+   * });
+   * ```
+   *
+   */
+  forEach(callbackfn: (value: string, key: string, parent: this) => void, thisArg?: any): void;
+
+  /** Returns an iterator allowing to go through all keys contained
+   * in this object.
+   *
+   * ```ts
+   * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
+   * for (const key of params.keys()) {
+   *   console.log(key);
+   * }
+   * ```
+   */
+  keys(): IterableIterator<string>;
+
+  /** Returns an iterator allowing to go through all values contained
+   * in this object.
+   *
+   * ```ts
+   * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
+   * for (const value of params.values()) {
+   *   console.log(value);
+   * }
+   * ```
+   */
+  values(): IterableIterator<string>;
+
+  /** Returns an iterator allowing to go through all key/value
+   * pairs contained in this object.
+   *
+   * ```ts
+   * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
+   * for (const [key, value] of params.entries()) {
+   *   console.log(key, value);
+   * }
+   * ```
+   */
+  entries(): IterableIterator<[string, string]>;
+
+  /** Returns an iterator allowing to go through all key/value
+   * pairs contained in this object.
+   *
+   * ```ts
+   * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
+   * for (const [key, value] of params) {
+   *   console.log(key, value);
+   * }
+   * ```
+   */
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+
+  /** Returns a query string suitable for use in a URL.
+   *
+   * ```ts
+   * searchParams.toString();
+   * ```
+   */
+  toString(): string;
+}
+
+declare const URLSearchParams: {
+  prototype: URLSearchParams;
+  new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+  toString(): string;
+};
+
+/** The URL interface represents an object providing static methods used for creating object URLs. */
+interface URL {
+  hash: string;
+  host: string;
+  hostname: string;
+  href: string;
+  toString(): string;
+  readonly origin: string;
+  password: string;
+  pathname: string;
+  port: string;
+  protocol: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  username: string;
+  toJSON(): string;
+}
+
+declare const URL: {
+  prototype: URL;
+  new (url: string | URL, base?: string | URL): URL;
+  createObjectURL(object: any): string;
+  revokeObjectURL(url: string): void;
+};
+
+interface MessageEventInit extends EventInit {
+  data?: any;
+  origin?: string;
+  lastEventId?: string;
+}
+
+declare class MessageEvent extends Event {
+  readonly data: any;
+  readonly origin: string;
+  readonly lastEventId: string;
+  constructor(type: string, eventInitDict?: MessageEventInit);
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string;
+  filename?: string;
+  lineno?: number;
+  colno?: number;
+  error?: any;
+}
+
+declare class ErrorEvent extends Event {
+  readonly message: string;
+  readonly filename: string;
+  readonly lineno: number;
+  readonly colno: number;
+  readonly error: any;
+  constructor(type: string, eventInitDict?: ErrorEventInit);
+}
+
+interface PostMessageOptions {
+  transfer?: any[];
+}
+
+declare class Worker extends EventTarget {
+  onerror?: (e: ErrorEvent) => void;
+  onmessage?: (e: MessageEvent) => void;
+  onmessageerror?: (e: MessageEvent) => void;
+  constructor(
+    specifier: string,
+    options?: {
+      type?: 'classic' | 'module';
+      name?: string;
+      /** UNSTABLE: New API. Expect many changes; most likely this
+       * field will be made into an object for more granular
+       * configuration of worker thread (permissions, import map, etc.).
+       *
+       * Set to `true` to make `Deno` namespace and all of its methods
+       * available to worker thread.
+       *
+       * Currently worker inherits permissions from main thread (permissions
+       * given using `--allow-*` flags).
+       * Configurable permissions are on the roadmap to be implemented.
+       *
+       * Example:
+       *
+       * ```ts
+       * // mod.ts
+       * const worker = new Worker("./deno_worker.ts", { type: "module", deno: true });
+       * worker.postMessage({ cmd: "readFile", fileName: "./log.txt" });
+       *
+       * // deno_worker.ts
+       *
+       *
+       * self.onmessage = async function (e) {
+       *     const { cmd, fileName } = e.data;
+       *     if (cmd !== "readFile") {
+       *         throw new Error("Invalid command");
+       *     }
+       *     const buf = await Deno.readFile(fileName);
+       *     const fileContents = new TextDecoder().decode(buf);
+       *     console.log(fileContents);
+       * }
+       * ```
+       *
+       * // log.txt
+       * hello world
+       * hello world 2
+       *
+       * // run program
+       * $ deno run --allow-read mod.ts
+       * hello world
+       * hello world2
+       *
+       */
+      deno?: boolean;
+    },
+  );
+  postMessage(message: any, transfer: ArrayBuffer[]): void;
+  postMessage(message: any, options?: PostMessageOptions): void;
+  terminate(): void;
+}
+
+declare namespace performance {
+  /** Returns a current time from Deno's start in milliseconds.
+   *
+   * Use the permission flag `--allow-hrtime` return a precise value.
+   *
+   * ```ts
+   * const t = performance.now();
+   * console.log(`${t} ms since start!`);
+   * ```
+   */
+  export function now(): number;
+}
+
+interface EventInit {
+  bubbles?: boolean;
+  cancelable?: boolean;
+  composed?: boolean;
+}
+
+/** An event which takes place in the DOM. */
+declare class Event {
+  constructor(type: string, eventInitDict?: EventInit);
+  /** Returns true or false depending on how event was initialized. True if
+   * event goes through its target's ancestors in reverse tree order, and
+   * false otherwise. */
+  readonly bubbles: boolean;
+  cancelBubble: boolean;
+  /** Returns true or false depending on how event was initialized. Its return
+   * value does not always carry meaning, but true can indicate that part of the
+   * operation during which event was dispatched, can be canceled by invoking
+   * the preventDefault() method. */
+  readonly cancelable: boolean;
+  /** Returns true or false depending on how event was initialized. True if
+   * event invokes listeners past a ShadowRoot node that is the root of its
+   * target, and false otherwise. */
+  readonly composed: boolean;
+  /** Returns the object whose event listener's callback is currently being
+   * invoked. */
+  readonly currentTarget: EventTarget | null;
+  /** Returns true if preventDefault() was invoked successfully to indicate
+   * cancellation, and false otherwise. */
+  readonly defaultPrevented: boolean;
+  /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE,
+   * AT_TARGET, and BUBBLING_PHASE. */
+  readonly eventPhase: number;
+  /** Returns true if event was dispatched by the user agent, and false
+   * otherwise. */
+  readonly isTrusted: boolean;
+  /** Returns the object to which event is dispatched (its target). */
+  readonly target: EventTarget | null;
+  /** Returns the event's timestamp as the number of milliseconds measured
+   * relative to the time origin. */
+  readonly timeStamp: number;
+  /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
+  readonly type: string;
+  /** Returns the invocation target objects of event's path (objects on which
+   * listeners will be invoked), except for any nodes in shadow trees of which
+   * the shadow root's mode is "closed" that are not reachable from event's
+   * currentTarget. */
+  composedPath(): EventTarget[];
+  /** If invoked when the cancelable attribute value is true, and while
+   * executing a listener for the event with passive set to false, signals to
+   * the operation that caused event to be dispatched that it needs to be
+   * canceled. */
+  preventDefault(): void;
+  /** Invoking this method prevents event from reaching any registered event
+   * listeners after the current one finishes running and, when dispatched in a
+   * tree, also prevents event from reaching any other objects. */
+  stopImmediatePropagation(): void;
+  /** When dispatched in a tree, invoking this method prevents event from
+   * reaching any objects other than the current object. */
+  stopPropagation(): void;
+  readonly AT_TARGET: number;
+  readonly BUBBLING_PHASE: number;
+  readonly CAPTURING_PHASE: number;
+  readonly NONE: number;
+  static readonly AT_TARGET: number;
+  static readonly BUBBLING_PHASE: number;
+  static readonly CAPTURING_PHASE: number;
+  static readonly NONE: number;
+}
+
+/**
+ * EventTarget is a DOM interface implemented by objects that can receive events
+ * and may have listeners for them.
+ */
+declare class EventTarget {
+  /** Appends an event listener for events whose type attribute value is type.
+   * The callback argument sets the callback that will be invoked when the event
+   * is dispatched.
+   *
+   * The options argument sets listener-specific options. For compatibility this
+   * can be a boolean, in which case the method behaves exactly as if the value
+   * was specified as options's capture.
+   *
+   * When set to true, options's capture prevents callback from being invoked
+   * when the event's eventPhase attribute value is BUBBLING_PHASE. When false
+   * (or not present), callback will not be invoked when event's eventPhase
+   * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
+   * event's eventPhase attribute value is AT_TARGET.
+   *
+   * When set to true, options's passive indicates that the callback will not
+   * cancel the event by invoking preventDefault(). This is used to enable
+   * performance optimizations described in § 2.8 Observing event listeners.
+   *
+   * When set to true, options's once indicates that the callback will only be
+   * invoked once after which the event listener will be removed.
+   *
+   * The event listener is appended to target's event listener list and is not
+   * appended if it has the same type, callback, and capture. */
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+  /** Dispatches a synthetic event event to target and returns true if either
+   * event's cancelable attribute value is false or its preventDefault() method
+   * was not invoked, and false otherwise. */
+  dispatchEvent(event: Event): boolean;
+  /** Removes the event listener in target's event listener list with the same
+   * type, callback, and options. */
+  removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+  [Symbol.toStringTag]: string;
+}
+
+interface EventListener {
+  (evt: Event): void | Promise<void>;
+}
+
+interface EventListenerObject {
+  handleEvent(evt: Event): void | Promise<void>;
+}
+
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
+interface AddEventListenerOptions extends EventListenerOptions {
+  once?: boolean;
+  passive?: boolean;
+}
+
+interface EventListenerOptions {
+  capture?: boolean;
+}
+
+/** Events measuring progress of an underlying process, like an HTTP request
+ * (for an XMLHttpRequest, or the loading of the underlying resource of an
+ * <img>, <audio>, <video>, <style> or <link>). */
+interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
+  readonly lengthComputable: boolean;
+  readonly loaded: number;
+  readonly target: T | null;
+  readonly total: number;
+}
+
+interface CustomEventInit<T = any> extends EventInit {
+  detail?: T;
+}
+
+declare class CustomEvent<T = any> extends Event {
+  constructor(typeArg: string, eventInitDict?: CustomEventInit<T>);
+  /** Returns any custom data event was created with. Typically used for
+   * synthetic events. */
+  readonly detail: T;
+}
+
+/** A controller object that allows you to abort one or more DOM requests as and
+ * when desired. */
+declare class AbortController {
+  /** Returns the AbortSignal object associated with this object. */
+  readonly signal: AbortSignal;
+  /** Invoking this method will set this object's AbortSignal's aborted flag and
+   * signal to any observers that the associated activity is to be aborted. */
+  abort(): void;
+}
+
+interface AbortSignalEventMap {
+  abort: Event;
+}
+
+/** A signal object that allows you to communicate with a DOM request (such as a
+ * Fetch) and abort it if required via an AbortController object. */
+interface AbortSignal extends EventTarget {
+  /** Returns true if this AbortSignal's AbortController has signaled to abort,
+   * and false otherwise. */
+  readonly aborted: boolean;
+  onabort: ((this: AbortSignal, ev: Event) => any) | null;
+  addEventListener<K extends keyof AbortSignalEventMap>(
+    type: K,
+    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions,
+  ): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener<K extends keyof AbortSignalEventMap>(
+    type: K,
+    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
+    options?: boolean | EventListenerOptions,
+  ): void;
+  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare const AbortSignal: {
+  prototype: AbortSignal;
+  new (): AbortSignal;
+};
+
+interface ErrorConstructor {
+  /** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  captureStackTrace(error: Object, constructor?: Function): void;
+  // TODO(nayeemrmn): Support `Error.prepareStackTrace()`. We currently use this
+  // internally in a way that makes it unavailable for users.
+}
+
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/// <reference no-default-lib="true" />
+/// <reference lib="deno.ns" />
+/// <reference lib="deno.shared_globals" />
+/// <reference lib="esnext" />
+
+declare interface Window extends EventTarget {
+  readonly window: Window & typeof globalThis;
+  readonly self: Window & typeof globalThis;
+  onload: ((this: Window, ev: Event) => any) | null;
+  onunload: ((this: Window, ev: Event) => any) | null;
+  close: () => void;
+  readonly closed: boolean;
+  Deno: typeof Deno;
+}
+
+declare const window: Window & typeof globalThis;
+declare const self: Window & typeof globalThis;
+declare const onload: ((this: Window, ev: Event) => any) | null;
+declare const onunload: ((this: Window, ev: Event) => any) | null;
+
+/* eslint-enable @typescript-eslint/no-explicit-any */