mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 15:24:46 -05:00
1441 lines
41 KiB
TypeScript
1441 lines
41 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
|
|
// deno-lint-ignore-file no-explicit-any no-var
|
|
|
|
/// <reference no-default-lib="true" />
|
|
/// <reference lib="esnext" />
|
|
|
|
/** @category Platform */
|
|
declare interface DOMException extends Error {
|
|
readonly name: string;
|
|
readonly message: string;
|
|
/** @deprecated */
|
|
readonly code: number;
|
|
readonly INDEX_SIZE_ERR: 1;
|
|
readonly DOMSTRING_SIZE_ERR: 2;
|
|
readonly HIERARCHY_REQUEST_ERR: 3;
|
|
readonly WRONG_DOCUMENT_ERR: 4;
|
|
readonly INVALID_CHARACTER_ERR: 5;
|
|
readonly NO_DATA_ALLOWED_ERR: 6;
|
|
readonly NO_MODIFICATION_ALLOWED_ERR: 7;
|
|
readonly NOT_FOUND_ERR: 8;
|
|
readonly NOT_SUPPORTED_ERR: 9;
|
|
readonly INUSE_ATTRIBUTE_ERR: 10;
|
|
readonly INVALID_STATE_ERR: 11;
|
|
readonly SYNTAX_ERR: 12;
|
|
readonly INVALID_MODIFICATION_ERR: 13;
|
|
readonly NAMESPACE_ERR: 14;
|
|
readonly INVALID_ACCESS_ERR: 15;
|
|
readonly VALIDATION_ERR: 16;
|
|
readonly TYPE_MISMATCH_ERR: 17;
|
|
readonly SECURITY_ERR: 18;
|
|
readonly NETWORK_ERR: 19;
|
|
readonly ABORT_ERR: 20;
|
|
readonly URL_MISMATCH_ERR: 21;
|
|
readonly QUOTA_EXCEEDED_ERR: 22;
|
|
readonly TIMEOUT_ERR: 23;
|
|
readonly INVALID_NODE_TYPE_ERR: 24;
|
|
readonly DATA_CLONE_ERR: 25;
|
|
}
|
|
|
|
/** @category Platform */
|
|
declare var DOMException: {
|
|
readonly prototype: DOMException;
|
|
new (message?: string, name?: string): DOMException;
|
|
readonly INDEX_SIZE_ERR: 1;
|
|
readonly DOMSTRING_SIZE_ERR: 2;
|
|
readonly HIERARCHY_REQUEST_ERR: 3;
|
|
readonly WRONG_DOCUMENT_ERR: 4;
|
|
readonly INVALID_CHARACTER_ERR: 5;
|
|
readonly NO_DATA_ALLOWED_ERR: 6;
|
|
readonly NO_MODIFICATION_ALLOWED_ERR: 7;
|
|
readonly NOT_FOUND_ERR: 8;
|
|
readonly NOT_SUPPORTED_ERR: 9;
|
|
readonly INUSE_ATTRIBUTE_ERR: 10;
|
|
readonly INVALID_STATE_ERR: 11;
|
|
readonly SYNTAX_ERR: 12;
|
|
readonly INVALID_MODIFICATION_ERR: 13;
|
|
readonly NAMESPACE_ERR: 14;
|
|
readonly INVALID_ACCESS_ERR: 15;
|
|
readonly VALIDATION_ERR: 16;
|
|
readonly TYPE_MISMATCH_ERR: 17;
|
|
readonly SECURITY_ERR: 18;
|
|
readonly NETWORK_ERR: 19;
|
|
readonly ABORT_ERR: 20;
|
|
readonly URL_MISMATCH_ERR: 21;
|
|
readonly QUOTA_EXCEEDED_ERR: 22;
|
|
readonly TIMEOUT_ERR: 23;
|
|
readonly INVALID_NODE_TYPE_ERR: 24;
|
|
readonly DATA_CLONE_ERR: 25;
|
|
};
|
|
|
|
/** @category Events */
|
|
declare interface EventInit {
|
|
bubbles?: boolean;
|
|
cancelable?: boolean;
|
|
composed?: boolean;
|
|
}
|
|
|
|
/** An event which takes place in the DOM.
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare interface Event {
|
|
/** 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;
|
|
/** @deprecated */
|
|
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;
|
|
/** @deprecated */
|
|
returnValue: boolean;
|
|
/** @deprecated */
|
|
readonly srcElement: EventTarget | null;
|
|
/** 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[];
|
|
/** @deprecated */
|
|
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
|
|
/** 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 NONE: 0;
|
|
readonly CAPTURING_PHASE: 1;
|
|
readonly AT_TARGET: 2;
|
|
readonly BUBBLING_PHASE: 3;
|
|
}
|
|
|
|
/** An event which takes place in the DOM.
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare var Event: {
|
|
readonly prototype: Event;
|
|
new (type: string, eventInitDict?: EventInit): Event;
|
|
readonly NONE: 0;
|
|
readonly CAPTURING_PHASE: 1;
|
|
readonly AT_TARGET: 2;
|
|
readonly BUBBLING_PHASE: 3;
|
|
};
|
|
|
|
/**
|
|
* EventTarget is a DOM interface implemented by objects that can receive events
|
|
* and may have listeners for them.
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare interface 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 to event 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;
|
|
}
|
|
|
|
/**
|
|
* EventTarget is a DOM interface implemented by objects that can receive events
|
|
* and may have listeners for them.
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare var EventTarget: {
|
|
readonly prototype: EventTarget;
|
|
new (): EventTarget;
|
|
};
|
|
|
|
/** @category Events */
|
|
declare interface EventListener {
|
|
(evt: Event): void;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare interface EventListenerObject {
|
|
handleEvent(evt: Event): void;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare type EventListenerOrEventListenerObject =
|
|
| EventListener
|
|
| EventListenerObject;
|
|
|
|
/** @category Events */
|
|
declare interface AddEventListenerOptions extends EventListenerOptions {
|
|
once?: boolean;
|
|
passive?: boolean;
|
|
signal?: AbortSignal;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare interface EventListenerOptions {
|
|
capture?: boolean;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare interface ProgressEventInit extends EventInit {
|
|
lengthComputable?: boolean;
|
|
loaded?: number;
|
|
total?: number;
|
|
}
|
|
|
|
/** 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>).
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare interface ProgressEvent<T extends EventTarget = EventTarget>
|
|
extends Event {
|
|
readonly lengthComputable: boolean;
|
|
readonly loaded: number;
|
|
readonly target: T | null;
|
|
readonly total: number;
|
|
}
|
|
|
|
/** 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>).
|
|
*
|
|
* @category Events
|
|
*/
|
|
declare var ProgressEvent: {
|
|
readonly prototype: ProgressEvent;
|
|
new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
|
|
};
|
|
|
|
/** Decodes a string of data which has been encoded using base-64 encoding.
|
|
*
|
|
* ```
|
|
* console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
|
|
* ```
|
|
*
|
|
* @category Encoding
|
|
*/
|
|
declare function atob(s: string): string;
|
|
|
|
/** Creates a base-64 ASCII encoded string from the input string.
|
|
*
|
|
* ```
|
|
* console.log(btoa("hello world")); // outputs "aGVsbG8gd29ybGQ="
|
|
* ```
|
|
*
|
|
* @category Encoding
|
|
*/
|
|
declare function btoa(s: string): string;
|
|
|
|
/** @category Encoding */
|
|
declare interface TextDecoderOptions {
|
|
fatal?: boolean;
|
|
ignoreBOM?: boolean;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare interface TextDecodeOptions {
|
|
stream?: boolean;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare interface TextDecoder extends TextDecoderCommon {
|
|
/** Returns the result of running encoding's decoder. */
|
|
decode(input?: BufferSource, options?: TextDecodeOptions): string;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare var TextDecoder: {
|
|
readonly prototype: TextDecoder;
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoder;
|
|
};
|
|
|
|
/** @category Encoding */
|
|
declare interface TextDecoderCommon {
|
|
/** Returns encoding's name, lowercased. */
|
|
readonly encoding: string;
|
|
/** Returns true if error mode is "fatal", otherwise false. */
|
|
readonly fatal: boolean;
|
|
/** Returns the value of ignore BOM. */
|
|
readonly ignoreBOM: boolean;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare interface TextEncoderEncodeIntoResult {
|
|
read: number;
|
|
written: number;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare interface TextEncoder extends TextEncoderCommon {
|
|
/** Returns the result of running UTF-8's encoder. */
|
|
encode(input?: string): Uint8Array;
|
|
encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare var TextEncoder: {
|
|
readonly prototype: TextEncoder;
|
|
new (): TextEncoder;
|
|
};
|
|
|
|
/** @category Encoding */
|
|
declare interface TextEncoderCommon {
|
|
/** Returns "utf-8". */
|
|
readonly encoding: string;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare interface TextDecoderStream
|
|
extends GenericTransformStream, TextDecoderCommon {
|
|
readonly readable: ReadableStream<string>;
|
|
readonly writable: WritableStream<BufferSource>;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare var TextDecoderStream: {
|
|
readonly prototype: TextDecoderStream;
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
|
|
};
|
|
|
|
/** @category Encoding */
|
|
declare interface TextEncoderStream
|
|
extends GenericTransformStream, TextEncoderCommon {
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<string>;
|
|
}
|
|
|
|
/** @category Encoding */
|
|
declare var TextEncoderStream: {
|
|
readonly prototype: TextEncoderStream;
|
|
new (): TextEncoderStream;
|
|
};
|
|
|
|
/** A controller object that allows you to abort one or more DOM requests as and
|
|
* when desired.
|
|
*
|
|
* @category Platform
|
|
*/
|
|
declare interface 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(reason?: any): void;
|
|
}
|
|
|
|
/** A controller object that allows you to abort one or more DOM requests as and
|
|
* when desired.
|
|
*
|
|
* @category Platform
|
|
*/
|
|
declare var AbortController: {
|
|
readonly prototype: AbortController;
|
|
new (): AbortController;
|
|
};
|
|
|
|
/** @category Platform */
|
|
declare 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.
|
|
*
|
|
* @category Platform
|
|
*/
|
|
declare interface AbortSignal extends EventTarget {
|
|
/** Returns true if this AbortSignal's AbortController has signaled to abort,
|
|
* and false otherwise. */
|
|
readonly aborted: boolean;
|
|
readonly reason: any;
|
|
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;
|
|
|
|
/** Throws this AbortSignal's abort reason, if its AbortController has
|
|
* signaled to abort; otherwise, does nothing. */
|
|
throwIfAborted(): void;
|
|
}
|
|
|
|
/** @category Platform */
|
|
declare var AbortSignal: {
|
|
readonly prototype: AbortSignal;
|
|
new (): never;
|
|
abort(reason?: any): AbortSignal;
|
|
any(signals: AbortSignal[]): AbortSignal;
|
|
timeout(milliseconds: number): AbortSignal;
|
|
};
|
|
|
|
/** @category File */
|
|
declare 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.
|
|
*
|
|
* @category File
|
|
*/
|
|
declare 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:
|
|
| typeof FileReader.EMPTY
|
|
| typeof FileReader.LOADING
|
|
| typeof FileReader.DONE;
|
|
readonly result: string | ArrayBuffer | null;
|
|
abort(): void;
|
|
readAsArrayBuffer(blob: Blob): void;
|
|
/** @deprecated */
|
|
readAsBinaryString(blob: Blob): void;
|
|
readAsDataURL(blob: Blob): void;
|
|
readAsText(blob: Blob, encoding?: string): void;
|
|
readonly EMPTY: 0;
|
|
readonly LOADING: 1;
|
|
readonly DONE: 2;
|
|
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;
|
|
}
|
|
|
|
/** @category File */
|
|
declare var FileReader: {
|
|
readonly prototype: FileReader;
|
|
new (): FileReader;
|
|
readonly EMPTY: 0;
|
|
readonly LOADING: 1;
|
|
readonly DONE: 2;
|
|
};
|
|
|
|
/** @category File */
|
|
declare type BlobPart = BufferSource | Blob | string;
|
|
|
|
/** @category File */
|
|
declare type EndingType = "transparent" | "native";
|
|
|
|
/** @category File */
|
|
declare interface BlobPropertyBag {
|
|
type?: string;
|
|
endings?: EndingType;
|
|
}
|
|
|
|
/** 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.
|
|
*
|
|
* @category File
|
|
*/
|
|
declare interface Blob {
|
|
readonly size: number;
|
|
readonly type: string;
|
|
arrayBuffer(): Promise<ArrayBuffer>;
|
|
bytes(): Promise<Uint8Array>;
|
|
slice(start?: number, end?: number, contentType?: string): Blob;
|
|
stream(): ReadableStream<Uint8Array>;
|
|
text(): Promise<string>;
|
|
}
|
|
|
|
/** 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.
|
|
*
|
|
* @category File
|
|
*/
|
|
declare var Blob: {
|
|
readonly prototype: Blob;
|
|
new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
|
|
};
|
|
|
|
/** @category File */
|
|
declare interface FilePropertyBag extends BlobPropertyBag {
|
|
lastModified?: number;
|
|
}
|
|
|
|
/** Provides information about files and allows JavaScript in a web page to
|
|
* access their content.
|
|
*
|
|
* @category File
|
|
*/
|
|
declare interface File extends Blob {
|
|
readonly lastModified: number;
|
|
readonly name: string;
|
|
readonly webkitRelativePath: string;
|
|
}
|
|
|
|
/** Provides information about files and allows JavaScript in a web page to
|
|
* access their content.
|
|
*
|
|
* @category File
|
|
*/
|
|
declare var File: {
|
|
readonly prototype: File;
|
|
new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare type ReadableStreamReader<T> =
|
|
| ReadableStreamDefaultReader<T>
|
|
| ReadableStreamBYOBReader;
|
|
|
|
/** @category Streams */
|
|
declare type ReadableStreamController<T> =
|
|
| ReadableStreamDefaultController<T>
|
|
| ReadableByteStreamController;
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamGenericReader {
|
|
readonly closed: Promise<undefined>;
|
|
cancel(reason?: any): Promise<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamReadDoneResult<T> {
|
|
done: true;
|
|
value?: T;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamReadValueResult<T> {
|
|
done: false;
|
|
value: T;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare type ReadableStreamReadResult<T> =
|
|
| ReadableStreamReadValueResult<T>
|
|
| ReadableStreamReadDoneResult<T>;
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamDefaultReader<R = any>
|
|
extends ReadableStreamGenericReader {
|
|
read(): Promise<ReadableStreamReadResult<R>>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableStreamDefaultReader: {
|
|
readonly prototype: ReadableStreamDefaultReader;
|
|
new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamBYOBReaderReadOptions {
|
|
min?: number;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
|
|
read<T extends ArrayBufferView>(
|
|
view: T,
|
|
options?: ReadableStreamBYOBReaderReadOptions,
|
|
): Promise<ReadableStreamReadResult<T>>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableStreamBYOBReader: {
|
|
readonly prototype: ReadableStreamBYOBReader;
|
|
new (stream: ReadableStream<Uint8Array>): ReadableStreamBYOBReader;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamBYOBRequest {
|
|
readonly view: ArrayBufferView | null;
|
|
respond(bytesWritten: number): void;
|
|
respondWithNewView(view: ArrayBufferView): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableStreamBYOBRequest: {
|
|
readonly prototype: ReadableStreamBYOBRequest;
|
|
new (): never;
|
|
};
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingByteSource["pull"]` instead.
|
|
* @category Streams
|
|
*/
|
|
declare interface ReadableByteStreamControllerCallback {
|
|
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingByteSource {
|
|
autoAllocateChunkSize?: number;
|
|
cancel?: UnderlyingSourceCancelCallback;
|
|
pull?: (controller: ReadableByteStreamController) => void | PromiseLike<void>;
|
|
start?: (controller: ReadableByteStreamController) => any;
|
|
type: "bytes";
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingDefaultSource<R = any> {
|
|
cancel?: UnderlyingSourceCancelCallback;
|
|
pull?: (
|
|
controller: ReadableStreamDefaultController<R>,
|
|
) => void | PromiseLike<void>;
|
|
start?: (controller: ReadableStreamDefaultController<R>) => any;
|
|
type?: undefined;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSink<W = any> {
|
|
abort?: UnderlyingSinkAbortCallback;
|
|
close?: UnderlyingSinkCloseCallback;
|
|
start?: UnderlyingSinkStartCallback;
|
|
type?: undefined;
|
|
write?: UnderlyingSinkWriteCallback<W>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare type ReadableStreamType = "bytes";
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSource<R = any> {
|
|
autoAllocateChunkSize?: number;
|
|
cancel?: UnderlyingSourceCancelCallback;
|
|
pull?: UnderlyingSourcePullCallback<R>;
|
|
start?: UnderlyingSourceStartCallback<R>;
|
|
type?: ReadableStreamType;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingSourceCancelCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type ReadableStreamErrorCallback = UnderlyingSourceCancelCallback;
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSourceCancelCallback {
|
|
(reason?: any): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSourcePullCallback<R> {
|
|
(controller: ReadableStreamController<R>): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSourceStartCallback<R> {
|
|
(controller: ReadableStreamController<R>): any;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `(controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>` type instead.
|
|
* @category Streams
|
|
*/
|
|
declare type ReadableStreamDefaultControllerCallback<R> = (
|
|
controller: ReadableStreamDefaultController<R>,
|
|
) => void | PromiseLike<void>;
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamDefaultController<R = any> {
|
|
readonly desiredSize: number | null;
|
|
close(): void;
|
|
enqueue(chunk?: R): void;
|
|
error(e?: any): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableStreamDefaultController: {
|
|
readonly prototype: ReadableStreamDefaultController;
|
|
new (): never;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableByteStreamController {
|
|
readonly byobRequest: ReadableStreamBYOBRequest | null;
|
|
readonly desiredSize: number | null;
|
|
close(): void;
|
|
enqueue(chunk: ArrayBufferView): void;
|
|
error(e?: any): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableByteStreamController: {
|
|
readonly prototype: ReadableByteStreamController;
|
|
new (): never;
|
|
};
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `StreamPipeOptions` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type PipeOptions = StreamPipeOptions;
|
|
|
|
/** @category Streams */
|
|
declare interface StreamPipeOptions {
|
|
preventAbort?: boolean;
|
|
preventCancel?: boolean;
|
|
preventClose?: boolean;
|
|
signal?: AbortSignal;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `QueuingStrategySize` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type QueuingStrategySizeCallback<T = any> = QueuingStrategySize<T>;
|
|
|
|
/** @category Streams */
|
|
declare interface QueuingStrategySize<T = any> {
|
|
(chunk: T): number;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface QueuingStrategy<T = any> {
|
|
highWaterMark?: number;
|
|
size?: QueuingStrategySize<T>;
|
|
}
|
|
|
|
/** This Streams API interface provides a built-in byte length queuing strategy
|
|
* that can be used when constructing streams.
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface CountQueuingStrategy extends QueuingStrategy {
|
|
readonly highWaterMark: number;
|
|
readonly size: QueuingStrategySize;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var CountQueuingStrategy: {
|
|
readonly prototype: CountQueuingStrategy;
|
|
new (init: QueuingStrategyInit): CountQueuingStrategy;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface ByteLengthQueuingStrategy
|
|
extends QueuingStrategy<ArrayBufferView> {
|
|
readonly highWaterMark: number;
|
|
readonly size: QueuingStrategySize<ArrayBufferView>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ByteLengthQueuingStrategy: {
|
|
readonly prototype: ByteLengthQueuingStrategy;
|
|
new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface QueuingStrategyInit {
|
|
highWaterMark: 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.
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface ReadableStream<R = any> {
|
|
readonly locked: boolean;
|
|
cancel(reason?: any): Promise<void>;
|
|
getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
|
|
getReader(): ReadableStreamDefaultReader<R>;
|
|
getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
|
|
pipeThrough<T>(
|
|
transform: ReadableWritablePair<T, R>,
|
|
options?: StreamPipeOptions,
|
|
): ReadableStream<T>;
|
|
pipeTo(
|
|
destination: WritableStream<R>,
|
|
options?: StreamPipeOptions,
|
|
): Promise<void>;
|
|
tee(): [ReadableStream<R>, ReadableStream<R>];
|
|
values(options?: ReadableStreamIteratorOptions): AsyncIterableIterator<R>;
|
|
[Symbol.asyncIterator](
|
|
options?: ReadableStreamIteratorOptions,
|
|
): AsyncIterableIterator<R>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var ReadableStream: {
|
|
readonly prototype: ReadableStream;
|
|
new (
|
|
underlyingSource: UnderlyingByteSource,
|
|
strategy?: { highWaterMark?: number },
|
|
): ReadableStream<Uint8Array>;
|
|
new <R = any>(
|
|
underlyingSource: UnderlyingDefaultSource<R>,
|
|
strategy?: QueuingStrategy<R>,
|
|
): ReadableStream<R>;
|
|
new <R = any>(
|
|
underlyingSource?: UnderlyingSource<R>,
|
|
strategy?: QueuingStrategy<R>,
|
|
): ReadableStream<R>;
|
|
from<R>(
|
|
asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>,
|
|
): ReadableStream<R>;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamIteratorOptions {
|
|
preventCancel?: boolean;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare type ReadableStreamReaderMode = "byob";
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableStreamGetReaderOptions {
|
|
mode?: ReadableStreamReaderMode;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface ReadableWritablePair<R = any, W = any> {
|
|
readable: ReadableStream<R>;
|
|
writable: WritableStream<W>;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingSinkCloseCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type WritableStreamDefaultControllerCloseCallback =
|
|
UnderlyingSinkCloseCallback;
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSinkCloseCallback {
|
|
(): void | PromiseLike<void>;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingSinkStartCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type WritableStreamDefaultControllerStartCallback =
|
|
UnderlyingSinkStartCallback;
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSinkStartCallback {
|
|
(controller: WritableStreamDefaultController): any;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingSinkWriteCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type WritableStreamDefaultControllerWriteCallback<W> =
|
|
UnderlyingSinkWriteCallback<W>;
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSinkWriteCallback<W> {
|
|
(
|
|
chunk: W,
|
|
controller: WritableStreamDefaultController,
|
|
): void | PromiseLike<void>;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `UnderlyingSinkAbortCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type WritableStreamErrorCallback = UnderlyingSinkAbortCallback;
|
|
|
|
/** @category Streams */
|
|
declare interface UnderlyingSinkAbortCallback {
|
|
(reason?: any): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** 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.
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface WritableStream<W = any> {
|
|
readonly locked: boolean;
|
|
abort(reason?: any): Promise<void>;
|
|
close(): Promise<void>;
|
|
getWriter(): WritableStreamDefaultWriter<W>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var WritableStream: {
|
|
readonly prototype: WritableStream;
|
|
new <W = any>(
|
|
underlyingSink?: UnderlyingSink<W>,
|
|
strategy?: QueuingStrategy<W>,
|
|
): WritableStream<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.
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface WritableStreamDefaultController {
|
|
readonly signal: AbortSignal;
|
|
error(e?: any): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var WritableStreamDefaultController: {
|
|
readonly prototype: WritableStreamDefaultController;
|
|
new (): never;
|
|
};
|
|
|
|
/** 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.
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface WritableStreamDefaultWriter<W = any> {
|
|
readonly closed: Promise<undefined>;
|
|
readonly desiredSize: number | null;
|
|
readonly ready: Promise<undefined>;
|
|
abort(reason?: any): Promise<void>;
|
|
close(): Promise<void>;
|
|
releaseLock(): void;
|
|
write(chunk?: W): Promise<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var WritableStreamDefaultWriter: {
|
|
readonly prototype: WritableStreamDefaultWriter;
|
|
new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface TransformStream<I = any, O = any> {
|
|
readonly readable: ReadableStream<O>;
|
|
readonly writable: WritableStream<I>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var TransformStream: {
|
|
readonly prototype: TransformStream;
|
|
new <I = any, O = any>(
|
|
transformer?: Transformer<I, O>,
|
|
writableStrategy?: QueuingStrategy<I>,
|
|
readableStrategy?: QueuingStrategy<O>,
|
|
): TransformStream<I, O>;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface TransformStreamDefaultController<O = any> {
|
|
readonly desiredSize: number | null;
|
|
enqueue(chunk?: O): void;
|
|
error(reason?: any): void;
|
|
terminate(): void;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare var TransformStreamDefaultController: {
|
|
readonly prototype: TransformStreamDefaultController;
|
|
new (): never;
|
|
};
|
|
|
|
/** @category Streams */
|
|
declare interface Transformer<I = any, O = any> {
|
|
flush?: TransformerFlushCallback<O>;
|
|
readableType?: undefined;
|
|
start?: TransformerStartCallback<O>;
|
|
transform?: TransformerTransformCallback<I, O>;
|
|
cancel?: TransformerCancelCallback;
|
|
writableType?: undefined;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `TransformerFlushCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type TransformStreamDefaultControllerCallback<O> =
|
|
TransformerFlushCallback<O>;
|
|
|
|
/** @category Streams */
|
|
declare interface TransformerFlushCallback<O> {
|
|
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface TransformerStartCallback<O> {
|
|
(controller: TransformStreamDefaultController<O>): any;
|
|
}
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `TransformerTransformCallback` instead.
|
|
* @category Streams
|
|
*/
|
|
declare type TransformStreamDefaultControllerTransformCallback<I, O> =
|
|
TransformerTransformCallback<I, O>;
|
|
|
|
/** @category Streams */
|
|
declare interface TransformerTransformCallback<I, O> {
|
|
(
|
|
chunk: I,
|
|
controller: TransformStreamDefaultController<O>,
|
|
): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface TransformerCancelCallback {
|
|
(reason: any): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare interface GenericTransformStream {
|
|
readonly readable: ReadableStream;
|
|
readonly writable: WritableStream;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare type MessageEventSource = Window | MessagePort;
|
|
|
|
/** @category Events */
|
|
declare interface MessageEventInit<T = any> extends EventInit {
|
|
data?: T;
|
|
lastEventId?: string;
|
|
origin?: string;
|
|
ports?: MessagePort[];
|
|
source?: MessageEventSource | null;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare interface MessageEvent<T = any> extends Event {
|
|
/**
|
|
* Returns the data of the message.
|
|
*/
|
|
readonly data: T;
|
|
/**
|
|
* Returns the origin of the message, for server-sent events.
|
|
*/
|
|
readonly origin: string;
|
|
/**
|
|
* Returns the last event ID string, for server-sent events.
|
|
*/
|
|
readonly lastEventId: string;
|
|
readonly source: MessageEventSource | null;
|
|
/**
|
|
* Returns transferred ports.
|
|
*/
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
/** @deprecated */
|
|
initMessageEvent(
|
|
type: string,
|
|
bubbles?: boolean,
|
|
cancelable?: boolean,
|
|
data?: any,
|
|
origin?: string,
|
|
lastEventId?: string,
|
|
source?: MessageEventSource | null,
|
|
ports?: MessagePort[],
|
|
): void;
|
|
}
|
|
|
|
/** @category Events */
|
|
declare var MessageEvent: {
|
|
readonly prototype: MessageEvent;
|
|
new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
|
|
};
|
|
|
|
/** @category Events */
|
|
declare type Transferable = MessagePort | ArrayBuffer;
|
|
|
|
// TODO(petamoriken): Will be removed in v2.0.
|
|
/**
|
|
* @deprecated use `StructuredSerializeOptions` instead.
|
|
* @category Events
|
|
*/
|
|
declare type PostMessageOptions = StructuredSerializeOptions;
|
|
|
|
/** @category Platform */
|
|
declare interface StructuredSerializeOptions {
|
|
transfer?: Transferable[];
|
|
}
|
|
|
|
/** The MessageChannel interface of the Channel Messaging API allows us to
|
|
* create a new message channel and send data through it via its two MessagePort
|
|
* properties.
|
|
*
|
|
* @category Messaging
|
|
*/
|
|
declare interface MessageChannel {
|
|
readonly port1: MessagePort;
|
|
readonly port2: MessagePort;
|
|
}
|
|
|
|
/** The MessageChannel interface of the Channel Messaging API allows us to
|
|
* create a new message channel and send data through it via its two MessagePort
|
|
* properties.
|
|
*
|
|
* @category Messaging
|
|
*/
|
|
declare var MessageChannel: {
|
|
readonly prototype: MessageChannel;
|
|
new (): MessageChannel;
|
|
};
|
|
|
|
/** @category Messaging */
|
|
declare interface MessagePortEventMap {
|
|
"message": MessageEvent;
|
|
"messageerror": MessageEvent;
|
|
}
|
|
|
|
/** The MessagePort interface of the Channel Messaging API represents one of the
|
|
* two ports of a MessageChannel, allowing messages to be sent from one port and
|
|
* listening out for them arriving at the other.
|
|
*
|
|
* @category Messaging
|
|
*/
|
|
declare interface MessagePort extends EventTarget {
|
|
onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
|
|
onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
|
|
/**
|
|
* Disconnects the port, so that it is no longer active.
|
|
*/
|
|
close(): void;
|
|
/**
|
|
* Posts a message through the channel. Objects listed in transfer are
|
|
* transferred, not just cloned, meaning that they are no longer usable on the
|
|
* sending side.
|
|
*
|
|
* Throws a "DataCloneError" DOMException if transfer contains duplicate
|
|
* objects or port, or if message could not be cloned.
|
|
*/
|
|
postMessage(message: any, transfer: Transferable[]): void;
|
|
postMessage(message: any, options?: StructuredSerializeOptions): void;
|
|
/**
|
|
* Begins dispatching messages received on the port. This is implicitly called
|
|
* when assigning a value to `this.onmessage`.
|
|
*/
|
|
start(): void;
|
|
addEventListener<K extends keyof MessagePortEventMap>(
|
|
type: K,
|
|
listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
addEventListener(
|
|
type: string,
|
|
listener: EventListenerOrEventListenerObject,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
removeEventListener<K extends keyof MessagePortEventMap>(
|
|
type: K,
|
|
listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any,
|
|
options?: boolean | EventListenerOptions,
|
|
): void;
|
|
removeEventListener(
|
|
type: string,
|
|
listener: EventListenerOrEventListenerObject,
|
|
options?: boolean | EventListenerOptions,
|
|
): void;
|
|
}
|
|
|
|
/** The MessagePort interface of the Channel Messaging API represents one of the
|
|
* two ports of a MessageChannel, allowing messages to be sent from one port and
|
|
* listening out for them arriving at the other.
|
|
*
|
|
* @category Messaging
|
|
*/
|
|
declare var MessagePort: {
|
|
readonly prototype: MessagePort;
|
|
new (): never;
|
|
};
|
|
|
|
/**
|
|
* Creates a deep copy of a given value using the structured clone algorithm.
|
|
*
|
|
* Unlike a shallow copy, a deep copy does not hold the same references as the
|
|
* source object, meaning its properties can be changed without affecting the
|
|
* source. For more details, see
|
|
* [MDN](https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy).
|
|
*
|
|
* Throws a `DataCloneError` if any part of the input value is not
|
|
* serializable.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* const object = { x: 0, y: 1 };
|
|
*
|
|
* const deepCopy = structuredClone(object);
|
|
* deepCopy.x = 1;
|
|
* console.log(deepCopy.x, object.x); // 1 0
|
|
*
|
|
* const shallowCopy = object;
|
|
* shallowCopy.x = 1;
|
|
* // shallowCopy.x is pointing to the same location in memory as object.x
|
|
* console.log(shallowCopy.x, object.x); // 1 1
|
|
* ```
|
|
*
|
|
* @category Platform
|
|
*/
|
|
declare function structuredClone<T = any>(
|
|
value: T,
|
|
options?: StructuredSerializeOptions,
|
|
): T;
|
|
|
|
/**
|
|
* An API for compressing a stream of data.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* await Deno.stdin.readable
|
|
* .pipeThrough(new CompressionStream("gzip"))
|
|
* .pipeTo(Deno.stdout.writable);
|
|
* ```
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface CompressionStream extends GenericTransformStream {
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<BufferSource>;
|
|
}
|
|
|
|
/** @category Streams */
|
|
declare type CompressionFormat = "deflate" | "deflate-raw" | "gzip";
|
|
|
|
/**
|
|
* An API for compressing a stream of data.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* await Deno.stdin.readable
|
|
* .pipeThrough(new CompressionStream("gzip"))
|
|
* .pipeTo(Deno.stdout.writable);
|
|
* ```
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare var CompressionStream: {
|
|
readonly prototype: CompressionStream;
|
|
/**
|
|
* Creates a new `CompressionStream` object which compresses a stream of
|
|
* data.
|
|
*
|
|
* Throws a `TypeError` if the format passed to the constructor is not
|
|
* supported.
|
|
*/
|
|
new (format: CompressionFormat): CompressionStream;
|
|
};
|
|
|
|
/**
|
|
* An API for decompressing a stream of data.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* const input = await Deno.open("./file.txt.gz");
|
|
* const output = await Deno.create("./file.txt");
|
|
*
|
|
* await input.readable
|
|
* .pipeThrough(new DecompressionStream("gzip"))
|
|
* .pipeTo(output.writable);
|
|
* ```
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare interface DecompressionStream extends GenericTransformStream {
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<BufferSource>;
|
|
}
|
|
|
|
/**
|
|
* An API for decompressing a stream of data.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* const input = await Deno.open("./file.txt.gz");
|
|
* const output = await Deno.create("./file.txt");
|
|
*
|
|
* await input.readable
|
|
* .pipeThrough(new DecompressionStream("gzip"))
|
|
* .pipeTo(output.writable);
|
|
* ```
|
|
*
|
|
* @category Streams
|
|
*/
|
|
declare var DecompressionStream: {
|
|
readonly prototype: DecompressionStream;
|
|
/**
|
|
* Creates a new `DecompressionStream` object which decompresses a stream of
|
|
* data.
|
|
*
|
|
* Throws a `TypeError` if the format passed to the constructor is not
|
|
* supported.
|
|
*/
|
|
new (format: CompressionFormat): DecompressionStream;
|
|
};
|
|
|
|
/** Dispatch an uncaught exception. Similar to a synchronous version of:
|
|
* ```ts
|
|
* setTimeout(() => { throw error; }, 0);
|
|
* ```
|
|
* The error can not be caught with a `try/catch` block. An error event will
|
|
* be dispatched to the global scope. You can prevent the error from being
|
|
* reported to the console with `Event.prototype.preventDefault()`:
|
|
* ```ts
|
|
* addEventListener("error", (event) => {
|
|
* event.preventDefault();
|
|
* });
|
|
* reportError(new Error("foo")); // Will not be reported.
|
|
* ```
|
|
* In Deno, this error will terminate the process if not intercepted like above.
|
|
*
|
|
* @category Platform
|
|
*/
|
|
declare function reportError(
|
|
error: any,
|
|
): void;
|
|
|
|
/** @category Platform */
|
|
declare type PredefinedColorSpace = "srgb" | "display-p3";
|
|
|
|
/** @category Platform */
|
|
declare interface ImageDataSettings {
|
|
readonly colorSpace?: PredefinedColorSpace;
|
|
}
|
|
|
|
/** @category Platform */
|
|
declare interface ImageData {
|
|
readonly colorSpace: PredefinedColorSpace;
|
|
readonly data: Uint8ClampedArray;
|
|
readonly height: number;
|
|
readonly width: number;
|
|
}
|
|
|
|
/** @category Platform */
|
|
declare var ImageData: {
|
|
readonly prototype: ImageData;
|
|
new (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
|
|
new (
|
|
data: Uint8ClampedArray,
|
|
sw: number,
|
|
sh?: number,
|
|
settings?: ImageDataSettings,
|
|
): ImageData;
|
|
};
|