123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
// Documentation partially adapted from [MDN](https://developer.mozilla.org/),// by Mozilla Contributors, which is licensed under CC-BY-SA 2.5.
/// <reference no-default-lib="true" />/// <reference lib="esnext" />/// <reference lib="deno.console" />/// <reference lib="deno.url" />/// <reference lib="deno.web" />/// <reference lib="deno.fetch" />/// <reference lib="deno.websocket" />/// <reference lib="deno.crypto" />/// <reference lib="deno.broadcast_channel" />
declare namespace WebAssembly { /** * The `WebAssembly.CompileError` object indicates an error during WebAssembly decoding or validation. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError) */ export class CompileError extends Error { /** Creates a new `WebAssembly.CompileError` object. */ constructor(); }
/** * A `WebAssembly.Global` object 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. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global) */ export class Global { /** Creates a new `Global` object. */ constructor(descriptor: GlobalDescriptor, v?: any);
/** * The value contained inside the global variable — this can be used to directly set * and get the global's value. */ value: any;
/** Old-style method that returns the value contained inside the global variable. */ valueOf(): any; }
/** * A `WebAssembly.Instance` object is a stateful, executable instance of a `WebAssembly.Module`. * Instance objects contain all the Exported WebAssembly functions that allow calling into * WebAssembly code from JavaScript. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance) */ export class Instance { /** Creates a new Instance object. */ constructor(module: Module, importObject?: Imports);
/** * Returns 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. * Read-only. */ readonly exports: Exports; }
/** * The `WebAssembly.LinkError` object indicates an error during module instantiation * (besides traps from the start function). * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError) */ export class LinkError extends Error { /** Creates a new WebAssembly.LinkError object. */ constructor(); }
/** * The `WebAssembly.Memory` object is a resizable `ArrayBuffer` or `SharedArrayBuffer` that * holds the raw bytes of memory accessed by a WebAssembly Instance. * * A memory created by JavaScript or in WebAssembly code will be accessible and mutable * from both JavaScript and WebAssembly. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) */ export class Memory { /** Creates a new `Memory` object. */ constructor(descriptor: MemoryDescriptor);
/** An accessor property that returns the buffer contained in the memory. */ readonly buffer: ArrayBuffer | SharedArrayBuffer;
/** * Increases the size of the memory instance by a specified number of WebAssembly * pages (each one is 64KB in size). */ grow(delta: number): number; }
/** * A `WebAssembly.Module` object contains stateless WebAssembly code that has already been compiled * by the browser — this can be efficiently shared with Workers, and instantiated multiple times. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) */ export class Module { /** Creates a new `Module` object. */ constructor(bytes: 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[]; }
/** * The `WebAssembly.RuntimeError` object is the error type that is thrown whenever WebAssembly * specifies a trap. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError) */ export class RuntimeError extends Error { /** Creates a new `WebAssembly.RuntimeError` object. */ constructor(); }
/** * The `WebAssembly.Table()` object is a JavaScript wrapper object — an array-like structure * representing a WebAssembly Table, which stores function references. A table created by * JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript * and WebAssembly. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table) */ export class Table { /** Creates a new `Table` object. */ 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): Function | null;
/** 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: Function | null): void; }
/** The `GlobalDescriptor` describes the options you can pass to `new WebAssembly.Global()`. */ export interface GlobalDescriptor { mutable?: boolean; value: ValueType; }
/** The `MemoryDescriptor` describes the options you can pass to `new WebAssembly.Memory()`. */ export interface MemoryDescriptor { initial: number; maximum?: number; shared?: boolean; }
/** A `ModuleExportDescriptor` is the description of a declared export in a `WebAssembly.Module`. */ export interface ModuleExportDescriptor { kind: ImportExportKind; name: string; }
/** A `ModuleImportDescriptor` is the description of a declared import in a `WebAssembly.Module`. */ export interface ModuleImportDescriptor { kind: ImportExportKind; module: string; name: string; }
/** The `TableDescriptor` describes the options you can pass to `new WebAssembly.Table()`. */ export interface TableDescriptor { element: TableKind; initial: number; maximum?: number; }
/** The value returned from `WebAssembly.instantiate`. */ export interface WebAssemblyInstantiatedSource { /* A `WebAssembly.Instance` object that contains all the exported WebAssembly functions. */ instance: Instance;
/** * A `WebAssembly.Module` object representing the compiled WebAssembly module. * This `Module` can be instantiated again, or shared via postMessage(). */ module: Module; }
export type ImportExportKind = "function" | "global" | "memory" | "table"; export type TableKind = "anyfunc"; export type ValueType = "f32" | "f64" | "i32" | "i64"; export type ExportValue = Function | Global | Memory | Table; export type Exports = Record<string, ExportValue>; export type ImportValue = ExportValue | number; export type ModuleImports = Record<string, ImportValue>; export type Imports = Record<string, ModuleImports>;
/** * The `WebAssembly.compile()` function compiles WebAssembly binary code into a * `WebAssembly.Module` object. This function is useful if it is necessary to compile * a module before it can be instantiated (otherwise, the `WebAssembly.instantiate()` * function should be used). * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile) */ export function compile(bytes: BufferSource): Promise<Module>;
/** * The `WebAssembly.compileStreaming()` function 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). * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming) */ export function compileStreaming( source: Response | Promise<Response>, ): Promise<Module>;
/** * The WebAssembly.instantiate() function allows you to compile and instantiate * WebAssembly code. * * This overload 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. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate) */ export function instantiate( bytes: BufferSource, importObject?: Imports, ): Promise<WebAssemblyInstantiatedSource>;
/** * The WebAssembly.instantiate() function allows you to compile and instantiate * WebAssembly code. * * This overload 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. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate) */ export function instantiate( moduleObject: Module, importObject?: Imports, ): Promise<Instance>;
/** * The `WebAssembly.instantiateStreaming()` function compiles and instantiates a * WebAssembly module directly from a streamed underlying source. This is the most * efficient, optimized way to load wasm code. * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming) */ export function instantiateStreaming( response: Response | PromiseLike<Response>, importObject?: Imports, ): Promise<WebAssemblyInstantiatedSource>;
/** * The `WebAssembly.validate()` function validates a given typed array of * WebAssembly binary code, returning whether the bytes form a valid wasm * module (`true`) or not (`false`). * * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate) */ export function validate(bytes: BufferSource): boolean;}
/** Sets a timer which executes a function once after the timer expires. Returns * an id which may be used to cancel the timeout. * * ```ts * 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. * * ```ts * // 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()` * * ```ts * const id = setInterval(() => {console.log('hello');}, 500); * // ... * clearInterval(id); * ``` */declare function clearInterval(id?: number): void;
/** Cancels a scheduled action initiated by `setTimeout()` * * ```ts * 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. * * ```ts * queueMicrotask(() => { console.log('This event loop stack is complete'); }); * ``` */declare function queueMicrotask(func: VoidFunction): 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. * * ```ts * dispatchEvent(new Event('unload')); * ``` */declare function dispatchEvent(event: Event): boolean;
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;
declare var console: Console;
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 AbstractWorkerEventMap { "error": ErrorEvent;}
interface WorkerEventMap extends AbstractWorkerEventMap { "message": MessageEvent; "messageerror": MessageEvent;}
interface WorkerOptions { type?: "classic" | "module"; name?: string;}
declare class Worker extends EventTarget { onerror?: (e: ErrorEvent) => void; onmessage?: (e: MessageEvent) => void; onmessageerror?: (e: MessageEvent) => void; constructor( specifier: string | URL, options?: WorkerOptions, ); postMessage(message: any, transfer: Transferable[]): void; postMessage(message: any, options?: StructuredSerializeOptions): void; addEventListener<K extends keyof WorkerEventMap>( type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions, ): void; addEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions, ): void; removeEventListener<K extends keyof WorkerEventMap>( type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions, ): void; removeEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions, ): void; terminate(): void;}
declare type PerformanceEntryList = PerformanceEntry[];
declare class Performance { constructor();
/** 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 var 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";}
declare 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;}
interface ErrorConstructor { /** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */ 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.}