diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1269366
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+test.ini
diff --git a/jsx-html/.github/workflows/ci.yml b/jsx-html/.github/workflows/ci.yml
new file mode 100644
index 0000000..55edd87
--- /dev/null
+++ b/jsx-html/.github/workflows/ci.yml
@@ -0,0 +1,16 @@
+name: ci
+
+on:
+ push:
+ branches:
+ - master
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ - uses: denolib/setup-deno@master
+ - run: deno --version
+ - run: deno test examples/01.tsx
+ - run: deno test examples/03-async.tsx
diff --git a/jsx-html/.gitignore b/jsx-html/.gitignore
new file mode 100644
index 0000000..cf8e22e
--- /dev/null
+++ b/jsx-html/.gitignore
@@ -0,0 +1,3 @@
+/dist
+node_modules
+tmp
\ No newline at end of file
diff --git a/jsx-html/.prettierrc.json b/jsx-html/.prettierrc.json
new file mode 100644
index 0000000..8455310
--- /dev/null
+++ b/jsx-html/.prettierrc.json
@@ -0,0 +1,5 @@
+{
+ "trailingComma": "all",
+ "tabWidth": 4,
+ "singleQuote": true
+ }
\ No newline at end of file
diff --git a/jsx-html/.vscode/settings.json b/jsx-html/.vscode/settings.json
new file mode 100644
index 0000000..8675ad5
--- /dev/null
+++ b/jsx-html/.vscode/settings.json
@@ -0,0 +1,4 @@
+{
+ "deno.enable": true,
+ "deno.unstable": true
+}
\ No newline at end of file
diff --git a/jsx-html/LICENSE b/jsx-html/LICENSE
new file mode 100644
index 0000000..02484b4
--- /dev/null
+++ b/jsx-html/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Alexandre Piel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/jsx-html/README.md b/jsx-html/README.md
new file mode 100644
index 0000000..18b0d37
--- /dev/null
+++ b/jsx-html/README.md
@@ -0,0 +1,103 @@
+# jsx-html
+
+`jsx-html` render JSX template to HTML asynchronously. Compatible with Deno, NodeJs and can also run in browser.
+
+Try with runkit: https://runkit.com/apiel/jsx-html-example
+
+## NodeJs
+
+```sh
+yarn add async-jsx-html
+# or
+npm install async-jsx-html
+```
+
+```tsx
+import { React } from 'async-jsx-html';
+
+const View = () =>
;
+// render return a Promise
+().render().then((html: string) => console.log(html));
+```
+
+```sh
+deno run https://raw.githubusercontent.com/apiel/jsx-html/master/examples/00.tsx
+```
+
+## TsConfig
+
+As you would do with React, you need to import `React` from `jsx-html` for the transpiler. If you are not feeling confortable with using `React` as import since it is not React, you can import `jsx` from `jsx-html` but you would have to update your tsconfig file: https://github.com/denoland/deno/issues/3572
+
+```json
+{
+ "compilerOptions": {
+ "jsx": "react",
+ "jsxFactory": "jsx"
+ }
+}
+```
+
+```tsx
+///
+
+import { jsx } from 'https://raw.githubusercontent.com/apiel/jsx-html/master/mod.ts';
+
+const View = () =>
Hello
;
+().render().then(console.log);
+```
+
+> **Note:** prefer using sermver tags version instead of master to avoid conflict with caching, e.g:
+> `import { jsx } from 'https://raw.githubusercontent.com/apiel/jsx-html/1.0.0/mod.ts';`.
+
+## Async component
+
+Unlike React, components can be asynchrone, so you can fetch for data without to handle states.
+
+```tsx
+import { React } from 'https://raw.githubusercontent.com/apiel/jsx-html/master/mod.ts';
+
+const Data = async () => {
+ const res = await fetch('http://example.com/some/api');
+ const content = new Uint8Array(await res.arrayBuffer());
+ return
{content}
;
+};
+
+const View = () => (
+
+
+
+);
+
+().render().then(console.log);
+```
+
+# InnerHTML
+
+The Element property innerHTML sets the HTML or XML markup contained within the property.
+
+In general, setting HTML from code is risky because it’s easy to inadvertently expose your users to a cross-site scripting (XSS) attack.
+
+```tsx
+///
+
+import { jsx } from 'https://raw.githubusercontent.com/apiel/jsx-html/master/mod.ts';
+
+const View = () => ;
+().render().then(console.log); // will output
hello world
+```
+
+## Browser
+
+`jsx-html` can also be used directly in browser. Find an example with webpack [here](https://github.com/apiel/jsx-html/tree/master/examples/browser).
diff --git a/jsx-html/babel-remove-ext.js b/jsx-html/babel-remove-ext.js
new file mode 100644
index 0000000..b18d2c0
--- /dev/null
+++ b/jsx-html/babel-remove-ext.js
@@ -0,0 +1,26 @@
+'use strict';
+
+var regExp = /\.(ts|tsx|js|jsx)$/i;
+
+module.exports = function () {
+ return {
+ visitor: {
+ ImportDeclaration: function ImportDeclaration(path) {
+ var source = path.node.source;
+ if (!source.value.match(regExp)) {
+ return;
+ }
+ source.value = source.value.replace(regExp, '');
+ },
+ ExportDeclaration: function ExportDeclaration(path) {
+ var source = path.node.source;
+ if (source) {
+ if (!source.value.match(regExp)) {
+ return;
+ }
+ source.value = source.value.replace(regExp, '');
+ }
+ },
+ },
+ };
+};
diff --git a/jsx-html/constants.ts b/jsx-html/constants.ts
new file mode 100644
index 0000000..fcebc07
--- /dev/null
+++ b/jsx-html/constants.ts
@@ -0,0 +1,6 @@
+export enum NODE_TYPE {
+ ELEMENT = 'element',
+ TEXT = 'text',
+ COMPONENT = 'component',
+ FRAGMENT = 'fragment',
+};
diff --git a/jsx-html/deno.d.ts b/jsx-html/deno.d.ts
new file mode 100644
index 0000000..0d5914d
--- /dev/null
+++ b/jsx-html/deno.d.ts
@@ -0,0 +1,3496 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+///
+///
+
+declare 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;
+ 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 => {
+ * 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;
+
+ /** 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;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+ writeSync(p: Uint8Array): number;
+ read(p: Uint8Array): Promise;
+ readSync(p: Uint8Array): number | null;
+ seek(offset: number, whence: SeekMode): Promise;
+ 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;
+ writeSync(p: Uint8Array): number;
+ /** NOTE: This methods writes bytes sychronously; it's provided for
+ * compatibility with `Writer` interface. */
+ write(p: Uint8Array): Promise;
+ /** 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;
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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;
+
+ 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 {
+ /** Waits for and resolves to the next connection to the `Listener`. */
+ accept(): Promise;
+ /** 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;
+ }
+
+ 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;
+
+ 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;
+
+ 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;
+
+ 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;
+ /** 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;
+ /** 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;
+ 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 */
+
+///
+///
+
+// 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;
+
+ /** 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): Promise;
+
+ /** 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;
+
+ /** 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;
+
+ /** 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,
+ importObject?: object
+ ): Promise;
+
+ /** 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 {
+ 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 {
+ keys(): IterableIterator;
+ values(): IterableIterator;
+ entries(): IterableIterator<[K, V]>;
+ [Symbol.iterator](): IterableIterator<[K, V]>;
+ forEach(
+ callback: (value: V, key: K, parent: this) => void,
+ thisArg?: any
+ ): void;
+}
+
+interface ReadableStreamReadDoneResult {
+ done: true;
+ value?: T;
+}
+
+interface ReadableStreamReadValueResult {
+ done: false;
+ value: T;
+}
+
+type ReadableStreamReadResult =
+ | ReadableStreamReadValueResult
+ | ReadableStreamReadDoneResult;
+
+interface ReadableStreamDefaultReader {
+ readonly closed: Promise;
+ cancel(reason?: any): Promise;
+ read(): Promise>;
+ releaseLock(): void;
+}
+
+interface ReadableStreamReader {
+ cancel(): Promise;
+ read(): Promise>;
+ releaseLock(): void;
+}
+
+interface ReadableByteStreamControllerCallback {
+ (controller: ReadableByteStreamController): void | PromiseLike;
+}
+
+interface UnderlyingByteSource {
+ autoAllocateChunkSize?: number;
+ cancel?: ReadableStreamErrorCallback;
+ pull?: ReadableByteStreamControllerCallback;
+ start?: ReadableByteStreamControllerCallback;
+ type: "bytes";
+}
+
+interface UnderlyingSource {
+ cancel?: ReadableStreamErrorCallback;
+ pull?: ReadableStreamDefaultControllerCallback;
+ start?: ReadableStreamDefaultControllerCallback;
+ type?: undefined;
+}
+
+interface ReadableStreamErrorCallback {
+ (reason: any): void | PromiseLike;
+}
+
+interface ReadableStreamDefaultControllerCallback {
+ (controller: ReadableStreamDefaultController): void | PromiseLike;
+}
+
+interface ReadableStreamDefaultController {
+ 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 {
+ (chunk: T): number;
+}
+
+interface QueuingStrategy {
+ highWaterMark?: number;
+ size?: QueuingStrategySizeCallback;
+}
+
+/** 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 {
+ 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 {
+ readonly locked: boolean;
+ cancel(reason?: any): Promise;
+ getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator;
+ // getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
+ getReader(): ReadableStreamDefaultReader;
+ pipeThrough(
+ {
+ writable,
+ readable,
+ }: {
+ writable: WritableStream;
+ readable: ReadableStream;
+ },
+ options?: PipeOptions
+ ): ReadableStream;
+ pipeTo(dest: WritableStream, options?: PipeOptions): Promise;
+ tee(): [ReadableStream, ReadableStream];
+ [Symbol.asyncIterator](options?: {
+ preventCancel?: boolean;
+ }): AsyncIterableIterator;
+}
+
+declare var ReadableStream: {
+ prototype: ReadableStream;
+ new (
+ underlyingSource: UnderlyingByteSource,
+ strategy?: { highWaterMark?: number; size?: undefined }
+ ): ReadableStream;
+ new (
+ underlyingSource?: UnderlyingSource,
+ strategy?: QueuingStrategy
+ ): ReadableStream;
+};
+
+interface WritableStreamDefaultControllerCloseCallback {
+ (): void | PromiseLike;
+}
+
+interface WritableStreamDefaultControllerStartCallback {
+ (controller: WritableStreamDefaultController): void | PromiseLike;
+}
+
+interface WritableStreamDefaultControllerWriteCallback {
+ (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<
+ void
+ >;
+}
+
+interface WritableStreamErrorCallback {
+ (reason: any): void | PromiseLike;
+}
+
+interface UnderlyingSink {
+ abort?: WritableStreamErrorCallback;
+ close?: WritableStreamDefaultControllerCloseCallback;
+ start?: WritableStreamDefaultControllerStartCallback;
+ type?: undefined;
+ write?: WritableStreamDefaultControllerWriteCallback;
+}
+
+/** 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 {
+ constructor(
+ underlyingSink?: UnderlyingSink,
+ strategy?: QueuingStrategy
+ );
+ readonly locked: boolean;
+ abort(reason?: any): Promise;
+ close(): Promise;
+ getWriter(): WritableStreamDefaultWriter;
+}
+
+/** 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 {
+ readonly closed: Promise;
+ readonly desiredSize: number | null;
+ readonly ready: Promise;
+ abort(reason?: any): Promise;
+ close(): Promise;
+ releaseLock(): void;
+ write(chunk: W): Promise;
+}
+
+declare class TransformStream {
+ constructor(
+ transformer?: Transformer,
+ writableStrategy?: QueuingStrategy,
+ readableStrategy?: QueuingStrategy
+ );
+ readonly readable: ReadableStream;
+ readonly writable: WritableStream;
+}
+
+interface TransformStreamDefaultController {
+ readonly desiredSize: number | null;
+ enqueue(chunk: O): void;
+ error(reason?: any): void;
+ terminate(): void;
+}
+
+interface Transformer {
+ flush?: TransformStreamDefaultControllerCallback;
+ readableType?: undefined;
+ start?: TransformStreamDefaultControllerCallback;
+ transform?: TransformStreamDefaultControllerTransformCallback;
+ writableType?: undefined;
+}
+
+interface TransformStreamDefaultControllerCallback {
+ (controller: TransformStreamDefaultController): void | PromiseLike;
+}
+
+interface TransformStreamDefaultControllerTransformCallback {
+ (
+ chunk: I,
+ controller: TransformStreamDefaultController
+ ): void | PromiseLike;
+}
+
+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;
+ slice(start?: number, end?: number, contentType?: string): Blob;
+ stream(): ReadableStream;
+ text(): Promise;
+}
+
+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 {
+ 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 | 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;
+ /** Takes a `Response` stream and reads it to completion. It returns a promise
+ * that resolves with a `Blob`.
+ */
+ blob(): Promise;
+ /** Takes a `Response` stream and reads it to completion. It returns a promise
+ * that resolves with a `FormData` object.
+ */
+ formData(): Promise;
+ /** 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;
+ /** Takes a `Response` stream and reads it to completion. It returns a promise
+ * that resolves with a `USVString` (text).
+ */
+ text(): Promise;
+}
+
+type HeadersInit = Headers | string[][] | Record;
+
+/** 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 {
+ /** 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;
+ /** 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;
+ 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
+ | 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;
+ 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;
+
+/** 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;
+
+ /** 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;
+
+ /** 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 | 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;
+}
+
+interface EventListenerObject {
+ handleEvent(evt: Event): void | Promise;
+}
+
+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
+ * ,