mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 15:24:46 -05:00
1049 lines
31 KiB
TypeScript
1049 lines
31 KiB
TypeScript
// Copyright 2018-2022 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 DOM Events */
|
|
declare class DOMException extends Error {
|
|
constructor(message?: string, name?: string);
|
|
readonly name: string;
|
|
readonly message: string;
|
|
readonly code: number;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
interface EventInit {
|
|
bubbles?: boolean;
|
|
cancelable?: boolean;
|
|
composed?: boolean;
|
|
}
|
|
|
|
/** An event which takes place in the DOM.
|
|
*
|
|
* @category DOM Events
|
|
*/
|
|
declare class Event {
|
|
constructor(type: string, eventInitDict?: EventInit);
|
|
/** Returns true or false depending on how event was initialized. True if
|
|
* event goes through its target's ancestors in reverse tree order, and
|
|
* false otherwise. */
|
|
readonly bubbles: boolean;
|
|
cancelBubble: boolean;
|
|
/** Returns true or false depending on how event was initialized. Its return
|
|
* value does not always carry meaning, but true can indicate that part of the
|
|
* operation during which event was dispatched, can be canceled by invoking
|
|
* the preventDefault() method. */
|
|
readonly cancelable: boolean;
|
|
/** Returns true or false depending on how event was initialized. True if
|
|
* event invokes listeners past a ShadowRoot node that is the root of its
|
|
* target, and false otherwise. */
|
|
readonly composed: boolean;
|
|
/** Returns the object whose event listener's callback is currently being
|
|
* invoked. */
|
|
readonly currentTarget: EventTarget | null;
|
|
/** Returns true if preventDefault() was invoked successfully to indicate
|
|
* cancellation, and false otherwise. */
|
|
readonly defaultPrevented: boolean;
|
|
/** Returns the event's phase, which is one of NONE, CAPTURING_PHASE,
|
|
* AT_TARGET, and BUBBLING_PHASE. */
|
|
readonly eventPhase: number;
|
|
/** Returns true if event was dispatched by the user agent, and false
|
|
* otherwise. */
|
|
readonly isTrusted: boolean;
|
|
/** Returns the object to which event is dispatched (its target). */
|
|
readonly target: EventTarget | null;
|
|
/** Returns the event's timestamp as the number of milliseconds measured
|
|
* relative to the time origin. */
|
|
readonly timeStamp: number;
|
|
/** Returns the type of event, e.g. "click", "hashchange", or "submit". */
|
|
readonly type: string;
|
|
/** Returns the invocation target objects of event's path (objects on which
|
|
* listeners will be invoked), except for any nodes in shadow trees of which
|
|
* the shadow root's mode is "closed" that are not reachable from event's
|
|
* currentTarget. */
|
|
composedPath(): EventTarget[];
|
|
/** If invoked when the cancelable attribute value is true, and while
|
|
* executing a listener for the event with passive set to false, signals to
|
|
* the operation that caused event to be dispatched that it needs to be
|
|
* canceled. */
|
|
preventDefault(): void;
|
|
/** Invoking this method prevents event from reaching any registered event
|
|
* listeners after the current one finishes running and, when dispatched in a
|
|
* tree, also prevents event from reaching any other objects. */
|
|
stopImmediatePropagation(): void;
|
|
/** When dispatched in a tree, invoking this method prevents event from
|
|
* reaching any objects other than the current object. */
|
|
stopPropagation(): void;
|
|
readonly AT_TARGET: number;
|
|
readonly BUBBLING_PHASE: number;
|
|
readonly CAPTURING_PHASE: number;
|
|
readonly NONE: number;
|
|
static readonly AT_TARGET: number;
|
|
static readonly BUBBLING_PHASE: number;
|
|
static readonly CAPTURING_PHASE: number;
|
|
static readonly NONE: number;
|
|
}
|
|
|
|
/**
|
|
* EventTarget is a DOM interface implemented by objects that can receive events
|
|
* and may have listeners for them.
|
|
*
|
|
* @category DOM Events
|
|
*/
|
|
declare class EventTarget {
|
|
/** Appends an event listener for events whose type attribute value is type.
|
|
* The callback argument sets the callback that will be invoked when the event
|
|
* is dispatched.
|
|
*
|
|
* The options argument sets listener-specific options. For compatibility this
|
|
* can be a boolean, in which case the method behaves exactly as if the value
|
|
* was specified as options's capture.
|
|
*
|
|
* When set to true, options's capture prevents callback from being invoked
|
|
* when the event's eventPhase attribute value is BUBBLING_PHASE. When false
|
|
* (or not present), callback will not be invoked when event's eventPhase
|
|
* attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
|
|
* event's eventPhase attribute value is AT_TARGET.
|
|
*
|
|
* When set to true, options's passive indicates that the callback will not
|
|
* cancel the event by invoking preventDefault(). This is used to enable
|
|
* performance optimizations described in § 2.8 Observing event listeners.
|
|
*
|
|
* When set to true, options's once indicates that the callback will only be
|
|
* invoked once after which the event listener will be removed.
|
|
*
|
|
* The event listener is appended to target's event listener list and is not
|
|
* appended if it has the same type, callback, and capture. */
|
|
addEventListener(
|
|
type: string,
|
|
listener: EventListenerOrEventListenerObject | null,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
/** Dispatches a synthetic event event to target and returns true if either
|
|
* event's cancelable attribute value is false or its preventDefault() method
|
|
* was not invoked, and false otherwise. */
|
|
dispatchEvent(event: Event): boolean;
|
|
/** Removes the event listener in target's event listener list with the same
|
|
* type, callback, and options. */
|
|
removeEventListener(
|
|
type: string,
|
|
callback: EventListenerOrEventListenerObject | null,
|
|
options?: EventListenerOptions | boolean,
|
|
): void;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
interface EventListener {
|
|
(evt: Event): void | Promise<void>;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
interface EventListenerObject {
|
|
handleEvent(evt: Event): void | Promise<void>;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
declare type EventListenerOrEventListenerObject =
|
|
| EventListener
|
|
| EventListenerObject;
|
|
|
|
/** @category DOM Events */
|
|
interface AddEventListenerOptions extends EventListenerOptions {
|
|
once?: boolean;
|
|
passive?: boolean;
|
|
signal?: AbortSignal;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
interface EventListenerOptions {
|
|
capture?: boolean;
|
|
}
|
|
|
|
/** @category DOM Events */
|
|
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 DOM Events
|
|
*/
|
|
declare class ProgressEvent<T extends EventTarget = EventTarget> extends Event {
|
|
constructor(type: string, eventInitDict?: ProgressEventInit);
|
|
readonly lengthComputable: boolean;
|
|
readonly loaded: number;
|
|
readonly target: T | null;
|
|
readonly total: number;
|
|
}
|
|
|
|
/** Decodes a string of data which has been encoded using base-64 encoding.
|
|
*
|
|
* ```
|
|
* console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
|
|
* ```
|
|
*
|
|
* @category Encoding API
|
|
*/
|
|
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 API
|
|
*/
|
|
declare function btoa(s: string): string;
|
|
|
|
/** @category Encoding API */
|
|
declare interface TextDecoderOptions {
|
|
fatal?: boolean;
|
|
ignoreBOM?: boolean;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
declare interface TextDecodeOptions {
|
|
stream?: boolean;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
interface TextDecoder {
|
|
/** Returns encoding's name, lowercased. */
|
|
readonly encoding: string;
|
|
/** Returns `true` if error mode is "fatal", and `false` otherwise. */
|
|
readonly fatal: boolean;
|
|
/** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
|
|
readonly ignoreBOM: boolean;
|
|
|
|
/** Returns the result of running encoding's decoder. */
|
|
decode(input?: BufferSource, options?: TextDecodeOptions): string;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
declare var TextDecoder: {
|
|
prototype: TextDecoder;
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoder;
|
|
};
|
|
|
|
/** @category Encoding API */
|
|
declare interface TextEncoderEncodeIntoResult {
|
|
read: number;
|
|
written: number;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
interface TextEncoder {
|
|
/** Returns "utf-8". */
|
|
readonly encoding: "utf-8";
|
|
/** Returns the result of running UTF-8's encoder. */
|
|
encode(input?: string): Uint8Array;
|
|
encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
declare var TextEncoder: {
|
|
prototype: TextEncoder;
|
|
new (): TextEncoder;
|
|
};
|
|
|
|
/** @category Encoding API */
|
|
interface TextDecoderStream {
|
|
/** Returns encoding's name, lowercased. */
|
|
readonly encoding: string;
|
|
/** Returns `true` if error mode is "fatal", and `false` otherwise. */
|
|
readonly fatal: boolean;
|
|
/** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
|
|
readonly ignoreBOM: boolean;
|
|
readonly readable: ReadableStream<string>;
|
|
readonly writable: WritableStream<BufferSource>;
|
|
readonly [Symbol.toStringTag]: string;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
declare var TextDecoderStream: {
|
|
prototype: TextDecoderStream;
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
|
|
};
|
|
|
|
/** @category Encoding API */
|
|
interface TextEncoderStream {
|
|
/** Returns "utf-8". */
|
|
readonly encoding: "utf-8";
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<string>;
|
|
readonly [Symbol.toStringTag]: string;
|
|
}
|
|
|
|
/** @category Encoding API */
|
|
declare var TextEncoderStream: {
|
|
prototype: TextEncoderStream;
|
|
new (): TextEncoderStream;
|
|
};
|
|
|
|
/** A controller object that allows you to abort one or more DOM requests as and
|
|
* when desired.
|
|
*
|
|
* @category Web APIs
|
|
*/
|
|
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(reason?: any): void;
|
|
}
|
|
|
|
/** @category Web APIs */
|
|
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 Web APIs
|
|
*/
|
|
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 Web APIs */
|
|
declare var AbortSignal: {
|
|
prototype: AbortSignal;
|
|
new (): AbortSignal;
|
|
abort(reason?: any): AbortSignal;
|
|
timeout(milliseconds: number): AbortSignal;
|
|
};
|
|
|
|
/** @category Web File API */
|
|
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 Web File API
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/** @category Web File API */
|
|
declare var FileReader: {
|
|
prototype: FileReader;
|
|
new (): FileReader;
|
|
readonly DONE: number;
|
|
readonly EMPTY: number;
|
|
readonly LOADING: number;
|
|
};
|
|
|
|
/** @category Web File API */
|
|
type BlobPart = BufferSource | Blob | string;
|
|
|
|
/** @category Web File API */
|
|
interface BlobPropertyBag {
|
|
type?: string;
|
|
endings?: "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.
|
|
*
|
|
* @category Web File API
|
|
*/
|
|
declare class Blob {
|
|
constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
|
|
|
|
readonly size: number;
|
|
readonly type: string;
|
|
arrayBuffer(): Promise<ArrayBuffer>;
|
|
slice(start?: number, end?: number, contentType?: string): Blob;
|
|
stream(): ReadableStream<Uint8Array>;
|
|
text(): Promise<string>;
|
|
}
|
|
|
|
/** @category Web File API */
|
|
interface FilePropertyBag extends BlobPropertyBag {
|
|
lastModified?: number;
|
|
}
|
|
|
|
/** Provides information about files and allows JavaScript in a web page to
|
|
* access their content.
|
|
*
|
|
* @category Web File API
|
|
*/
|
|
declare class File extends Blob {
|
|
constructor(
|
|
fileBits: BlobPart[],
|
|
fileName: string,
|
|
options?: FilePropertyBag,
|
|
);
|
|
|
|
readonly lastModified: number;
|
|
readonly name: string;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamReadDoneResult<T> {
|
|
done: true;
|
|
value?: T;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamReadValueResult<T> {
|
|
done: false;
|
|
value: T;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
type ReadableStreamReadResult<T> =
|
|
| ReadableStreamReadValueResult<T>
|
|
| ReadableStreamReadDoneResult<T>;
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamDefaultReader<R = any> {
|
|
readonly closed: Promise<void>;
|
|
cancel(reason?: any): Promise<void>;
|
|
read(): Promise<ReadableStreamReadResult<R>>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> {
|
|
done: true;
|
|
value?: V;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> {
|
|
done: false;
|
|
value: V;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
type ReadableStreamBYOBReadResult<V extends ArrayBufferView> =
|
|
| ReadableStreamBYOBReadDoneResult<V>
|
|
| ReadableStreamBYOBReadValueResult<V>;
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamBYOBReader {
|
|
readonly closed: Promise<void>;
|
|
cancel(reason?: any): Promise<void>;
|
|
read<V extends ArrayBufferView>(
|
|
view: V,
|
|
): Promise<ReadableStreamBYOBReadResult<V>>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamBYOBRequest {
|
|
readonly view: ArrayBufferView | null;
|
|
respond(bytesWritten: number): void;
|
|
respondWithNewView(view: ArrayBufferView): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var ReadableStreamDefaultReader: {
|
|
prototype: ReadableStreamDefaultReader;
|
|
new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamReader<R = any> {
|
|
cancel(): Promise<void>;
|
|
read(): Promise<ReadableStreamReadResult<R>>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var ReadableStreamReader: {
|
|
prototype: ReadableStreamReader;
|
|
new (): ReadableStreamReader;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface ReadableByteStreamControllerCallback {
|
|
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface UnderlyingByteSource {
|
|
autoAllocateChunkSize?: number;
|
|
cancel?: ReadableStreamErrorCallback;
|
|
pull?: ReadableByteStreamControllerCallback;
|
|
start?: ReadableByteStreamControllerCallback;
|
|
type: "bytes";
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface UnderlyingSink<W = any> {
|
|
abort?: WritableStreamErrorCallback;
|
|
close?: WritableStreamDefaultControllerCloseCallback;
|
|
start?: WritableStreamDefaultControllerStartCallback;
|
|
type?: undefined;
|
|
write?: WritableStreamDefaultControllerWriteCallback<W>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface UnderlyingSource<R = any> {
|
|
cancel?: ReadableStreamErrorCallback;
|
|
pull?: ReadableStreamDefaultControllerCallback<R>;
|
|
start?: ReadableStreamDefaultControllerCallback<R>;
|
|
type?: undefined;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamErrorCallback {
|
|
(reason: any): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamDefaultControllerCallback<R> {
|
|
(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface ReadableStreamDefaultController<R = any> {
|
|
readonly desiredSize: number | null;
|
|
close(): void;
|
|
enqueue(chunk: R): void;
|
|
error(error?: any): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var ReadableStreamDefaultController: {
|
|
prototype: ReadableStreamDefaultController;
|
|
new (): ReadableStreamDefaultController;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface ReadableByteStreamController {
|
|
readonly byobRequest: ReadableStreamBYOBRequest | null;
|
|
readonly desiredSize: number | null;
|
|
close(): void;
|
|
enqueue(chunk: ArrayBufferView): void;
|
|
error(error?: any): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var ReadableByteStreamController: {
|
|
prototype: ReadableByteStreamController;
|
|
new (): ReadableByteStreamController;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface PipeOptions {
|
|
preventAbort?: boolean;
|
|
preventCancel?: boolean;
|
|
preventClose?: boolean;
|
|
signal?: AbortSignal;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface QueuingStrategySizeCallback<T = any> {
|
|
(chunk: T): number;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
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.
|
|
*
|
|
* @category Streams API
|
|
*/
|
|
interface CountQueuingStrategy extends QueuingStrategy {
|
|
highWaterMark: number;
|
|
size(chunk: any): 1;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var CountQueuingStrategy: {
|
|
prototype: CountQueuingStrategy;
|
|
new (options: { highWaterMark: number }): CountQueuingStrategy;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
|
|
highWaterMark: number;
|
|
size(chunk: ArrayBufferView): number;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var ByteLengthQueuingStrategy: {
|
|
prototype: ByteLengthQueuingStrategy;
|
|
new (options: { highWaterMark: number }): ByteLengthQueuingStrategy;
|
|
};
|
|
|
|
/** 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 API
|
|
*/
|
|
interface ReadableStream<R = any> {
|
|
readonly locked: boolean;
|
|
cancel(reason?: any): Promise<void>;
|
|
getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
|
|
getReader(options?: { mode?: undefined }): 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>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
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>;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface WritableStreamDefaultControllerCloseCallback {
|
|
(): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface WritableStreamDefaultControllerStartCallback {
|
|
(controller: WritableStreamDefaultController): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface WritableStreamDefaultControllerWriteCallback<W> {
|
|
(chunk: W, controller: WritableStreamDefaultController):
|
|
| void
|
|
| PromiseLike<
|
|
void
|
|
>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface WritableStreamErrorCallback {
|
|
(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 API
|
|
*/
|
|
interface WritableStream<W = any> {
|
|
readonly locked: boolean;
|
|
abort(reason?: any): Promise<void>;
|
|
close(): Promise<void>;
|
|
getWriter(): WritableStreamDefaultWriter<W>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var WritableStream: {
|
|
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 API
|
|
*/
|
|
interface WritableStreamDefaultController {
|
|
signal: AbortSignal;
|
|
error(error?: any): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var WritableStreamDefaultController: WritableStreamDefaultController;
|
|
|
|
/** 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 API
|
|
*/
|
|
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>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var WritableStreamDefaultWriter: {
|
|
prototype: WritableStreamDefaultWriter;
|
|
new (): WritableStreamDefaultWriter;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface TransformStream<I = any, O = any> {
|
|
readonly readable: ReadableStream<O>;
|
|
readonly writable: WritableStream<I>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var TransformStream: {
|
|
prototype: TransformStream;
|
|
new <I = any, O = any>(
|
|
transformer?: Transformer<I, O>,
|
|
writableStrategy?: QueuingStrategy<I>,
|
|
readableStrategy?: QueuingStrategy<O>,
|
|
): TransformStream<I, O>;
|
|
};
|
|
|
|
/** @category Streams API */
|
|
interface TransformStreamDefaultController<O = any> {
|
|
readonly desiredSize: number | null;
|
|
enqueue(chunk: O): void;
|
|
error(reason?: any): void;
|
|
terminate(): void;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare var TransformStreamDefaultController: TransformStreamDefaultController;
|
|
|
|
/** @category Streams API */
|
|
interface Transformer<I = any, O = any> {
|
|
flush?: TransformStreamDefaultControllerCallback<O>;
|
|
readableType?: undefined;
|
|
start?: TransformStreamDefaultControllerCallback<O>;
|
|
transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
|
|
writableType?: undefined;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface TransformStreamDefaultControllerCallback<O> {
|
|
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface TransformStreamDefaultControllerTransformCallback<I, O> {
|
|
(
|
|
chunk: I,
|
|
controller: TransformStreamDefaultController<O>,
|
|
): void | PromiseLike<void>;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
interface MessageEventInit<T = any> extends EventInit {
|
|
data?: T;
|
|
origin?: string;
|
|
lastEventId?: string;
|
|
}
|
|
|
|
/** @category Streams API */
|
|
declare class MessageEvent<T = any> extends Event {
|
|
/**
|
|
* Returns the data of the message.
|
|
*/
|
|
readonly data: T;
|
|
/**
|
|
* Returns the last event ID string, for server-sent events.
|
|
*/
|
|
readonly lastEventId: string;
|
|
/**
|
|
* Returns transferred ports.
|
|
*/
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
constructor(type: string, eventInitDict?: MessageEventInit);
|
|
}
|
|
|
|
/** @category DOM APIs */
|
|
type Transferable = ArrayBuffer | MessagePort;
|
|
|
|
/**
|
|
* This type has been renamed to StructuredSerializeOptions. Use that type for
|
|
* new code.
|
|
*
|
|
* @deprecated use `StructuredSerializeOptions` instead.
|
|
* @category DOM APIs
|
|
*/
|
|
type PostMessageOptions = StructuredSerializeOptions;
|
|
|
|
/** @category DOM APIs */
|
|
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 DOM APIs
|
|
*/
|
|
declare class MessageChannel {
|
|
constructor();
|
|
readonly port1: MessagePort;
|
|
readonly port2: MessagePort;
|
|
}
|
|
|
|
/** @category DOM APIs */
|
|
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 DOM APIs
|
|
*/
|
|
declare class 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 implictly called
|
|
* when assiging 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;
|
|
}
|
|
|
|
/**
|
|
* 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 DOM APIs
|
|
*/
|
|
declare function structuredClone(
|
|
value: any,
|
|
options?: StructuredSerializeOptions,
|
|
): any;
|
|
|
|
/**
|
|
* An API for compressing a stream of data.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* await Deno.stdin.readable
|
|
* .pipeThrough(new CompressionStream("gzip"))
|
|
* .pipeTo(Deno.stdout.writable);
|
|
* ```
|
|
*
|
|
* @category Compression Streams API
|
|
*/
|
|
declare class 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.
|
|
*/
|
|
constructor(format: string);
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
}
|
|
|
|
/**
|
|
* 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 Compression Streams API
|
|
*/
|
|
declare class 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.
|
|
*/
|
|
constructor(format: string);
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
}
|
|
|
|
/** 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 Web APIs
|
|
*/
|
|
declare function reportError(
|
|
error: any,
|
|
): void;
|