From 1b2d85eeef07de2e877defdd940dddc515725b69 Mon Sep 17 00:00:00 2001 From: Fabian Stamm Date: Wed, 14 Oct 2020 02:56:11 +0200 Subject: [PATCH] Adding hotfixes for packages --- .gitignore | 1 + jsx-html/.github/workflows/ci.yml | 16 + jsx-html/.gitignore | 3 + jsx-html/.prettierrc.json | 5 + jsx-html/.vscode/settings.json | 4 + jsx-html/LICENSE | 21 + jsx-html/README.md | 103 + jsx-html/babel-remove-ext.js | 26 + jsx-html/constants.ts | 6 + jsx-html/deno.d.ts | 3496 +++++++++++++++ jsx-html/deno.json | 17 + jsx-html/deno2nodejs.js | 101 + jsx-html/examples/00.tsx | 6 + jsx-html/examples/01.tsx | 62 + jsx-html/examples/02/02.tsx | 6 + jsx-html/examples/02/tsconfig.json | 6 + jsx-html/examples/03-async.tsx | 30 + jsx-html/examples/04.tsx | 9 + jsx-html/examples/05.tsx | 27 + jsx-html/examples/06.tsx | 19 + jsx-html/examples/browser/dist/index.html | 19 + jsx-html/examples/browser/dist/index.js | 502 +++ jsx-html/examples/browser/package.json | 25 + jsx-html/examples/browser/src/index.tsx | 5 + jsx-html/examples/browser/tsconfig.json | 15 + jsx-html/examples/browser/webpack.config.js | 33 + jsx-html/examples/browser/yarn.lock | 3846 +++++++++++++++++ jsx-html/examples/node_01.js | 30 + jsx-html/examples/node_01.jsx | 22 + jsx-html/jsx.d.ts | 5 + jsx-html/jsx.ts | 33 + jsx-html/meta.json | 12 + jsx-html/mod.ts | 27 + jsx-html/node/ComponentNode.ts | 37 + jsx-html/node/ElementNode.ts | 91 + jsx-html/node/FragmentNode.ts | 15 + jsx-html/node/Node.ts | 29 + jsx-html/node/TextNode.ts | 12 + jsx-html/node/utils/htmlEncode.ts | 13 + jsx-html/node/utils/normalizeChildren.ts | 31 + jsx-html/nodejs/constants.d.ts | 6 + jsx-html/nodejs/constants.js | 12 + jsx-html/nodejs/constants.js.map | 1 + jsx-html/nodejs/jsx.d.ts | 5 + jsx-html/nodejs/jsx.js | 19 + jsx-html/nodejs/jsx.js.map | 1 + jsx-html/nodejs/mod.d.ts | 9 + jsx-html/nodejs/mod.js | 17 + jsx-html/nodejs/mod.js.map | 1 + jsx-html/nodejs/node/ComponentNode.d.ts | 11 + jsx-html/nodejs/node/ComponentNode.js | 43 + jsx-html/nodejs/node/ComponentNode.js.map | 1 + jsx-html/nodejs/node/ElementNode.d.ts | 12 + jsx-html/nodejs/node/ElementNode.js | 60 + jsx-html/nodejs/node/ElementNode.js.map | 1 + jsx-html/nodejs/node/FragmentNode.d.ts | 8 + jsx-html/nodejs/node/FragmentNode.js | 16 + jsx-html/nodejs/node/FragmentNode.js.map | 1 + jsx-html/nodejs/node/Node.d.ts | 9 + jsx-html/nodejs/node/Node.js | 38 + jsx-html/nodejs/node/Node.js.map | 1 + jsx-html/nodejs/node/TextNode.d.ts | 7 + jsx-html/nodejs/node/TextNode.js | 27 + jsx-html/nodejs/node/TextNode.js.map | 1 + jsx-html/nodejs/node/utils/htmlEncode.d.ts | 2 + jsx-html/nodejs/node/utils/htmlEncode.js | 12 + jsx-html/nodejs/node/utils/htmlEncode.js.map | 1 + .../nodejs/node/utils/normalizeChildren.d.ts | 2 + .../nodejs/node/utils/normalizeChildren.js | 27 + .../node/utils/normalizeChildren.js.map | 1 + jsx-html/nodejs/types.d.ts | 15 + jsx-html/nodejs/types.js | 3 + jsx-html/nodejs/types.js.map | 1 + jsx-html/note.md | 16 + jsx-html/package.json | 25 + jsx-html/types.ts | 23 + jsx-html/yarn.lock | 1267 ++++++ markdown/.vscode/launch.json | 14 + markdown/.vscode/settings.json | 9 + markdown/LICENSE | 21 + markdown/README.md | 62 + markdown/example.html | Bin 0 -> 1952 bytes markdown/example.md | 34 + markdown/md2html.ts | 8 + markdown/meta.json | 12 + markdown/mod.ts | 8 + markdown/src/block-lexer.ts | 520 +++ markdown/src/extend-regexp.ts | 43 + markdown/src/helpers.ts | 64 + markdown/src/inline-lexer.ts | 419 ++ markdown/src/interfaces.ts | 196 + markdown/src/marked.ts | 154 + markdown/src/parser.ts | 247 ++ markdown/src/renderer.ts | 179 + registry/src/deps.ts | 11 +- 95 files changed, 12467 insertions(+), 2 deletions(-) create mode 100644 .gitignore create mode 100644 jsx-html/.github/workflows/ci.yml create mode 100644 jsx-html/.gitignore create mode 100644 jsx-html/.prettierrc.json create mode 100644 jsx-html/.vscode/settings.json create mode 100644 jsx-html/LICENSE create mode 100644 jsx-html/README.md create mode 100644 jsx-html/babel-remove-ext.js create mode 100644 jsx-html/constants.ts create mode 100644 jsx-html/deno.d.ts create mode 100644 jsx-html/deno.json create mode 100644 jsx-html/deno2nodejs.js create mode 100644 jsx-html/examples/00.tsx create mode 100644 jsx-html/examples/01.tsx create mode 100644 jsx-html/examples/02/02.tsx create mode 100644 jsx-html/examples/02/tsconfig.json create mode 100644 jsx-html/examples/03-async.tsx create mode 100644 jsx-html/examples/04.tsx create mode 100644 jsx-html/examples/05.tsx create mode 100644 jsx-html/examples/06.tsx create mode 100644 jsx-html/examples/browser/dist/index.html create mode 100644 jsx-html/examples/browser/dist/index.js create mode 100644 jsx-html/examples/browser/package.json create mode 100644 jsx-html/examples/browser/src/index.tsx create mode 100644 jsx-html/examples/browser/tsconfig.json create mode 100644 jsx-html/examples/browser/webpack.config.js create mode 100644 jsx-html/examples/browser/yarn.lock create mode 100644 jsx-html/examples/node_01.js create mode 100644 jsx-html/examples/node_01.jsx create mode 100644 jsx-html/jsx.d.ts create mode 100644 jsx-html/jsx.ts create mode 100644 jsx-html/meta.json create mode 100644 jsx-html/mod.ts create mode 100644 jsx-html/node/ComponentNode.ts create mode 100644 jsx-html/node/ElementNode.ts create mode 100644 jsx-html/node/FragmentNode.ts create mode 100644 jsx-html/node/Node.ts create mode 100644 jsx-html/node/TextNode.ts create mode 100644 jsx-html/node/utils/htmlEncode.ts create mode 100644 jsx-html/node/utils/normalizeChildren.ts create mode 100644 jsx-html/nodejs/constants.d.ts create mode 100644 jsx-html/nodejs/constants.js create mode 100644 jsx-html/nodejs/constants.js.map create mode 100644 jsx-html/nodejs/jsx.d.ts create mode 100644 jsx-html/nodejs/jsx.js create mode 100644 jsx-html/nodejs/jsx.js.map create mode 100644 jsx-html/nodejs/mod.d.ts create mode 100644 jsx-html/nodejs/mod.js create mode 100644 jsx-html/nodejs/mod.js.map create mode 100644 jsx-html/nodejs/node/ComponentNode.d.ts create mode 100644 jsx-html/nodejs/node/ComponentNode.js create mode 100644 jsx-html/nodejs/node/ComponentNode.js.map create mode 100644 jsx-html/nodejs/node/ElementNode.d.ts create mode 100644 jsx-html/nodejs/node/ElementNode.js create mode 100644 jsx-html/nodejs/node/ElementNode.js.map create mode 100644 jsx-html/nodejs/node/FragmentNode.d.ts create mode 100644 jsx-html/nodejs/node/FragmentNode.js create mode 100644 jsx-html/nodejs/node/FragmentNode.js.map create mode 100644 jsx-html/nodejs/node/Node.d.ts create mode 100644 jsx-html/nodejs/node/Node.js create mode 100644 jsx-html/nodejs/node/Node.js.map create mode 100644 jsx-html/nodejs/node/TextNode.d.ts create mode 100644 jsx-html/nodejs/node/TextNode.js create mode 100644 jsx-html/nodejs/node/TextNode.js.map create mode 100644 jsx-html/nodejs/node/utils/htmlEncode.d.ts create mode 100644 jsx-html/nodejs/node/utils/htmlEncode.js create mode 100644 jsx-html/nodejs/node/utils/htmlEncode.js.map create mode 100644 jsx-html/nodejs/node/utils/normalizeChildren.d.ts create mode 100644 jsx-html/nodejs/node/utils/normalizeChildren.js create mode 100644 jsx-html/nodejs/node/utils/normalizeChildren.js.map create mode 100644 jsx-html/nodejs/types.d.ts create mode 100644 jsx-html/nodejs/types.js create mode 100644 jsx-html/nodejs/types.js.map create mode 100644 jsx-html/note.md create mode 100644 jsx-html/package.json create mode 100644 jsx-html/types.ts create mode 100644 jsx-html/yarn.lock create mode 100644 markdown/.vscode/launch.json create mode 100644 markdown/.vscode/settings.json create mode 100644 markdown/LICENSE create mode 100644 markdown/README.md create mode 100644 markdown/example.html create mode 100644 markdown/example.md create mode 100644 markdown/md2html.ts create mode 100644 markdown/meta.json create mode 100644 markdown/mod.ts create mode 100644 markdown/src/block-lexer.ts create mode 100644 markdown/src/extend-regexp.ts create mode 100644 markdown/src/helpers.ts create mode 100644 markdown/src/inline-lexer.ts create mode 100644 markdown/src/interfaces.ts create mode 100644 markdown/src/marked.ts create mode 100644 markdown/src/parser.ts create mode 100644 markdown/src/renderer.ts 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 = () =>
Hello
; +// render return a Promise +().render().then((html: string) => console.log(html)); +``` + +## Deno + +```tsx +/// + +import { React } from 'https://raw.githubusercontent.com/apiel/jsx-html/master/mod.ts'; + +const View = () =>
Hello
; +// 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 + * ,