2024-01-01 19:58:21 +00:00
|
|
|
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
2020-08-07 14:55:02 +00:00
|
|
|
|
2021-12-09 22:12:21 +00:00
|
|
|
// deno-lint-ignore-file no-explicit-any no-var
|
2020-08-19 12:43:20 +00:00
|
|
|
|
2020-08-07 14:55:02 +00:00
|
|
|
/// <reference no-default-lib="true" />
|
|
|
|
/// <reference lib="esnext" />
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** @category Web APIs */
|
|
|
|
declare interface DOMException extends Error {
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly name: string;
|
|
|
|
readonly message: string;
|
2021-01-09 06:27:46 +00:00
|
|
|
readonly code: number;
|
2023-07-03 18:36:55 +00:00
|
|
|
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;
|
2020-08-07 14:55:02 +00:00
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** @category Web APIs */
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface EventInit {
|
2020-08-07 14:55:02 +00:00
|
|
|
bubbles?: boolean;
|
|
|
|
cancelable?: boolean;
|
|
|
|
composed?: boolean;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** An event which takes place in the DOM.
|
|
|
|
*
|
|
|
|
* @category DOM Events
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface Event {
|
2020-08-07 14:55:02 +00:00
|
|
|
/** Returns true or false depending on how event was initialized. True if
|
2021-09-02 22:28:12 +00:00
|
|
|
* event goes through its target's ancestors in reverse tree order, and
|
|
|
|
* false otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly bubbles: boolean;
|
|
|
|
cancelBubble: boolean;
|
|
|
|
/** Returns true or false depending on how event was initialized. Its return
|
2021-09-02 22:28:12 +00:00
|
|
|
* 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. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly cancelable: boolean;
|
|
|
|
/** Returns true or false depending on how event was initialized. True if
|
2021-09-02 22:28:12 +00:00
|
|
|
* event invokes listeners past a ShadowRoot node that is the root of its
|
|
|
|
* target, and false otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly composed: boolean;
|
|
|
|
/** Returns the object whose event listener's callback is currently being
|
2021-09-02 22:28:12 +00:00
|
|
|
* invoked. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly currentTarget: EventTarget | null;
|
|
|
|
/** Returns true if preventDefault() was invoked successfully to indicate
|
2021-09-02 22:28:12 +00:00
|
|
|
* cancellation, and false otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly defaultPrevented: boolean;
|
|
|
|
/** Returns the event's phase, which is one of NONE, CAPTURING_PHASE,
|
2021-09-02 22:28:12 +00:00
|
|
|
* AT_TARGET, and BUBBLING_PHASE. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly eventPhase: number;
|
|
|
|
/** Returns true if event was dispatched by the user agent, and false
|
2021-09-02 22:28:12 +00:00
|
|
|
* otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
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
|
2021-09-02 22:28:12 +00:00
|
|
|
* relative to the time origin. */
|
2020-08-07 14:55:02 +00:00
|
|
|
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
|
2021-09-02 22:28:12 +00:00
|
|
|
* 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. */
|
2020-08-07 14:55:02 +00:00
|
|
|
composedPath(): EventTarget[];
|
|
|
|
/** If invoked when the cancelable attribute value is true, and while
|
2021-09-02 22:28:12 +00:00
|
|
|
* 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. */
|
2020-08-07 14:55:02 +00:00
|
|
|
preventDefault(): void;
|
|
|
|
/** Invoking this method prevents event from reaching any registered event
|
2021-09-02 22:28:12 +00:00
|
|
|
* listeners after the current one finishes running and, when dispatched in a
|
|
|
|
* tree, also prevents event from reaching any other objects. */
|
2020-08-07 14:55:02 +00:00
|
|
|
stopImmediatePropagation(): void;
|
|
|
|
/** When dispatched in a tree, invoking this method prevents event from
|
2021-09-02 22:28:12 +00:00
|
|
|
* reaching any objects other than the current object. */
|
2020-08-07 14:55:02 +00:00
|
|
|
stopPropagation(): void;
|
|
|
|
readonly AT_TARGET: number;
|
|
|
|
readonly BUBBLING_PHASE: number;
|
|
|
|
readonly CAPTURING_PHASE: number;
|
|
|
|
readonly NONE: number;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** An event which takes place in the DOM.
|
|
|
|
*
|
|
|
|
* @category DOM Events
|
|
|
|
*/
|
|
|
|
declare var Event: {
|
|
|
|
readonly prototype: Event;
|
|
|
|
new (type: string, eventInitDict?: EventInit): Event;
|
|
|
|
readonly AT_TARGET: number;
|
|
|
|
readonly BUBBLING_PHASE: number;
|
|
|
|
readonly CAPTURING_PHASE: number;
|
|
|
|
readonly NONE: number;
|
|
|
|
};
|
|
|
|
|
2020-08-07 14:55:02 +00:00
|
|
|
/**
|
2021-09-02 22:28:12 +00:00
|
|
|
* EventTarget is a DOM interface implemented by objects that can receive events
|
|
|
|
* and may have listeners for them.
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category DOM Events
|
2021-09-02 22:28:12 +00:00
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface EventTarget {
|
2020-08-07 14:55:02 +00:00
|
|
|
/** Appends an event listener for events whose type attribute value is type.
|
2021-04-14 20:49:16 +00:00
|
|
|
* 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. */
|
2020-08-07 14:55:02 +00:00
|
|
|
addEventListener(
|
|
|
|
type: string,
|
|
|
|
listener: EventListenerOrEventListenerObject | null,
|
|
|
|
options?: boolean | AddEventListenerOptions,
|
|
|
|
): void;
|
2023-10-23 12:34:37 +00:00
|
|
|
/** Dispatches a synthetic event to event target and returns true if either
|
2021-04-14 20:49:16 +00:00
|
|
|
* event's cancelable attribute value is false or its preventDefault() method
|
|
|
|
* was not invoked, and false otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
dispatchEvent(event: Event): boolean;
|
|
|
|
/** Removes the event listener in target's event listener list with the same
|
2021-04-14 20:49:16 +00:00
|
|
|
* type, callback, and options. */
|
2020-08-07 14:55:02 +00:00
|
|
|
removeEventListener(
|
|
|
|
type: string,
|
|
|
|
callback: EventListenerOrEventListenerObject | null,
|
|
|
|
options?: EventListenerOptions | boolean,
|
|
|
|
): void;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/**
|
|
|
|
* EventTarget is a DOM interface implemented by objects that can receive events
|
|
|
|
* and may have listeners for them.
|
|
|
|
*
|
|
|
|
* @category DOM Events
|
|
|
|
*/
|
|
|
|
declare var EventTarget: {
|
|
|
|
readonly prototype: EventTarget;
|
|
|
|
new (): EventTarget;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface EventListener {
|
2020-08-07 14:55:02 +00:00
|
|
|
(evt: Event): void | Promise<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface EventListenerObject {
|
2020-08-07 14:55:02 +00:00
|
|
|
handleEvent(evt: Event): void | Promise<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2020-08-07 14:55:02 +00:00
|
|
|
declare type EventListenerOrEventListenerObject =
|
|
|
|
| EventListener
|
|
|
|
| EventListenerObject;
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface AddEventListenerOptions extends EventListenerOptions {
|
2020-08-07 14:55:02 +00:00
|
|
|
once?: boolean;
|
|
|
|
passive?: boolean;
|
2022-06-17 15:05:02 +00:00
|
|
|
signal?: AbortSignal;
|
2020-08-07 14:55:02 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface EventListenerOptions {
|
2020-08-07 14:55:02 +00:00
|
|
|
capture?: boolean;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM Events */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ProgressEventInit extends EventInit {
|
2020-12-26 17:15:30 +00:00
|
|
|
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
|
2022-08-17 03:12:24 +00:00
|
|
|
* <img>, <audio>, <video>, <style> or <link>).
|
|
|
|
*
|
|
|
|
* @category DOM Events
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ProgressEvent<T extends EventTarget = EventTarget>
|
|
|
|
extends Event {
|
2020-12-26 17:15:30 +00:00
|
|
|
readonly lengthComputable: boolean;
|
|
|
|
readonly loaded: number;
|
|
|
|
readonly target: T | null;
|
|
|
|
readonly total: number;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** 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 var ProgressEvent: {
|
|
|
|
readonly prototype: ProgressEvent;
|
|
|
|
new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
|
|
|
|
};
|
|
|
|
|
2020-08-07 14:55:02 +00:00
|
|
|
/** Decodes a string of data which has been encoded using base-64 encoding.
|
|
|
|
*
|
2022-02-22 19:41:59 +00:00
|
|
|
* ```
|
|
|
|
* console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
|
|
|
|
* ```
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category Encoding API
|
2020-08-07 14:55:02 +00:00
|
|
|
*/
|
|
|
|
declare function atob(s: string): string;
|
|
|
|
|
|
|
|
/** Creates a base-64 ASCII encoded string from the input string.
|
|
|
|
*
|
2022-02-22 19:41:59 +00:00
|
|
|
* ```
|
|
|
|
* console.log(btoa("hello world")); // outputs "aGVsbG8gd29ybGQ="
|
|
|
|
* ```
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category Encoding API
|
2020-08-07 14:55:02 +00:00
|
|
|
*/
|
|
|
|
declare function btoa(s: string): string;
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-06-05 21:10:07 +00:00
|
|
|
declare interface TextDecoderOptions {
|
|
|
|
fatal?: boolean;
|
|
|
|
ignoreBOM?: boolean;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-06-05 21:10:07 +00:00
|
|
|
declare interface TextDecodeOptions {
|
|
|
|
stream?: boolean;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TextDecoder {
|
2021-04-02 01:12:07 +00:00
|
|
|
/** Returns encoding's name, lowercased. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly encoding: string;
|
2021-04-02 01:12:07 +00:00
|
|
|
/** Returns `true` if error mode is "fatal", and `false` otherwise. */
|
2020-08-07 14:55:02 +00:00
|
|
|
readonly fatal: boolean;
|
2021-04-02 01:12:07 +00:00
|
|
|
/** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
|
2021-10-21 06:47:14 +00:00
|
|
|
readonly ignoreBOM: boolean;
|
2021-06-05 21:10:07 +00:00
|
|
|
|
2021-06-06 01:23:16 +00:00
|
|
|
/** Returns the result of running encoding's decoder. */
|
2021-06-05 21:10:07 +00:00
|
|
|
decode(input?: BufferSource, options?: TextDecodeOptions): string;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var TextDecoder: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: TextDecoder;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoder;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-06-05 21:10:07 +00:00
|
|
|
declare interface TextEncoderEncodeIntoResult {
|
|
|
|
read: number;
|
|
|
|
written: number;
|
2021-04-02 01:12:07 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TextEncoder {
|
2021-04-02 01:12:07 +00:00
|
|
|
/** Returns "utf-8". */
|
2021-06-06 01:23:16 +00:00
|
|
|
readonly encoding: "utf-8";
|
2021-04-02 01:12:07 +00:00
|
|
|
/** Returns the result of running UTF-8's encoder. */
|
2020-08-07 14:55:02 +00:00
|
|
|
encode(input?: string): Uint8Array;
|
2021-06-05 21:10:07 +00:00
|
|
|
encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult;
|
2020-08-07 14:55:02 +00:00
|
|
|
}
|
2020-08-19 12:43:20 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var TextEncoder: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: TextEncoder;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (): TextEncoder;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TextDecoderStream {
|
2021-06-06 01:23:16 +00:00
|
|
|
/** 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. */
|
2021-10-21 06:47:14 +00:00
|
|
|
readonly ignoreBOM: boolean;
|
2021-06-06 01:23:16 +00:00
|
|
|
readonly readable: ReadableStream<string>;
|
|
|
|
readonly writable: WritableStream<BufferSource>;
|
|
|
|
readonly [Symbol.toStringTag]: string;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var TextDecoderStream: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: TextDecoderStream;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TextEncoderStream {
|
2021-06-06 01:23:16 +00:00
|
|
|
/** Returns "utf-8". */
|
|
|
|
readonly encoding: "utf-8";
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
readonly writable: WritableStream<string>;
|
|
|
|
readonly [Symbol.toStringTag]: string;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Encoding API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var TextEncoderStream: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: TextEncoderStream;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (): TextEncoderStream;
|
|
|
|
};
|
|
|
|
|
2020-08-19 12:43:20 +00:00
|
|
|
/** A controller object that allows you to abort one or more DOM requests as and
|
2022-08-17 03:12:24 +00:00
|
|
|
* when desired.
|
|
|
|
*
|
|
|
|
* @category Web APIs
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface AbortController {
|
2020-08-19 12:43:20 +00:00
|
|
|
/** Returns the AbortSignal object associated with this object. */
|
|
|
|
readonly signal: AbortSignal;
|
|
|
|
/** Invoking this method will set this object's AbortSignal's aborted flag and
|
2021-09-02 22:28:12 +00:00
|
|
|
* signal to any observers that the associated activity is to be aborted. */
|
2021-11-11 09:28:06 +00:00
|
|
|
abort(reason?: any): void;
|
2020-08-19 12:43:20 +00:00
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** A controller object that allows you to abort one or more DOM requests as and
|
|
|
|
* when desired.
|
|
|
|
*
|
|
|
|
* @category Web APIs
|
|
|
|
*/
|
|
|
|
declare var AbortController: {
|
|
|
|
readonly prototype: AbortController;
|
|
|
|
new (): AbortController;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web APIs */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface AbortSignalEventMap {
|
2020-08-19 12:43:20 +00:00
|
|
|
abort: Event;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** A signal object that allows you to communicate with a DOM request (such as a
|
2022-08-17 03:12:24 +00:00
|
|
|
* Fetch) and abort it if required via an AbortController object.
|
|
|
|
*
|
|
|
|
* @category Web APIs
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface AbortSignal extends EventTarget {
|
2020-08-19 12:43:20 +00:00
|
|
|
/** Returns true if this AbortSignal's AbortController has signaled to abort,
|
2021-09-02 22:28:12 +00:00
|
|
|
* and false otherwise. */
|
2020-08-19 12:43:20 +00:00
|
|
|
readonly aborted: boolean;
|
2022-06-01 00:19:18 +00:00
|
|
|
readonly reason: any;
|
2020-08-19 12:43:20 +00:00
|
|
|
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;
|
2021-12-10 14:12:38 +00:00
|
|
|
|
|
|
|
/** Throws this AbortSignal's abort reason, if its AbortController has
|
|
|
|
* signaled to abort; otherwise, does nothing. */
|
|
|
|
throwIfAborted(): void;
|
2020-08-19 12:43:20 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web APIs */
|
2020-09-25 21:23:35 +00:00
|
|
|
declare var AbortSignal: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: AbortSignal;
|
|
|
|
new (): never;
|
2021-11-11 09:28:06 +00:00
|
|
|
abort(reason?: any): AbortSignal;
|
2023-11-13 00:04:11 +00:00
|
|
|
any(signals: AbortSignal[]): AbortSignal;
|
2022-03-14 19:19:22 +00:00
|
|
|
timeout(milliseconds: number): AbortSignal;
|
2020-08-19 12:43:20 +00:00
|
|
|
};
|
2020-09-18 14:01:50 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web File API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface FileReaderEventMap {
|
2020-09-18 14:01:50 +00:00
|
|
|
"abort": ProgressEvent<FileReader>;
|
|
|
|
"error": ProgressEvent<FileReader>;
|
|
|
|
"load": ProgressEvent<FileReader>;
|
|
|
|
"loadend": ProgressEvent<FileReader>;
|
|
|
|
"loadstart": ProgressEvent<FileReader>;
|
|
|
|
"progress": ProgressEvent<FileReader>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** 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
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface FileReader extends EventTarget {
|
2020-09-18 14:01:50 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web File API */
|
2020-09-18 14:01:50 +00:00
|
|
|
declare var FileReader: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: FileReader;
|
2020-09-18 14:01:50 +00:00
|
|
|
new (): FileReader;
|
|
|
|
readonly DONE: number;
|
|
|
|
readonly EMPTY: number;
|
|
|
|
readonly LOADING: number;
|
|
|
|
};
|
2021-06-10 13:26:10 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web File API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare type BlobPart = BufferSource | Blob | string;
|
2021-06-10 13:26:10 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web File API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface BlobPropertyBag {
|
2021-06-10 13:26:10 +00:00
|
|
|
type?: string;
|
|
|
|
endings?: "transparent" | "native";
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** 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
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface Blob {
|
2021-06-10 13:26:10 +00:00
|
|
|
readonly size: number;
|
|
|
|
readonly type: string;
|
|
|
|
arrayBuffer(): Promise<ArrayBuffer>;
|
|
|
|
slice(start?: number, end?: number, contentType?: string): Blob;
|
|
|
|
stream(): ReadableStream<Uint8Array>;
|
|
|
|
text(): Promise<string>;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** 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 var Blob: {
|
|
|
|
readonly prototype: Blob;
|
|
|
|
new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Web File API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface FilePropertyBag extends BlobPropertyBag {
|
2021-06-10 13:26:10 +00:00
|
|
|
lastModified?: number;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Provides information about files and allows JavaScript in a web page to
|
2022-08-17 03:12:24 +00:00
|
|
|
* access their content.
|
|
|
|
*
|
|
|
|
* @category Web File API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface File extends Blob {
|
2021-06-10 13:26:10 +00:00
|
|
|
readonly lastModified: number;
|
|
|
|
readonly name: string;
|
|
|
|
}
|
2021-06-14 11:51:02 +00:00
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** Provides information about files and allows JavaScript in a web page to
|
|
|
|
* access their content.
|
|
|
|
*
|
|
|
|
* @category Web File API
|
|
|
|
*/
|
|
|
|
declare var File: {
|
|
|
|
readonly prototype: File;
|
|
|
|
new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamDefaultReadDoneResult {
|
2021-06-14 11:51:02 +00:00
|
|
|
done: true;
|
2022-11-30 15:24:13 +00:00
|
|
|
value?: undefined;
|
2021-06-14 11:51:02 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamDefaultReadValueResult<T> {
|
2021-06-14 11:51:02 +00:00
|
|
|
done: false;
|
|
|
|
value: T;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare type ReadableStreamDefaultReadResult<T> =
|
2022-11-30 15:24:13 +00:00
|
|
|
| ReadableStreamDefaultReadValueResult<T>
|
|
|
|
| ReadableStreamDefaultReadDoneResult;
|
2021-06-14 11:51:02 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamDefaultReader<R = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly closed: Promise<void>;
|
|
|
|
cancel(reason?: any): Promise<void>;
|
2022-11-30 15:24:13 +00:00
|
|
|
read(): Promise<ReadableStreamDefaultReadResult<R>>;
|
2021-06-14 11:51:02 +00:00
|
|
|
releaseLock(): void;
|
|
|
|
}
|
|
|
|
|
2022-11-30 15:24:13 +00:00
|
|
|
/** @category Streams API */
|
|
|
|
declare var ReadableStreamDefaultReader: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ReadableStreamDefaultReader;
|
2022-11-30 15:24:13 +00:00
|
|
|
new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> {
|
2021-11-03 09:47:40 +00:00
|
|
|
done: true;
|
2021-11-05 11:56:28 +00:00
|
|
|
value?: V;
|
2021-11-03 09:47:40 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> {
|
2021-11-03 09:47:40 +00:00
|
|
|
done: false;
|
2021-11-05 11:56:28 +00:00
|
|
|
value: V;
|
2021-11-03 09:47:40 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare type ReadableStreamBYOBReadResult<V extends ArrayBufferView> =
|
2021-11-05 11:56:28 +00:00
|
|
|
| ReadableStreamBYOBReadDoneResult<V>
|
|
|
|
| ReadableStreamBYOBReadValueResult<V>;
|
2021-11-03 09:47:40 +00:00
|
|
|
|
2023-11-24 22:24:41 +00:00
|
|
|
/** @category Streams API */
|
|
|
|
declare interface ReadableStreamBYOBReaderReadOptions {
|
|
|
|
min?: number;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamBYOBReader {
|
2021-11-03 09:47:40 +00:00
|
|
|
readonly closed: Promise<void>;
|
|
|
|
cancel(reason?: any): Promise<void>;
|
2021-11-05 11:56:28 +00:00
|
|
|
read<V extends ArrayBufferView>(
|
|
|
|
view: V,
|
2023-11-24 22:24:41 +00:00
|
|
|
options?: ReadableStreamBYOBReaderReadOptions,
|
2021-11-05 11:56:28 +00:00
|
|
|
): Promise<ReadableStreamBYOBReadResult<V>>;
|
2021-11-03 09:47:40 +00:00
|
|
|
releaseLock(): void;
|
|
|
|
}
|
|
|
|
|
2022-11-30 15:24:13 +00:00
|
|
|
/** @category Streams API */
|
|
|
|
declare var ReadableStreamBYOBReader: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ReadableStreamBYOBReader;
|
2022-11-30 15:24:13 +00:00
|
|
|
new (stream: ReadableStream<Uint8Array>): ReadableStreamBYOBReader;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamBYOBRequest {
|
2021-11-03 09:47:40 +00:00
|
|
|
readonly view: ArrayBufferView | null;
|
|
|
|
respond(bytesWritten: number): void;
|
|
|
|
respondWithNewView(view: ArrayBufferView): void;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare var ReadableStreamBYOBRequest: {
|
|
|
|
readonly prototype: ReadableStreamBYOBRequest;
|
|
|
|
new (): never;
|
|
|
|
};
|
|
|
|
|
|
|
|
/** @category Streams API */
|
|
|
|
declare interface ReadableByteStreamControllerCallback {
|
2021-06-14 11:51:02 +00:00
|
|
|
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface UnderlyingByteSource {
|
2021-06-14 11:51:02 +00:00
|
|
|
autoAllocateChunkSize?: number;
|
|
|
|
cancel?: ReadableStreamErrorCallback;
|
|
|
|
pull?: ReadableByteStreamControllerCallback;
|
|
|
|
start?: ReadableByteStreamControllerCallback;
|
|
|
|
type: "bytes";
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface UnderlyingSink<W = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
abort?: WritableStreamErrorCallback;
|
|
|
|
close?: WritableStreamDefaultControllerCloseCallback;
|
|
|
|
start?: WritableStreamDefaultControllerStartCallback;
|
|
|
|
type?: undefined;
|
|
|
|
write?: WritableStreamDefaultControllerWriteCallback<W>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface UnderlyingSource<R = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
cancel?: ReadableStreamErrorCallback;
|
|
|
|
pull?: ReadableStreamDefaultControllerCallback<R>;
|
|
|
|
start?: ReadableStreamDefaultControllerCallback<R>;
|
|
|
|
type?: undefined;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamErrorCallback {
|
2021-06-14 11:51:02 +00:00
|
|
|
(reason: any): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamDefaultControllerCallback<R> {
|
2021-06-14 11:51:02 +00:00
|
|
|
(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStreamDefaultController<R = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly desiredSize: number | null;
|
|
|
|
close(): void;
|
|
|
|
enqueue(chunk: R): void;
|
|
|
|
error(error?: any): void;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var ReadableStreamDefaultController: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ReadableStreamDefaultController;
|
|
|
|
new (): never;
|
2021-06-14 11:51:02 +00:00
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableByteStreamController {
|
2021-11-03 09:47:40 +00:00
|
|
|
readonly byobRequest: ReadableStreamBYOBRequest | null;
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly desiredSize: number | null;
|
|
|
|
close(): void;
|
|
|
|
enqueue(chunk: ArrayBufferView): void;
|
|
|
|
error(error?: any): void;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var ReadableByteStreamController: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ReadableByteStreamController;
|
|
|
|
new (): never;
|
2021-06-14 11:51:02 +00:00
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface PipeOptions {
|
2021-06-14 11:51:02 +00:00
|
|
|
preventAbort?: boolean;
|
|
|
|
preventCancel?: boolean;
|
|
|
|
preventClose?: boolean;
|
|
|
|
signal?: AbortSignal;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface QueuingStrategySizeCallback<T = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
(chunk: T): number;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface QueuingStrategy<T = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
highWaterMark?: number;
|
|
|
|
size?: QueuingStrategySizeCallback<T>;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** This Streams API interface provides a built-in byte length queuing strategy
|
2022-08-17 03:12:24 +00:00
|
|
|
* that can be used when constructing streams.
|
|
|
|
*
|
|
|
|
* @category Streams API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface CountQueuingStrategy extends QueuingStrategy {
|
2021-06-14 11:51:02 +00:00
|
|
|
highWaterMark: number;
|
|
|
|
size(chunk: any): 1;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var CountQueuingStrategy: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: CountQueuingStrategy;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (options: { highWaterMark: number }): CountQueuingStrategy;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ByteLengthQueuingStrategy
|
|
|
|
extends QueuingStrategy<ArrayBufferView> {
|
2021-06-14 11:51:02 +00:00
|
|
|
highWaterMark: number;
|
|
|
|
size(chunk: ArrayBufferView): number;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-10-21 06:47:14 +00:00
|
|
|
declare var ByteLengthQueuingStrategy: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ByteLengthQueuingStrategy;
|
2021-10-21 06:47:14 +00:00
|
|
|
new (options: { highWaterMark: number }): ByteLengthQueuingStrategy;
|
|
|
|
};
|
|
|
|
|
2021-06-14 11:51:02 +00:00
|
|
|
/** This Streams API interface represents a readable stream of byte data. The
|
|
|
|
* Fetch API offers a concrete instance of a ReadableStream through the body
|
2022-08-17 03:12:24 +00:00
|
|
|
* property of a Response object.
|
|
|
|
*
|
|
|
|
* @category Streams API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface ReadableStream<R = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly locked: boolean;
|
|
|
|
cancel(reason?: any): Promise<void>;
|
2021-11-05 11:56:28 +00:00
|
|
|
getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
|
|
|
|
getReader(options?: { mode?: undefined }): ReadableStreamDefaultReader<R>;
|
2022-10-26 13:53:48 +00:00
|
|
|
pipeThrough<T>(transform: {
|
|
|
|
writable: WritableStream<R>;
|
|
|
|
readable: ReadableStream<T>;
|
|
|
|
}, options?: PipeOptions): ReadableStream<T>;
|
2021-06-14 11:51:02 +00:00
|
|
|
pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
|
|
|
|
tee(): [ReadableStream<R>, ReadableStream<R>];
|
2023-07-03 18:36:55 +00:00
|
|
|
values(options?: {
|
|
|
|
preventCancel?: boolean;
|
|
|
|
}): AsyncIterableIterator<R>;
|
2021-06-14 11:51:02 +00:00
|
|
|
[Symbol.asyncIterator](options?: {
|
|
|
|
preventCancel?: boolean;
|
|
|
|
}): AsyncIterableIterator<R>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var ReadableStream: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: ReadableStream;
|
2021-06-14 11:51:02 +00:00
|
|
|
new (
|
|
|
|
underlyingSource: UnderlyingByteSource,
|
|
|
|
strategy?: { highWaterMark?: number; size?: undefined },
|
|
|
|
): ReadableStream<Uint8Array>;
|
|
|
|
new <R = any>(
|
|
|
|
underlyingSource?: UnderlyingSource<R>,
|
|
|
|
strategy?: QueuingStrategy<R>,
|
|
|
|
): ReadableStream<R>;
|
2023-07-03 18:36:55 +00:00
|
|
|
from<R>(
|
|
|
|
asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>,
|
|
|
|
): ReadableStream<R>;
|
2021-06-14 11:51:02 +00:00
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamDefaultControllerCloseCallback {
|
2021-06-14 11:51:02 +00:00
|
|
|
(): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamDefaultControllerStartCallback {
|
2021-06-14 11:51:02 +00:00
|
|
|
(controller: WritableStreamDefaultController): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamDefaultControllerWriteCallback<W> {
|
2021-06-14 11:51:02 +00:00
|
|
|
(chunk: W, controller: WritableStreamDefaultController):
|
|
|
|
| void
|
|
|
|
| PromiseLike<
|
|
|
|
void
|
|
|
|
>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamErrorCallback {
|
2021-06-14 11:51:02 +00:00
|
|
|
(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
|
2022-08-17 03:12:24 +00:00
|
|
|
* built-in backpressure and queuing.
|
|
|
|
*
|
|
|
|
* @category Streams API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStream<W = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly locked: boolean;
|
|
|
|
abort(reason?: any): Promise<void>;
|
2022-04-20 22:20:33 +00:00
|
|
|
close(): Promise<void>;
|
2021-06-14 11:51:02 +00:00
|
|
|
getWriter(): WritableStreamDefaultWriter<W>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var WritableStream: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: WritableStream;
|
2021-06-14 11:51:02 +00:00
|
|
|
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
|
2022-08-17 03:12:24 +00:00
|
|
|
* manipulate.
|
|
|
|
*
|
|
|
|
* @category Streams API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamDefaultController {
|
2021-11-08 11:54:24 +00:00
|
|
|
signal: AbortSignal;
|
2021-06-14 11:51:02 +00:00
|
|
|
error(error?: any): void;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare var WritableStreamDefaultController: {
|
|
|
|
readonly prototype: WritableStreamDefaultController;
|
|
|
|
new (): never;
|
|
|
|
};
|
2021-10-21 06:47:14 +00:00
|
|
|
|
2021-06-14 11:51:02 +00:00
|
|
|
/** 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
|
2022-08-17 03:12:24 +00:00
|
|
|
* sink.
|
|
|
|
*
|
|
|
|
* @category Streams API
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface WritableStreamDefaultWriter<W = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
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>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var WritableStreamDefaultWriter: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: WritableStreamDefaultWriter;
|
|
|
|
new <W>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
|
2021-06-14 11:51:02 +00:00
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TransformStream<I = any, O = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly readable: ReadableStream<O>;
|
|
|
|
readonly writable: WritableStream<I>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2021-06-14 11:51:02 +00:00
|
|
|
declare var TransformStream: {
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly prototype: TransformStream;
|
2021-06-14 11:51:02 +00:00
|
|
|
new <I = any, O = any>(
|
|
|
|
transformer?: Transformer<I, O>,
|
|
|
|
writableStrategy?: QueuingStrategy<I>,
|
|
|
|
readableStrategy?: QueuingStrategy<O>,
|
|
|
|
): TransformStream<I, O>;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TransformStreamDefaultController<O = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
readonly desiredSize: number | null;
|
|
|
|
enqueue(chunk: O): void;
|
|
|
|
error(reason?: any): void;
|
|
|
|
terminate(): void;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare var TransformStreamDefaultController: {
|
|
|
|
readonly prototype: TransformStreamDefaultController;
|
|
|
|
new (): never;
|
|
|
|
};
|
2021-10-21 06:47:14 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface Transformer<I = any, O = any> {
|
2021-06-14 11:51:02 +00:00
|
|
|
flush?: TransformStreamDefaultControllerCallback<O>;
|
|
|
|
readableType?: undefined;
|
|
|
|
start?: TransformStreamDefaultControllerCallback<O>;
|
|
|
|
transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
|
2023-10-10 09:42:31 +00:00
|
|
|
cancel?: (reason: any) => Promise<void>;
|
2021-06-14 11:51:02 +00:00
|
|
|
writableType?: undefined;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TransformStreamDefaultControllerCallback<O> {
|
2021-06-14 11:51:02 +00:00
|
|
|
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
|
|
|
}
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category Streams API */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface TransformStreamDefaultControllerTransformCallback<I, O> {
|
2021-06-14 11:51:02 +00:00
|
|
|
(
|
|
|
|
chunk: I,
|
|
|
|
controller: TransformStreamDefaultController<O>,
|
|
|
|
): void | PromiseLike<void>;
|
|
|
|
}
|
2021-06-21 17:53:52 +00:00
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** @category DOM APIs */
|
|
|
|
declare interface MessageEventInit<T = any> extends EventInit {
|
2021-06-21 17:53:52 +00:00
|
|
|
data?: T;
|
|
|
|
origin?: string;
|
|
|
|
lastEventId?: string;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** @category DOM APIs */
|
|
|
|
declare interface MessageEvent<T = any> extends Event {
|
2021-06-21 17:53:52 +00:00
|
|
|
/**
|
|
|
|
* Returns the data of the message.
|
|
|
|
*/
|
|
|
|
readonly data: T;
|
2023-07-03 18:36:55 +00:00
|
|
|
/**
|
|
|
|
* Returns the origin of the message, for server-sent events.
|
|
|
|
*/
|
|
|
|
readonly origin: string;
|
2021-06-21 17:53:52 +00:00
|
|
|
/**
|
|
|
|
* Returns the last event ID string, for server-sent events.
|
|
|
|
*/
|
|
|
|
readonly lastEventId: string;
|
2023-07-03 18:36:55 +00:00
|
|
|
readonly source: null;
|
2021-06-21 17:53:52 +00:00
|
|
|
/**
|
2022-06-07 09:25:10 +00:00
|
|
|
* Returns transferred ports.
|
2021-06-21 17:53:52 +00:00
|
|
|
*/
|
|
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
|
|
}
|
|
|
|
|
2022-08-30 11:16:56 +00:00
|
|
|
/** @category DOM APIs */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare var MessageEvent: {
|
|
|
|
readonly prototype: MessageEvent;
|
|
|
|
new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
|
|
|
|
};
|
|
|
|
|
|
|
|
/** @category DOM APIs */
|
|
|
|
declare type Transferable = ArrayBuffer | MessagePort;
|
2021-06-21 17:53:52 +00:00
|
|
|
|
2021-08-09 08:39:00 +00:00
|
|
|
/**
|
|
|
|
* This type has been renamed to StructuredSerializeOptions. Use that type for
|
|
|
|
* new code.
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @deprecated use `StructuredSerializeOptions` instead.
|
|
|
|
* @category DOM APIs
|
2021-08-09 08:39:00 +00:00
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare type PostMessageOptions = StructuredSerializeOptions;
|
2021-08-09 08:39:00 +00:00
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM APIs */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface StructuredSerializeOptions {
|
2021-06-21 17:53:52 +00:00
|
|
|
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
|
2022-08-17 03:12:24 +00:00
|
|
|
* properties.
|
|
|
|
*
|
|
|
|
* @category DOM APIs
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface MessageChannel {
|
2021-06-21 17:53:52 +00:00
|
|
|
readonly port1: MessagePort;
|
|
|
|
readonly port2: MessagePort;
|
|
|
|
}
|
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** 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 var MessageChannel: {
|
|
|
|
readonly prototype: MessageChannel;
|
|
|
|
new (): MessageChannel;
|
|
|
|
};
|
|
|
|
|
2022-08-17 03:12:24 +00:00
|
|
|
/** @category DOM APIs */
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface MessagePortEventMap {
|
2021-06-21 17:53:52 +00:00
|
|
|
"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
|
2022-08-17 03:12:24 +00:00
|
|
|
* listening out for them arriving at the other.
|
|
|
|
*
|
|
|
|
* @category DOM APIs
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface MessagePort extends EventTarget {
|
2021-06-21 17:53:52 +00:00
|
|
|
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;
|
2021-08-09 08:39:00 +00:00
|
|
|
postMessage(message: any, options?: StructuredSerializeOptions): void;
|
2021-06-21 17:53:52 +00:00
|
|
|
/**
|
2022-10-12 07:47:15 +00:00
|
|
|
* Begins dispatching messages received on the port. This is implicitly called
|
|
|
|
* when assigning a value to `this.onmessage`.
|
2021-06-21 17:53:52 +00:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
}
|
2021-08-09 08:39:00 +00:00
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/** 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 var MessagePort: {
|
|
|
|
readonly prototype: MessagePort;
|
|
|
|
new (): never;
|
|
|
|
};
|
|
|
|
|
2022-02-22 19:41:59 +00:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
* ```
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category DOM APIs
|
2022-02-22 19:41:59 +00:00
|
|
|
*/
|
2021-08-09 08:39:00 +00:00
|
|
|
declare function structuredClone(
|
|
|
|
value: any,
|
|
|
|
options?: StructuredSerializeOptions,
|
|
|
|
): any;
|
2022-01-24 17:03:06 +00:00
|
|
|
|
2022-02-22 19:41:59 +00:00
|
|
|
/**
|
|
|
|
* An API for compressing a stream of data.
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* ```ts
|
|
|
|
* await Deno.stdin.readable
|
|
|
|
* .pipeThrough(new CompressionStream("gzip"))
|
|
|
|
* .pipeTo(Deno.stdout.writable);
|
|
|
|
* ```
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category Compression Streams API
|
2022-02-22 19:41:59 +00:00
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare interface CompressionStream {
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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 var CompressionStream: {
|
|
|
|
readonly prototype: CompressionStream;
|
2022-02-22 19:41:59 +00:00
|
|
|
/**
|
|
|
|
* Creates a new `CompressionStream` object which compresses a stream of
|
|
|
|
* data.
|
|
|
|
*
|
|
|
|
* Throws a `TypeError` if the format passed to the constructor is not
|
|
|
|
* supported.
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
new (format: string): CompressionStream;
|
|
|
|
};
|
2022-01-24 17:03:06 +00:00
|
|
|
|
2023-07-03 18:36:55 +00:00
|
|
|
/**
|
|
|
|
* 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 interface DecompressionStream {
|
2022-01-24 17:03:06 +00:00
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
|
|
}
|
|
|
|
|
2022-02-22 19:41:59 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
* ```
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category Compression Streams API
|
2022-02-22 19:41:59 +00:00
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
declare var DecompressionStream: {
|
|
|
|
readonly prototype: DecompressionStream;
|
2022-02-22 19:41:59 +00:00
|
|
|
/**
|
|
|
|
* Creates a new `DecompressionStream` object which decompresses a stream of
|
|
|
|
* data.
|
|
|
|
*
|
|
|
|
* Throws a `TypeError` if the format passed to the constructor is not
|
|
|
|
* supported.
|
|
|
|
*/
|
2023-07-03 18:36:55 +00:00
|
|
|
new (format: string): DecompressionStream;
|
|
|
|
};
|
2022-04-19 08:59:51 +00:00
|
|
|
|
|
|
|
/** 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.
|
2022-08-17 03:12:24 +00:00
|
|
|
*
|
|
|
|
* @category Web APIs
|
2022-04-19 08:59:51 +00:00
|
|
|
*/
|
|
|
|
declare function reportError(
|
|
|
|
error: any,
|
|
|
|
): void;
|
2024-02-07 00:11:15 +00:00
|
|
|
|
|
|
|
/** @category Web APIs */
|
|
|
|
declare type PredefinedColorSpace = "srgb" | "display-p3";
|
|
|
|
|
|
|
|
/** @category Web APIs */
|
|
|
|
declare interface ImageDataSettings {
|
|
|
|
readonly colorSpace?: PredefinedColorSpace;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @category Web APIs */
|
|
|
|
declare interface ImageData {
|
|
|
|
readonly colorSpace: PredefinedColorSpace;
|
|
|
|
readonly data: Uint8ClampedArray;
|
|
|
|
readonly height: number;
|
|
|
|
readonly width: number;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @category Web APIs */
|
|
|
|
declare var ImageData: {
|
|
|
|
prototype: ImageData;
|
|
|
|
new (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
|
|
|
|
new (
|
|
|
|
data: Uint8ClampedArray,
|
|
|
|
sw: number,
|
|
|
|
sh?: number,
|
|
|
|
settings?: ImageDataSettings,
|
|
|
|
): ImageData;
|
|
|
|
};
|