mirror of
https://github.com/denoland/deno.git
synced 2024-10-30 09:08:00 -04:00
1530 lines
47 KiB
TypeScript
Vendored
1530 lines
47 KiB
TypeScript
Vendored
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
||
|
||
/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, no-var */
|
||
|
||
/// <reference no-default-lib="true" />
|
||
/// <reference lib="esnext" />
|
||
/// <reference lib="deno.web" />
|
||
|
||
// This follows the WebIDL at: https://webassembly.github.io/spec/js-api/
|
||
// and: https://webassembly.github.io/spec/web-api/
|
||
declare namespace WebAssembly {
|
||
interface WebAssemblyInstantiatedSource {
|
||
module: Module;
|
||
instance: Instance;
|
||
}
|
||
|
||
/** Compiles a `WebAssembly.Module` from WebAssembly binary code. This
|
||
* function is useful if it is necessary to a compile a module before it can
|
||
* be instantiated (otherwise, the `WebAssembly.instantiate()` function
|
||
* should be used). */
|
||
function compile(bufferSource: BufferSource): Promise<Module>;
|
||
|
||
/** Compiles a `WebAssembly.Module` directly from a streamed underlying
|
||
* source. This function is useful if it is necessary to a compile a module
|
||
* before it can be instantiated (otherwise, the
|
||
* `WebAssembly.instantiateStreaming()` function should be used). */
|
||
function compileStreaming(source: Promise<Response>): Promise<Module>;
|
||
|
||
/** Takes the WebAssembly binary code, in the form of a typed array or
|
||
* `ArrayBuffer`, and performs both compilation and instantiation in one step.
|
||
* The returned `Promise` resolves to both a compiled `WebAssembly.Module` and
|
||
* its first `WebAssembly.Instance`. */
|
||
function instantiate(
|
||
bufferSource: BufferSource,
|
||
importObject?: object,
|
||
): Promise<WebAssemblyInstantiatedSource>;
|
||
|
||
/** Takes an already-compiled `WebAssembly.Module` and returns a `Promise`
|
||
* that resolves to an `Instance` of that `Module`. This overload is useful if
|
||
* the `Module` has already been compiled. */
|
||
function instantiate(
|
||
module: Module,
|
||
importObject?: object,
|
||
): Promise<Instance>;
|
||
|
||
/** Compiles and instantiates a WebAssembly module directly from a streamed
|
||
* underlying source. This is the most efficient, optimized way to load wasm
|
||
* code. */
|
||
function instantiateStreaming(
|
||
source: Promise<Response>,
|
||
importObject?: object,
|
||
): Promise<WebAssemblyInstantiatedSource>;
|
||
|
||
/** Validates a given typed array of WebAssembly binary code, returning
|
||
* whether the bytes form a valid wasm module (`true`) or not (`false`). */
|
||
function validate(bufferSource: BufferSource): boolean;
|
||
|
||
type ImportExportKind = "function" | "table" | "memory" | "global";
|
||
|
||
interface ModuleExportDescriptor {
|
||
name: string;
|
||
kind: ImportExportKind;
|
||
}
|
||
interface ModuleImportDescriptor {
|
||
module: string;
|
||
name: string;
|
||
kind: ImportExportKind;
|
||
}
|
||
|
||
class Module {
|
||
constructor(bufferSource: BufferSource);
|
||
|
||
/** Given a `Module` and string, returns a copy of the contents of all
|
||
* custom sections in the module with the given string name. */
|
||
static customSections(
|
||
moduleObject: Module,
|
||
sectionName: string,
|
||
): ArrayBuffer;
|
||
|
||
/** Given a `Module`, returns an array containing descriptions of all the
|
||
* declared exports. */
|
||
static exports(moduleObject: Module): ModuleExportDescriptor[];
|
||
|
||
/** Given a `Module`, returns an array containing descriptions of all the
|
||
* declared imports. */
|
||
static imports(moduleObject: Module): ModuleImportDescriptor[];
|
||
}
|
||
|
||
class Instance<T extends object = { [key: string]: any }> {
|
||
constructor(module: Module, importObject?: object);
|
||
|
||
/** An object containing as its members all the functions exported from the
|
||
* WebAssembly module instance, to allow them to be accessed and used by
|
||
* JavaScript. */
|
||
readonly exports: T;
|
||
}
|
||
|
||
interface MemoryDescriptor {
|
||
initial: number;
|
||
maximum?: number;
|
||
}
|
||
|
||
class Memory {
|
||
constructor(descriptor: MemoryDescriptor);
|
||
|
||
/** An accessor property that returns the buffer contained in the memory. */
|
||
readonly buffer: ArrayBuffer;
|
||
|
||
/** Increases the size of the memory instance by a specified number of
|
||
* WebAssembly pages (each one is 64KB in size). */
|
||
grow(delta: number): number;
|
||
}
|
||
|
||
type TableKind = "anyfunc";
|
||
|
||
interface TableDescriptor {
|
||
element: TableKind;
|
||
initial: number;
|
||
maximum?: number;
|
||
}
|
||
|
||
class Table {
|
||
constructor(descriptor: TableDescriptor);
|
||
|
||
/** Returns the length of the table, i.e. the number of elements. */
|
||
readonly length: number;
|
||
|
||
/** Accessor function — gets the element stored at a given index. */
|
||
get(index: number): (...args: any[]) => any;
|
||
|
||
/** Increases the size of the Table instance by a specified number of
|
||
* elements. */
|
||
grow(delta: number): number;
|
||
|
||
/** Sets an element stored at a given index to a given value. */
|
||
set(index: number, value: (...args: any[]) => any): void;
|
||
}
|
||
|
||
type ValueType = "i32" | "i64" | "f32" | "f64";
|
||
|
||
interface GlobalDescriptor {
|
||
value: ValueType;
|
||
mutable?: boolean;
|
||
}
|
||
|
||
/** Represents a global variable instance, accessible from both JavaScript and
|
||
* importable/exportable across one or more `WebAssembly.Module` instances.
|
||
* This allows dynamic linking of multiple modules. */
|
||
class Global {
|
||
constructor(descriptor: GlobalDescriptor, value?: any);
|
||
|
||
/** Old-style method that returns the value contained inside the global
|
||
* variable. */
|
||
valueOf(): any;
|
||
|
||
/** The value contained inside the global variable — this can be used to
|
||
* directly set and get the global's value. */
|
||
value: any;
|
||
}
|
||
|
||
/** Indicates an error during WebAssembly decoding or validation */
|
||
class CompileError extends Error {
|
||
constructor(message: string, fileName?: string, lineNumber?: string);
|
||
}
|
||
|
||
/** Indicates an error during module instantiation (besides traps from the
|
||
* start function). */
|
||
class LinkError extends Error {
|
||
constructor(message: string, fileName?: string, lineNumber?: string);
|
||
}
|
||
|
||
/** Is thrown whenever WebAssembly specifies a trap. */
|
||
class RuntimeError extends Error {
|
||
constructor(message: string, fileName?: string, lineNumber?: string);
|
||
}
|
||
}
|
||
|
||
/** Sets a timer which executes a function once after the timer expires. Returns
|
||
* an id which may be used to cancel the timeout.
|
||
*
|
||
* setTimeout(() => { console.log('hello'); }, 500);
|
||
*/
|
||
declare function setTimeout(
|
||
/** callback function to execute when timer expires */
|
||
cb: (...args: any[]) => void,
|
||
/** delay in ms */
|
||
delay?: number,
|
||
/** arguments passed to callback function */
|
||
...args: any[]
|
||
): number;
|
||
|
||
/** Repeatedly calls a function , with a fixed time delay between each call.
|
||
*
|
||
* // Outputs 'hello' to the console every 500ms
|
||
* setInterval(() => { console.log('hello'); }, 500);
|
||
*/
|
||
declare function setInterval(
|
||
/** callback function to execute when timer expires */
|
||
cb: (...args: any[]) => void,
|
||
/** delay in ms */
|
||
delay?: number,
|
||
/** arguments passed to callback function */
|
||
...args: any[]
|
||
): number;
|
||
|
||
/** Cancels a timed, repeating action which was previously started by a call
|
||
* to `setInterval()`
|
||
*
|
||
* const id = setInterval(()= > {console.log('hello');}, 500);
|
||
* ...
|
||
* clearInterval(id);
|
||
*/
|
||
declare function clearInterval(id?: number): void;
|
||
|
||
/** Cancels a scheduled action initiated by `setTimeout()`
|
||
*
|
||
* const id = setTimeout(()= > {console.log('hello');}, 500);
|
||
* ...
|
||
* clearTimeout(id);
|
||
*/
|
||
declare function clearTimeout(id?: number): void;
|
||
|
||
interface VoidFunction {
|
||
(): 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: VoidFunction): 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;
|
||
|
||
interface DomIterable<K, V> {
|
||
keys(): IterableIterator<K>;
|
||
values(): IterableIterator<V>;
|
||
entries(): IterableIterator<[K, V]>;
|
||
[Symbol.iterator](): IterableIterator<[K, V]>;
|
||
forEach(
|
||
callback: (value: V, key: K, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
}
|
||
|
||
interface ReadableStreamReadDoneResult<T> {
|
||
done: true;
|
||
value?: T;
|
||
}
|
||
|
||
interface ReadableStreamReadValueResult<T> {
|
||
done: false;
|
||
value: T;
|
||
}
|
||
|
||
type ReadableStreamReadResult<T> =
|
||
| ReadableStreamReadValueResult<T>
|
||
| ReadableStreamReadDoneResult<T>;
|
||
|
||
interface ReadableStreamDefaultReader<R = any> {
|
||
readonly closed: Promise<void>;
|
||
cancel(reason?: any): Promise<void>;
|
||
read(): Promise<ReadableStreamReadResult<R>>;
|
||
releaseLock(): void;
|
||
}
|
||
|
||
interface ReadableStreamReader<R = any> {
|
||
cancel(): Promise<void>;
|
||
read(): Promise<ReadableStreamReadResult<R>>;
|
||
releaseLock(): void;
|
||
}
|
||
|
||
interface ReadableByteStreamControllerCallback {
|
||
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface UnderlyingByteSource {
|
||
autoAllocateChunkSize?: number;
|
||
cancel?: ReadableStreamErrorCallback;
|
||
pull?: ReadableByteStreamControllerCallback;
|
||
start?: ReadableByteStreamControllerCallback;
|
||
type: "bytes";
|
||
}
|
||
|
||
interface UnderlyingSource<R = any> {
|
||
cancel?: ReadableStreamErrorCallback;
|
||
pull?: ReadableStreamDefaultControllerCallback<R>;
|
||
start?: ReadableStreamDefaultControllerCallback<R>;
|
||
type?: undefined;
|
||
}
|
||
|
||
interface ReadableStreamErrorCallback {
|
||
(reason: any): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface ReadableStreamDefaultControllerCallback<R> {
|
||
(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface ReadableStreamDefaultController<R = any> {
|
||
readonly desiredSize: number | null;
|
||
close(): void;
|
||
enqueue(chunk: R): void;
|
||
error(error?: any): void;
|
||
}
|
||
|
||
interface ReadableByteStreamController {
|
||
readonly byobRequest: undefined;
|
||
readonly desiredSize: number | null;
|
||
close(): void;
|
||
enqueue(chunk: ArrayBufferView): void;
|
||
error(error?: any): void;
|
||
}
|
||
|
||
interface PipeOptions {
|
||
preventAbort?: boolean;
|
||
preventCancel?: boolean;
|
||
preventClose?: boolean;
|
||
signal?: AbortSignal;
|
||
}
|
||
|
||
interface QueuingStrategySizeCallback<T = any> {
|
||
(chunk: T): number;
|
||
}
|
||
|
||
interface QueuingStrategy<T = any> {
|
||
highWaterMark?: number;
|
||
size?: QueuingStrategySizeCallback<T>;
|
||
}
|
||
|
||
/** This Streams API interface provides a built-in byte length queuing strategy
|
||
* that can be used when constructing streams. */
|
||
declare class CountQueuingStrategy implements QueuingStrategy {
|
||
constructor(options: { highWaterMark: number });
|
||
highWaterMark: number;
|
||
size(chunk: any): 1;
|
||
}
|
||
|
||
declare class ByteLengthQueuingStrategy
|
||
implements QueuingStrategy<ArrayBufferView> {
|
||
constructor(options: { highWaterMark: number });
|
||
highWaterMark: number;
|
||
size(chunk: ArrayBufferView): number;
|
||
}
|
||
|
||
/** This Streams API interface represents a readable stream of byte data. The
|
||
* Fetch API offers a concrete instance of a ReadableStream through the body
|
||
* property of a Response object. */
|
||
interface ReadableStream<R = any> {
|
||
readonly locked: boolean;
|
||
cancel(reason?: any): Promise<void>;
|
||
getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
|
||
// getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
|
||
getReader(): ReadableStreamDefaultReader<R>;
|
||
pipeThrough<T>(
|
||
{
|
||
writable,
|
||
readable,
|
||
}: {
|
||
writable: WritableStream<R>;
|
||
readable: ReadableStream<T>;
|
||
},
|
||
options?: PipeOptions,
|
||
): ReadableStream<T>;
|
||
pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
|
||
tee(): [ReadableStream<R>, ReadableStream<R>];
|
||
[Symbol.asyncIterator](options?: {
|
||
preventCancel?: boolean;
|
||
}): AsyncIterableIterator<R>;
|
||
}
|
||
|
||
declare var ReadableStream: {
|
||
prototype: ReadableStream;
|
||
new (
|
||
underlyingSource: UnderlyingByteSource,
|
||
strategy?: { highWaterMark?: number; size?: undefined },
|
||
): ReadableStream<Uint8Array>;
|
||
new <R = any>(
|
||
underlyingSource?: UnderlyingSource<R>,
|
||
strategy?: QueuingStrategy<R>,
|
||
): ReadableStream<R>;
|
||
};
|
||
|
||
interface WritableStreamDefaultControllerCloseCallback {
|
||
(): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface WritableStreamDefaultControllerStartCallback {
|
||
(controller: WritableStreamDefaultController): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface WritableStreamDefaultControllerWriteCallback<W> {
|
||
(chunk: W, controller: WritableStreamDefaultController):
|
||
| void
|
||
| PromiseLike<
|
||
void
|
||
>;
|
||
}
|
||
|
||
interface WritableStreamErrorCallback {
|
||
(reason: any): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface UnderlyingSink<W = any> {
|
||
abort?: WritableStreamErrorCallback;
|
||
close?: WritableStreamDefaultControllerCloseCallback;
|
||
start?: WritableStreamDefaultControllerStartCallback;
|
||
type?: undefined;
|
||
write?: WritableStreamDefaultControllerWriteCallback<W>;
|
||
}
|
||
|
||
/** This Streams API interface provides a standard abstraction for writing
|
||
* streaming data to a destination, known as a sink. This object comes with
|
||
* built-in backpressure and queuing. */
|
||
declare class WritableStream<W = any> {
|
||
constructor(
|
||
underlyingSink?: UnderlyingSink<W>,
|
||
strategy?: QueuingStrategy<W>,
|
||
);
|
||
readonly locked: boolean;
|
||
abort(reason?: any): Promise<void>;
|
||
close(): Promise<void>;
|
||
getWriter(): WritableStreamDefaultWriter<W>;
|
||
}
|
||
|
||
/** This Streams API interface represents a controller allowing control of a
|
||
* WritableStream's state. When constructing a WritableStream, the underlying
|
||
* sink is given a corresponding WritableStreamDefaultController instance to
|
||
* manipulate. */
|
||
interface WritableStreamDefaultController {
|
||
error(error?: any): void;
|
||
}
|
||
|
||
/** This Streams API interface is the object returned by
|
||
* WritableStream.getWriter() and once created locks the < writer to the
|
||
* WritableStream ensuring that no other streams can write to the underlying
|
||
* sink. */
|
||
interface WritableStreamDefaultWriter<W = any> {
|
||
readonly closed: Promise<void>;
|
||
readonly desiredSize: number | null;
|
||
readonly ready: Promise<void>;
|
||
abort(reason?: any): Promise<void>;
|
||
close(): Promise<void>;
|
||
releaseLock(): void;
|
||
write(chunk: W): Promise<void>;
|
||
}
|
||
|
||
declare class TransformStream<I = any, O = any> {
|
||
constructor(
|
||
transformer?: Transformer<I, O>,
|
||
writableStrategy?: QueuingStrategy<I>,
|
||
readableStrategy?: QueuingStrategy<O>,
|
||
);
|
||
readonly readable: ReadableStream<O>;
|
||
readonly writable: WritableStream<I>;
|
||
}
|
||
|
||
interface TransformStreamDefaultController<O = any> {
|
||
readonly desiredSize: number | null;
|
||
enqueue(chunk: O): void;
|
||
error(reason?: any): void;
|
||
terminate(): void;
|
||
}
|
||
|
||
interface Transformer<I = any, O = any> {
|
||
flush?: TransformStreamDefaultControllerCallback<O>;
|
||
readableType?: undefined;
|
||
start?: TransformStreamDefaultControllerCallback<O>;
|
||
transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
|
||
writableType?: undefined;
|
||
}
|
||
|
||
interface TransformStreamDefaultControllerCallback<O> {
|
||
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface TransformStreamDefaultControllerTransformCallback<I, O> {
|
||
(
|
||
chunk: I,
|
||
controller: TransformStreamDefaultController<O>,
|
||
): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface DOMStringList {
|
||
/** Returns the number of strings in strings. */
|
||
readonly length: number;
|
||
/** Returns true if strings contains string, and false otherwise. */
|
||
contains(string: string): boolean;
|
||
/** Returns the string with index index from strings. */
|
||
item(index: number): string | null;
|
||
[index: number]: string;
|
||
}
|
||
|
||
type BufferSource = ArrayBufferView | ArrayBuffer;
|
||
type BlobPart = BufferSource | Blob | string;
|
||
|
||
interface BlobPropertyBag {
|
||
type?: string;
|
||
ending?: "transparent" | "native";
|
||
}
|
||
|
||
/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
|
||
interface Blob {
|
||
readonly size: number;
|
||
readonly type: string;
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
slice(start?: number, end?: number, contentType?: string): Blob;
|
||
stream(): ReadableStream;
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
declare const Blob: {
|
||
prototype: Blob;
|
||
new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
|
||
};
|
||
|
||
interface FilePropertyBag extends BlobPropertyBag {
|
||
lastModified?: number;
|
||
}
|
||
|
||
/** Provides information about files and allows JavaScript in a web page to
|
||
* access their content. */
|
||
interface File extends Blob {
|
||
readonly lastModified: number;
|
||
readonly name: string;
|
||
}
|
||
|
||
declare const File: {
|
||
prototype: File;
|
||
new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
|
||
};
|
||
|
||
interface FileReaderEventMap {
|
||
"abort": ProgressEvent<FileReader>;
|
||
"error": ProgressEvent<FileReader>;
|
||
"load": ProgressEvent<FileReader>;
|
||
"loadend": ProgressEvent<FileReader>;
|
||
"loadstart": ProgressEvent<FileReader>;
|
||
"progress": ProgressEvent<FileReader>;
|
||
}
|
||
|
||
/** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
|
||
interface FileReader extends EventTarget {
|
||
readonly error: DOMException | null;
|
||
onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
||
readonly readyState: number;
|
||
readonly result: string | ArrayBuffer | null;
|
||
abort(): void;
|
||
readAsArrayBuffer(blob: Blob): void;
|
||
readAsBinaryString(blob: Blob): void;
|
||
readAsDataURL(blob: Blob): void;
|
||
readAsText(blob: Blob, encoding?: string): void;
|
||
readonly DONE: number;
|
||
readonly EMPTY: number;
|
||
readonly LOADING: number;
|
||
addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
||
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
||
removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
||
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
||
}
|
||
|
||
declare var FileReader: {
|
||
prototype: FileReader;
|
||
new(): FileReader;
|
||
readonly DONE: number;
|
||
readonly EMPTY: number;
|
||
readonly LOADING: number;
|
||
};
|
||
|
||
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;
|
||
|
||
/** 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`.
|
||
*
|
||
* > [Console.dirxml](https://developer.mozilla.org/en-US/docs/Web/API/Console/dirxml)
|
||
* > by Mozilla Contributors is licensed under CC-BY-SA 2.5.
|
||
*/
|
||
dirxml: (
|
||
obj: unknown,
|
||
options?: Partial<{
|
||
showHidden: boolean;
|
||
depth: number;
|
||
colors: boolean;
|
||
indentLevel: number;
|
||
}>,
|
||
) => void;
|
||
|
||
/** Writes the arguments to stdout */
|
||
warn: (...args: unknown[]) => void;
|
||
/** Writes the arguments to stdout */
|
||
error: (...args: unknown[]) => void;
|
||
/** Writes an error message to stdout if the assertion is `false`. If the
|
||
* assertion is `true`, nothing happens.
|
||
*
|
||
* ref: https://console.spec.whatwg.org/#assert
|
||
*/
|
||
assert: (condition?: boolean, ...args: unknown[]) => void;
|
||
count: (label?: string) => void;
|
||
countReset: (label?: string) => void;
|
||
table: (data: unknown, properties?: string[] | undefined) => void;
|
||
time: (label?: string) => void;
|
||
timeLog: (label?: string, ...args: unknown[]) => void;
|
||
timeEnd: (label?: string) => void;
|
||
group: (...label: unknown[]) => void;
|
||
groupCollapsed: (...label: unknown[]) => void;
|
||
groupEnd: () => void;
|
||
clear: () => void;
|
||
trace: (...args: unknown[]) => void;
|
||
static [Symbol.hasInstance](instance: Console): boolean;
|
||
}
|
||
|
||
declare interface Crypto {
|
||
readonly subtle: null;
|
||
getRandomValues<
|
||
T extends
|
||
| Int8Array
|
||
| Int16Array
|
||
| Int32Array
|
||
| Uint8Array
|
||
| Uint16Array
|
||
| Uint32Array
|
||
| Uint8ClampedArray
|
||
| Float32Array
|
||
| Float64Array
|
||
| DataView
|
||
| null,
|
||
>(
|
||
array: T,
|
||
): T;
|
||
}
|
||
|
||
type FormDataEntryValue = File | string;
|
||
|
||
/** Provides a way to easily construct a set of key/value pairs representing
|
||
* form fields and their values, which can then be easily sent using the
|
||
* XMLHttpRequest.send() method. It uses the same format a form would use if the
|
||
* encoding type were set to "multipart/form-data". */
|
||
interface FormData extends DomIterable<string, FormDataEntryValue> {
|
||
append(name: string, value: string | Blob, fileName?: string): void;
|
||
delete(name: string): void;
|
||
get(name: string): FormDataEntryValue | null;
|
||
getAll(name: string): FormDataEntryValue[];
|
||
has(name: string): boolean;
|
||
set(name: string, value: string | Blob, fileName?: string): void;
|
||
}
|
||
|
||
declare const FormData: {
|
||
prototype: FormData;
|
||
// TODO(ry) FormData constructor is non-standard.
|
||
// new(form?: HTMLFormElement): FormData;
|
||
new (): FormData;
|
||
};
|
||
|
||
interface Body {
|
||
/** A simple getter used to expose a `ReadableStream` of the body contents. */
|
||
readonly body: ReadableStream<Uint8Array> | null;
|
||
/** Stores a `Boolean` that declares whether the body has been used in a
|
||
* response yet.
|
||
*/
|
||
readonly bodyUsed: boolean;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with an `ArrayBuffer`.
|
||
*/
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `Blob`.
|
||
*/
|
||
blob(): Promise<Blob>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `FormData` object.
|
||
*/
|
||
formData(): Promise<FormData>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with the result of parsing the body text as JSON.
|
||
*/
|
||
json(): Promise<any>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `USVString` (text).
|
||
*/
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
type HeadersInit = Headers | string[][] | Record<string, string>;
|
||
|
||
/** This Fetch API interface allows you to perform various actions on HTTP
|
||
* request and response headers. These actions include retrieving, setting,
|
||
* adding to, and removing. A Headers object has an associated header list,
|
||
* which is initially empty and consists of zero or more name and value pairs.
|
||
* You can add to this using methods like append() (see Examples.) In all
|
||
* methods of this interface, header names are matched by case-insensitive byte
|
||
* sequence. */
|
||
interface Headers {
|
||
append(name: string, value: string): void;
|
||
delete(name: string): void;
|
||
get(name: string): string | null;
|
||
has(name: string): boolean;
|
||
set(name: string, value: string): void;
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: Headers) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
}
|
||
|
||
interface Headers extends DomIterable<string, string> {
|
||
/** Appends a new value onto an existing header inside a `Headers` object, or
|
||
* adds the header if it does not already exist.
|
||
*/
|
||
append(name: string, value: string): void;
|
||
/** Deletes a header from a `Headers` object. */
|
||
delete(name: string): void;
|
||
/** Returns an iterator allowing to go through all key/value pairs
|
||
* contained in this Headers object. The both the key and value of each pairs
|
||
* are ByteString objects.
|
||
*/
|
||
entries(): IterableIterator<[string, string]>;
|
||
/** Returns a `ByteString` sequence of all the values of a header within a
|
||
* `Headers` object with a given name.
|
||
*/
|
||
get(name: string): string | null;
|
||
/** Returns a boolean stating whether a `Headers` object contains a certain
|
||
* header.
|
||
*/
|
||
has(name: string): boolean;
|
||
/** Returns an iterator allowing to go through all keys contained in
|
||
* this Headers object. The keys are ByteString objects.
|
||
*/
|
||
keys(): IterableIterator<string>;
|
||
/** Sets a new value for an existing header inside a Headers object, or adds
|
||
* the header if it does not already exist.
|
||
*/
|
||
set(name: string, value: string): void;
|
||
/** Returns an iterator allowing to go through all values contained in
|
||
* this Headers object. The values are ByteString objects.
|
||
*/
|
||
values(): IterableIterator<string>;
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
/** The Symbol.iterator well-known symbol specifies the default
|
||
* iterator for this Headers object
|
||
*/
|
||
[Symbol.iterator](): IterableIterator<[string, string]>;
|
||
}
|
||
|
||
declare const Headers: {
|
||
prototype: Headers;
|
||
new (init?: HeadersInit): Headers;
|
||
};
|
||
|
||
type RequestInfo = Request | string;
|
||
type RequestCache =
|
||
| "default"
|
||
| "force-cache"
|
||
| "no-cache"
|
||
| "no-store"
|
||
| "only-if-cached"
|
||
| "reload";
|
||
type RequestCredentials = "include" | "omit" | "same-origin";
|
||
type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
|
||
type RequestRedirect = "error" | "follow" | "manual";
|
||
type ReferrerPolicy =
|
||
| ""
|
||
| "no-referrer"
|
||
| "no-referrer-when-downgrade"
|
||
| "origin"
|
||
| "origin-when-cross-origin"
|
||
| "same-origin"
|
||
| "strict-origin"
|
||
| "strict-origin-when-cross-origin"
|
||
| "unsafe-url";
|
||
type BodyInit =
|
||
| Blob
|
||
| BufferSource
|
||
| FormData
|
||
| URLSearchParams
|
||
| ReadableStream<Uint8Array>
|
||
| string;
|
||
type RequestDestination =
|
||
| ""
|
||
| "audio"
|
||
| "audioworklet"
|
||
| "document"
|
||
| "embed"
|
||
| "font"
|
||
| "image"
|
||
| "manifest"
|
||
| "object"
|
||
| "paintworklet"
|
||
| "report"
|
||
| "script"
|
||
| "sharedworker"
|
||
| "style"
|
||
| "track"
|
||
| "video"
|
||
| "worker"
|
||
| "xslt";
|
||
|
||
interface RequestInit {
|
||
/**
|
||
* A BodyInit object or null to set request's body.
|
||
*/
|
||
body?: BodyInit | null;
|
||
/**
|
||
* A string indicating how the request will interact with the browser's cache
|
||
* to set request's cache.
|
||
*/
|
||
cache?: RequestCache;
|
||
/**
|
||
* A string indicating whether credentials will be sent with the request
|
||
* always, never, or only when sent to a same-origin URL. Sets request's
|
||
* credentials.
|
||
*/
|
||
credentials?: RequestCredentials;
|
||
/**
|
||
* A Headers object, an object literal, or an array of two-item arrays to set
|
||
* request's headers.
|
||
*/
|
||
headers?: HeadersInit;
|
||
/**
|
||
* A cryptographic hash of the resource to be fetched by request. Sets
|
||
* request's integrity.
|
||
*/
|
||
integrity?: string;
|
||
/**
|
||
* A boolean to set request's keepalive.
|
||
*/
|
||
keepalive?: boolean;
|
||
/**
|
||
* A string to set request's method.
|
||
*/
|
||
method?: string;
|
||
/**
|
||
* A string to indicate whether the request will use CORS, or will be
|
||
* restricted to same-origin URLs. Sets request's mode.
|
||
*/
|
||
mode?: RequestMode;
|
||
/**
|
||
* A string indicating whether request follows redirects, results in an error
|
||
* upon encountering a redirect, or returns the redirect (in an opaque
|
||
* fashion). Sets request's redirect.
|
||
*/
|
||
redirect?: RequestRedirect;
|
||
/**
|
||
* A string whose value is a same-origin URL, "about:client", or the empty
|
||
* string, to set request's referrer.
|
||
*/
|
||
referrer?: string;
|
||
/**
|
||
* A referrer policy to set request's referrerPolicy.
|
||
*/
|
||
referrerPolicy?: ReferrerPolicy;
|
||
/**
|
||
* An AbortSignal to set request's signal.
|
||
*/
|
||
signal?: AbortSignal | null;
|
||
/**
|
||
* Can only be null. Used to disassociate request from any Window.
|
||
*/
|
||
window?: any;
|
||
}
|
||
|
||
/** This Fetch API interface represents a resource request. */
|
||
interface Request extends Body {
|
||
/**
|
||
* Returns the cache mode associated with request, which is a string
|
||
* indicating how the request will interact with the browser's cache when
|
||
* fetching.
|
||
*/
|
||
readonly cache: RequestCache;
|
||
/**
|
||
* Returns the credentials mode associated with request, which is a string
|
||
* indicating whether credentials will be sent with the request always, never,
|
||
* or only when sent to a same-origin URL.
|
||
*/
|
||
readonly credentials: RequestCredentials;
|
||
/**
|
||
* Returns the kind of resource requested by request, e.g., "document" or "script".
|
||
*/
|
||
readonly destination: RequestDestination;
|
||
/**
|
||
* Returns a Headers object consisting of the headers associated with request.
|
||
* Note that headers added in the network layer by the user agent will not be
|
||
* accounted for in this object, e.g., the "Host" header.
|
||
*/
|
||
readonly headers: Headers;
|
||
/**
|
||
* Returns request's subresource integrity metadata, which is a cryptographic
|
||
* hash of the resource being fetched. Its value consists of multiple hashes
|
||
* separated by whitespace. [SRI]
|
||
*/
|
||
readonly integrity: string;
|
||
/**
|
||
* Returns a boolean indicating whether or not request is for a history
|
||
* navigation (a.k.a. back-forward navigation).
|
||
*/
|
||
readonly isHistoryNavigation: boolean;
|
||
/**
|
||
* Returns a boolean indicating whether or not request is for a reload
|
||
* navigation.
|
||
*/
|
||
readonly isReloadNavigation: boolean;
|
||
/**
|
||
* Returns a boolean indicating whether or not request can outlive the global
|
||
* in which it was created.
|
||
*/
|
||
readonly keepalive: boolean;
|
||
/**
|
||
* Returns request's HTTP method, which is "GET" by default.
|
||
*/
|
||
readonly method: string;
|
||
/**
|
||
* Returns the mode associated with request, which is a string indicating
|
||
* whether the request will use CORS, or will be restricted to same-origin
|
||
* URLs.
|
||
*/
|
||
readonly mode: RequestMode;
|
||
/**
|
||
* Returns the redirect mode associated with request, which is a string
|
||
* indicating how redirects for the request will be handled during fetching. A
|
||
* request will follow redirects by default.
|
||
*/
|
||
readonly redirect: RequestRedirect;
|
||
/**
|
||
* Returns the referrer of request. Its value can be a same-origin URL if
|
||
* explicitly set in init, the empty string to indicate no referrer, and
|
||
* "about:client" when defaulting to the global's default. This is used during
|
||
* fetching to determine the value of the `Referer` header of the request
|
||
* being made.
|
||
*/
|
||
readonly referrer: string;
|
||
/**
|
||
* Returns the referrer policy associated with request. This is used during
|
||
* fetching to compute the value of the request's referrer.
|
||
*/
|
||
readonly referrerPolicy: ReferrerPolicy;
|
||
/**
|
||
* Returns the signal associated with request, which is an AbortSignal object
|
||
* indicating whether or not request has been aborted, and its abort event
|
||
* handler.
|
||
*/
|
||
readonly signal: AbortSignal;
|
||
/**
|
||
* Returns the URL of request as a string.
|
||
*/
|
||
readonly url: string;
|
||
clone(): Request;
|
||
}
|
||
|
||
declare const Request: {
|
||
prototype: Request;
|
||
new (input: RequestInfo, init?: RequestInit): Request;
|
||
};
|
||
|
||
interface ResponseInit {
|
||
headers?: HeadersInit;
|
||
status?: number;
|
||
statusText?: string;
|
||
}
|
||
|
||
type ResponseType =
|
||
| "basic"
|
||
| "cors"
|
||
| "default"
|
||
| "error"
|
||
| "opaque"
|
||
| "opaqueredirect";
|
||
|
||
/** This Fetch API interface represents the response to a request. */
|
||
interface Response extends Body {
|
||
readonly headers: Headers;
|
||
readonly ok: boolean;
|
||
readonly redirected: boolean;
|
||
readonly status: number;
|
||
readonly statusText: string;
|
||
readonly trailer: Promise<Headers>;
|
||
readonly type: ResponseType;
|
||
readonly url: string;
|
||
clone(): Response;
|
||
}
|
||
|
||
declare const Response: {
|
||
prototype: Response;
|
||
new (body?: BodyInit | null, init?: ResponseInit): Response;
|
||
error(): Response;
|
||
redirect(url: string, status?: number): Response;
|
||
};
|
||
|
||
/** Fetch a resource from the network. It returns a Promise that resolves to the
|
||
* Response to that request, whether it is successful or not.
|
||
*
|
||
* const response = await fetch("http://my.json.host/data.json");
|
||
* console.log(response.status); // e.g. 200
|
||
* console.log(response.statusText); // e.g. "OK"
|
||
* const jsonData = await response.json();
|
||
*/
|
||
declare function fetch(
|
||
input: Request | URL | string,
|
||
init?: RequestInit,
|
||
): Promise<Response>;
|
||
|
||
interface URLSearchParams {
|
||
/** Appends a specified key/value pair as a new search parameter.
|
||
*
|
||
* ```ts
|
||
* let searchParams = new URLSearchParams();
|
||
* searchParams.append('name', 'first');
|
||
* searchParams.append('name', 'second');
|
||
* ```
|
||
*/
|
||
append(name: string, value: string): void;
|
||
|
||
/** Deletes the given search parameter and its associated value,
|
||
* from the list of all search parameters.
|
||
*
|
||
* ```ts
|
||
* let searchParams = new URLSearchParams([['name', 'value']]);
|
||
* searchParams.delete('name');
|
||
* ```
|
||
*/
|
||
delete(name: string): void;
|
||
|
||
/** Returns all the values associated with a given search parameter
|
||
* as an array.
|
||
*
|
||
* ```ts
|
||
* searchParams.getAll('name');
|
||
* ```
|
||
*/
|
||
getAll(name: string): string[];
|
||
|
||
/** Returns the first value associated to the given search parameter.
|
||
*
|
||
* ```ts
|
||
* searchParams.get('name');
|
||
* ```
|
||
*/
|
||
get(name: string): string | null;
|
||
|
||
/** Returns a Boolean that indicates whether a parameter with the
|
||
* specified name exists.
|
||
*
|
||
* ```ts
|
||
* searchParams.has('name');
|
||
* ```
|
||
*/
|
||
has(name: string): boolean;
|
||
|
||
/** Sets the value associated with a given search parameter to the
|
||
* given value. If there were several matching values, this method
|
||
* deletes the others. If the search parameter doesn't exist, this
|
||
* method creates it.
|
||
*
|
||
* ```ts
|
||
* searchParams.set('name', 'value');
|
||
* ```
|
||
*/
|
||
set(name: string, value: string): void;
|
||
|
||
/** Sort all key/value pairs contained in this object in place and
|
||
* return undefined. The sort order is according to Unicode code
|
||
* points of the keys.
|
||
*
|
||
* ```ts
|
||
* searchParams.sort();
|
||
* ```
|
||
*/
|
||
sort(): void;
|
||
|
||
/** Calls a function for each element contained in this object in
|
||
* place and return undefined. Optionally accepts an object to use
|
||
* as this when executing callback as second argument.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* params.forEach((value, key, parent) => {
|
||
* console.log(value, key, parent);
|
||
* });
|
||
* ```
|
||
*
|
||
*/
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
|
||
/** Returns an iterator allowing to go through all keys contained
|
||
* in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const key of params.keys()) {
|
||
* console.log(key);
|
||
* }
|
||
* ```
|
||
*/
|
||
keys(): IterableIterator<string>;
|
||
|
||
/** Returns an iterator allowing to go through all values contained
|
||
* in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const value of params.values()) {
|
||
* console.log(value);
|
||
* }
|
||
* ```
|
||
*/
|
||
values(): IterableIterator<string>;
|
||
|
||
/** Returns an iterator allowing to go through all key/value
|
||
* pairs contained in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const [key, value] of params.entries()) {
|
||
* console.log(key, value);
|
||
* }
|
||
* ```
|
||
*/
|
||
entries(): IterableIterator<[string, string]>;
|
||
|
||
/** Returns an iterator allowing to go through all key/value
|
||
* pairs contained in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const [key, value] of params) {
|
||
* console.log(key, value);
|
||
* }
|
||
* ```
|
||
*/
|
||
[Symbol.iterator](): IterableIterator<[string, string]>;
|
||
|
||
/** Returns a query string suitable for use in a URL.
|
||
*
|
||
* ```ts
|
||
* searchParams.toString();
|
||
* ```
|
||
*/
|
||
toString(): string;
|
||
}
|
||
|
||
declare const URLSearchParams: {
|
||
prototype: URLSearchParams;
|
||
new (
|
||
init?: string[][] | Record<string, string> | string | URLSearchParams,
|
||
): URLSearchParams;
|
||
toString(): string;
|
||
};
|
||
|
||
/** The URL interface represents an object providing static methods used for creating object URLs. */
|
||
interface URL {
|
||
hash: string;
|
||
host: string;
|
||
hostname: string;
|
||
href: string;
|
||
toString(): string;
|
||
readonly origin: string;
|
||
password: string;
|
||
pathname: string;
|
||
port: string;
|
||
protocol: string;
|
||
search: string;
|
||
readonly searchParams: URLSearchParams;
|
||
username: string;
|
||
toJSON(): string;
|
||
}
|
||
|
||
declare const URL: {
|
||
prototype: URL;
|
||
new (url: string, 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[];
|
||
}
|
||
|
||
interface ProgressEventInit extends EventInit {
|
||
lengthComputable?: boolean;
|
||
loaded?: number;
|
||
total?: number;
|
||
}
|
||
|
||
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(
|
||
* new URL("deno_worker.ts", import.meta.url).href,
|
||
* { 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 type PerformanceEntryList = PerformanceEntry[];
|
||
|
||
declare interface Performance {
|
||
/** Removes the stored timestamp with the associated name. */
|
||
clearMarks(markName?: string): void;
|
||
|
||
/** Removes stored timestamp with the associated name. */
|
||
clearMeasures(measureName?: string): void;
|
||
|
||
getEntries(): PerformanceEntryList;
|
||
getEntriesByName(name: string, type?: string): PerformanceEntryList;
|
||
getEntriesByType(type: string): PerformanceEntryList;
|
||
|
||
/** Stores a timestamp with the associated name (a "mark"). */
|
||
mark(markName: string, options?: PerformanceMarkOptions): PerformanceMark;
|
||
|
||
/** Stores the `DOMHighResTimeStamp` duration between two marks along with the
|
||
* associated name (a "measure"). */
|
||
measure(
|
||
measureName: string,
|
||
options?: PerformanceMeasureOptions,
|
||
): PerformanceMeasure;
|
||
/** Stores the `DOMHighResTimeStamp` duration between two marks along with the
|
||
* associated name (a "measure"). */
|
||
measure(
|
||
measureName: string,
|
||
startMark?: string,
|
||
endMark?: string,
|
||
): PerformanceMeasure;
|
||
|
||
/** 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!`);
|
||
* ```
|
||
*/
|
||
now(): number;
|
||
}
|
||
|
||
declare const Performance: {
|
||
prototype: Performance;
|
||
new (): Performance;
|
||
};
|
||
|
||
declare const performance: Performance;
|
||
|
||
declare interface PerformanceMarkOptions {
|
||
/** Metadata to be included in the mark. */
|
||
detail?: any;
|
||
|
||
/** Timestamp to be used as the mark time. */
|
||
startTime?: number;
|
||
}
|
||
|
||
declare interface PerformanceMeasureOptions {
|
||
/** Metadata to be included in the measure. */
|
||
detail?: any;
|
||
|
||
/** Timestamp to be used as the start time or string to be used as start
|
||
* mark.*/
|
||
start?: string | number;
|
||
|
||
/** Duration between the start and end times. */
|
||
duration?: number;
|
||
|
||
/** Timestamp to be used as the end time or string to be used as end mark. */
|
||
end?: string | number;
|
||
}
|
||
|
||
/** Encapsulates a single performance metric that is part of the performance
|
||
* timeline. A performance entry can be directly created by making a performance
|
||
* mark or measure (for example by calling the `.mark()` method) at an explicit
|
||
* point in an application. */
|
||
declare class PerformanceEntry {
|
||
readonly duration: number;
|
||
readonly entryType: string;
|
||
readonly name: string;
|
||
readonly startTime: number;
|
||
toJSON(): any;
|
||
}
|
||
|
||
/** `PerformanceMark` is an abstract interface for `PerformanceEntry` objects
|
||
* with an entryType of `"mark"`. Entries of this type are created by calling
|
||
* `performance.mark()` to add a named `DOMHighResTimeStamp` (the mark) to the
|
||
* performance timeline. */
|
||
declare class PerformanceMark extends PerformanceEntry {
|
||
readonly detail: any;
|
||
readonly entryType: "mark";
|
||
constructor(name: string, options?: PerformanceMarkOptions);
|
||
}
|
||
|
||
/** `PerformanceMeasure` is an abstract interface for `PerformanceEntry` objects
|
||
* with an entryType of `"measure"`. Entries of this type are created by calling
|
||
* `performance.measure()` to add a named `DOMHighResTimeStamp` (the measure)
|
||
* between two marks to the performance timeline. */
|
||
declare class PerformanceMeasure extends PerformanceEntry {
|
||
readonly detail: any;
|
||
readonly entryType: "measure";
|
||
}
|
||
|
||
/** Events measuring progress of an underlying process, like an HTTP request
|
||
* (for an XMLHttpRequest, or the loading of the underlying resource of an
|
||
* <img>, <audio>, <video>, <style> or <link>). */
|
||
interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
|
||
readonly lengthComputable: boolean;
|
||
readonly loaded: number;
|
||
readonly target: T | null;
|
||
readonly total: number;
|
||
}
|
||
|
||
declare var ProgressEvent: {
|
||
prototype: ProgressEvent;
|
||
new(type:string, eventInitDict?: ProgressEventInit): ProgressEvent;
|
||
};
|
||
|
||
interface CustomEventInit<T = any> extends EventInit {
|
||
detail?: T;
|
||
}
|
||
|
||
declare class CustomEvent<T = any> extends Event {
|
||
constructor(typeArg: string, eventInitDict?: CustomEventInit<T>);
|
||
/** Returns any custom data event was created with. Typically used for
|
||
* synthetic events. */
|
||
readonly detail: T;
|
||
}
|
||
|
||
/** A controller object that allows you to abort one or more DOM requests as and
|
||
* when desired. */
|
||
declare class AbortController {
|
||
/** Returns the AbortSignal object associated with this object. */
|
||
readonly signal: AbortSignal;
|
||
/** Invoking this method will set this object's AbortSignal's aborted flag and
|
||
* signal to any observers that the associated activity is to be aborted. */
|
||
abort(): void;
|
||
}
|
||
|
||
interface AbortSignalEventMap {
|
||
abort: Event;
|
||
}
|
||
|
||
/** A signal object that allows you to communicate with a DOM request (such as a
|
||
* Fetch) and abort it if required via an AbortController object. */
|
||
interface AbortSignal extends EventTarget {
|
||
/** Returns true if this AbortSignal's AbortController has signaled to abort,
|
||
* and false otherwise. */
|
||
readonly aborted: boolean;
|
||
onabort: ((this: AbortSignal, ev: Event) => any) | null;
|
||
addEventListener<K extends keyof AbortSignalEventMap>(
|
||
type: K,
|
||
listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
|
||
options?: boolean | AddEventListenerOptions,
|
||
): void;
|
||
addEventListener(
|
||
type: string,
|
||
listener: EventListenerOrEventListenerObject,
|
||
options?: boolean | AddEventListenerOptions,
|
||
): void;
|
||
removeEventListener<K extends keyof AbortSignalEventMap>(
|
||
type: K,
|
||
listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
|
||
options?: boolean | EventListenerOptions,
|
||
): void;
|
||
removeEventListener(
|
||
type: string,
|
||
listener: EventListenerOrEventListenerObject,
|
||
options?: boolean | EventListenerOptions,
|
||
): void;
|
||
}
|
||
|
||
declare const AbortSignal: {
|
||
prototype: AbortSignal;
|
||
new (): AbortSignal;
|
||
};
|
||
|
||
interface ErrorConstructor {
|
||
/** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */
|
||
// eslint-disable-next-line @typescript-eslint/ban-types
|
||
captureStackTrace(error: Object, constructor?: Function): void;
|
||
// TODO(nayeemrmn): Support `Error.prepareStackTrace()`. We currently use this
|
||
// internally in a way that makes it unavailable for users.
|
||
}
|