intelephense
1.14.41.16.1
lib/lib.webworker.d.tslib/lib.webworker.d.ts+5116−1383
Index: package/lib/lib.webworker.d.ts
===================================================================
--- package/lib/lib.webworker.d.ts
+++ package/lib/lib.webworker.d.ts
@@ -64,8 +64,61 @@
samplerate?: number;
spatialRendering?: boolean;
}
+interface AudioDataCopyToOptions {
+ format?: AudioSampleFormat;
+ frameCount?: number;
+ frameOffset?: number;
+ planeIndex: number;
+}
+
+interface AudioDataInit {
+ data: BufferSource;
+ format: AudioSampleFormat;
+ numberOfChannels: number;
+ numberOfFrames: number;
+ sampleRate: number;
+ timestamp: number;
+ transfer?: ArrayBuffer[];
+}
+
+interface AudioDecoderConfig {
+ codec: string;
+ description?: AllowSharedBufferSource;
+ numberOfChannels: number;
+ sampleRate: number;
+}
+
+interface AudioDecoderInit {
+ error: WebCodecsErrorCallback;
+ output: AudioDataOutputCallback;
+}
+
+interface AudioDecoderSupport {
+ config?: AudioDecoderConfig;
+ supported?: boolean;
+}
+
+interface AudioEncoderConfig {
+ bitrate?: number;
+ bitrateMode?: BitrateMode;
+ codec: string;
+ numberOfChannels: number;
+ opus?: OpusEncoderConfig;
+ sampleRate: number;
+}
+
+interface AudioEncoderInit {
+ error: WebCodecsErrorCallback;
+ output: EncodedAudioChunkOutputCallback;
+}
+
+interface AudioEncoderSupport {
+ config?: AudioEncoderConfig;
+ supported?: boolean;
+}
+
interface AvcEncoderConfig {
format?: AvcBitstreamFormat;
}
@@ -105,8 +158,35 @@
reason?: string;
wasClean?: boolean;
}
+interface CookieInit {
+ domain?: string | null;
+ expires?: DOMHighResTimeStamp | null;
+ name: string;
+ partitioned?: boolean;
+ path?: string;
+ sameSite?: CookieSameSite;
+ value: string;
+}
+
+interface CookieListItem {
+ name?: string;
+ value?: string;
+}
+
+interface CookieStoreDeleteOptions {
+ domain?: string | null;
+ name: string;
+ partitioned?: boolean;
+ path?: string;
+}
+
+interface CookieStoreGetOptions {
+ name?: string;
+ url?: string;
+}
+
interface CryptoKeyPair {
privateKey: CryptoKey;
publicKey: CryptoKey;
}
@@ -180,8 +260,20 @@
interface EcdsaParams extends Algorithm {
hash: HashAlgorithmIdentifier;
}
+interface EncodedAudioChunkInit {
+ data: AllowSharedBufferSource;
+ duration?: number;
+ timestamp: number;
+ transfer?: ArrayBuffer[];
+ type: EncodedAudioChunkType;
+}
+
+interface EncodedAudioChunkMetadata {
+ decoderConfig?: AudioDecoderConfig;
+}
+
interface EncodedVideoChunkInit {
data: AllowSharedBufferSource;
duration?: number;
timestamp: number;
@@ -213,8 +305,13 @@
interface EventSourceInit {
withCredentials?: boolean;
}
+interface ExtendableCookieChangeEventInit extends ExtendableEventInit {
+ changed?: CookieList;
+ deleted?: CookieList;
+}
+
interface ExtendableEventInit extends EventInit {
}
interface ExtendableMessageEventInit extends ExtendableEventInit {
@@ -226,11 +323,10 @@
}
interface FetchEventInit extends ExtendableEventInit {
clientId?: string;
- handled?: Promise<undefined>;
+ handled?: Promise<void>;
preloadResponse?: Promise<any>;
- replacesClientId?: string;
request: Request;
resultingClientId?: string;
}
@@ -334,17 +430,33 @@
interface ImageDataSettings {
colorSpace?: PredefinedColorSpace;
}
+interface ImageDecodeOptions {
+ completeFramesOnly?: boolean;
+ frameIndex?: number;
+}
+
+interface ImageDecodeResult {
+ complete: boolean;
+ image: VideoFrame;
+}
+
+interface ImageDecoderInit {
+ colorSpaceConversion?: ColorSpaceConversion;
+ data: ImageBufferSource;
+ desiredHeight?: number;
+ desiredWidth?: number;
+ preferAnimation?: boolean;
+ transfer?: ArrayBuffer[];
+ type: string;
+}
+
interface ImageEncodeOptions {
quality?: number;
type?: string;
}
-interface ImportMeta {
- url: string;
-}
-
interface JsonWebKey {
alg?: string;
crv?: string;
d?: string;
@@ -368,8 +480,12 @@
interface KeyAlgorithm {
name: string;
}
+interface KeySystemTrackConfiguration {
+ robustness?: string;
+}
+
interface LockInfo {
clientId?: string;
mode?: LockMode;
name?: string;
@@ -387,34 +503,47 @@
steal?: boolean;
}
interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {
- configuration?: MediaDecodingConfiguration;
}
interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {
- configuration?: MediaEncodingConfiguration;
}
interface MediaCapabilitiesInfo {
powerEfficient: boolean;
smooth: boolean;
supported: boolean;
}
+interface MediaCapabilitiesKeySystemConfiguration {
+ audio?: KeySystemTrackConfiguration;
+ distinctiveIdentifier?: MediaKeysRequirement;
+ initDataType?: string;
+ keySystem: string;
+ persistentState?: MediaKeysRequirement;
+ sessionTypes?: string[];
+ video?: KeySystemTrackConfiguration;
+}
+
interface MediaConfiguration {
audio?: AudioConfiguration;
video?: VideoConfiguration;
}
interface MediaDecodingConfiguration extends MediaConfiguration {
+ keySystemConfiguration?: MediaCapabilitiesKeySystemConfiguration;
type: MediaDecodingType;
}
interface MediaEncodingConfiguration extends MediaConfiguration {
type: MediaEncodingType;
}
+interface MediaStreamTrackProcessorInit {
+ maxBufferSize?: number;
+}
+
interface MessageEventInit<T = any> extends EventInit {
data?: T;
lastEventId?: string;
origin?: string;
@@ -447,8 +576,17 @@
silent?: boolean | null;
tag?: string;
}
+interface OpusEncoderConfig {
+ complexity?: number;
+ format?: OpusBitstreamFormat;
+ frameDuration?: number;
+ packetlossperc?: number;
+ usedtx?: boolean;
+ useinbandfec?: boolean;
+}
+
interface Pbkdf2Params extends Algorithm {
hash: HashAlgorithmIdentifier;
iterations: number;
salt: BufferSource;
@@ -495,8 +633,13 @@
interface PushEventInit extends ExtendableEventInit {
data?: PushMessageDataInit;
}
+interface PushSubscriptionChangeEventInit extends ExtendableEventInit {
+ newSubscription?: PushSubscription;
+ oldSubscription?: PushSubscription;
+}
+
interface PushSubscriptionJSON {
endpoint?: string;
expirationTime?: EpochTimeStamp | null;
keys?: Record<string, string>;
@@ -520,23 +663,25 @@
*/
highWaterMark: number;
}
-interface RTCEncodedAudioFrameMetadata {
+interface RTCEncodedAudioFrameMetadata extends RTCEncodedFrameMetadata {
+ sequenceNumber?: number;
+}
+
+interface RTCEncodedFrameMetadata {
contributingSources?: number[];
+ mimeType?: string;
payloadType?: number;
- sequenceNumber?: number;
+ rtpTimestamp?: number;
synchronizationSource?: number;
}
-interface RTCEncodedVideoFrameMetadata {
- contributingSources?: number[];
+interface RTCEncodedVideoFrameMetadata extends RTCEncodedFrameMetadata {
dependencies?: number[];
frameId?: number;
height?: number;
- payloadType?: number;
spatialIndex?: number;
- synchronizationSource?: number;
temporalIndex?: number;
timestamp?: number;
width?: number;
}
@@ -549,11 +694,22 @@
*/
mode?: ReadableStreamReaderMode;
}
+interface ReadableStreamIteratorOptions {
+ /**
+ * Asynchronously iterates over the chunks in the stream's internal queue.
+ *
+ * Asynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader. The lock will be released if the async iterator's return() method is called, e.g. by breaking out of the loop.
+ *
+ * By default, calling the async iterator's return() method will also cancel the stream. To prevent this, use the stream's values() method, passing true for the preventCancel option.
+ */
+ preventCancel?: boolean;
+}
+
interface ReadableStreamReadDoneResult<T> {
done: true;
- value?: T;
+ value: T | undefined;
}
interface ReadableStreamReadValueResult<T> {
done: false;
@@ -646,18 +802,18 @@
interface SecurityPolicyViolationEventInit extends EventInit {
blockedURI?: string;
columnNumber?: number;
- disposition: SecurityPolicyViolationEventDisposition;
- documentURI: string;
- effectiveDirective: string;
+ disposition?: SecurityPolicyViolationEventDisposition;
+ documentURI?: string;
+ effectiveDirective?: string;
lineNumber?: number;
- originalPolicy: string;
+ originalPolicy?: string;
referrer?: string;
sample?: string;
sourceFile?: string;
- statusCode: number;
- violatedDirective: string;
+ statusCode?: number;
+ violatedDirective?: string;
}
interface StorageEstimate {
quota?: number;
@@ -756,8 +912,9 @@
bitrate: number;
colorGamut?: ColorGamut;
contentType: string;
framerate: number;
+ hasAlphaChannel?: boolean;
hdrMetadataType?: HdrMetadataType;
height: number;
scalabilityMode?: string;
transferFunction?: TransferFunction;
@@ -791,8 +948,9 @@
avc?: AvcEncoderConfig;
bitrate?: number;
bitrateMode?: VideoEncoderBitrateMode;
codec: string;
+ contentHint?: string;
displayHeight?: number;
displayWidth?: number;
framerate?: number;
hardwareAcceleration?: HardwareAcceleration;
@@ -802,11 +960,16 @@
width: number;
}
interface VideoEncoderEncodeOptions {
+ avc?: VideoEncoderEncodeOptionsForAvc;
keyFrame?: boolean;
}
+interface VideoEncoderEncodeOptionsForAvc {
+ quantizer?: number | null;
+}
+
interface VideoEncoderInit {
error: WebCodecsErrorCallback;
output: EncodedVideoChunkOutputCallback;
}
@@ -829,8 +992,10 @@
visibleRect?: DOMRectInit;
}
interface VideoFrameCopyToOptions {
+ colorSpace?: PredefinedColorSpace;
+ format?: VideoPixelFormat;
layout?: PlaneLayout[];
rect?: DOMRectInit;
}
@@ -880,12 +1045,15 @@
requireUnreliable?: boolean;
serverCertificateHashes?: WebTransportHash[];
}
-interface WebTransportSendStreamOptions {
+interface WebTransportSendOptions {
sendOrder?: number;
}
+interface WebTransportSendStreamOptions extends WebTransportSendOptions {
+}
+
interface WorkerOptions {
credentials?: RequestCredentials;
name?: string;
type?: WorkerType;
@@ -898,36 +1066,48 @@
type: WriteCommandType;
}
/**
- * The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type.
+ * The **`ANGLE_instanced_arrays`** extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays)
*/
interface ANGLE_instanced_arrays {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawArraysInstancedANGLE) */
+ /**
+ * The **`ANGLE_instanced_arrays.drawArraysInstancedANGLE()`** method of the WebGL API renders primitives from array data like the WebGLRenderingContext.drawArrays() method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawArraysInstancedANGLE)
+ */
drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawElementsInstancedANGLE) */
+ /**
+ * The **`ANGLE_instanced_arrays.drawElementsInstancedANGLE()`** method of the WebGL API renders primitives from array data like the WebGLRenderingContext.drawElements() method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawElementsInstancedANGLE)
+ */
drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/vertexAttribDivisorANGLE) */
+ /**
+ * The **ANGLE_instanced_arrays.vertexAttribDivisorANGLE()** method of the WebGL API modifies the rate at which generic vertex attributes advance when rendering multiple instances of primitives with ANGLE_instanced_arrays.drawArraysInstancedANGLE() and ANGLE_instanced_arrays.drawElementsInstancedANGLE().
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/vertexAttribDivisorANGLE)
+ */
vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88FE;
}
/**
- * A controller object that allows you to abort one or more DOM requests as and when desired.
+ * The **`AbortController`** interface represents a controller object that allows you to abort one or more Web requests as and when desired.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController)
*/
interface AbortController {
/**
- * Returns the AbortSignal object associated with this object.
+ * The **`signal`** read-only property of the AbortController interface returns an AbortSignal object instance, which can be used to communicate with/abort an asynchronous operation as desired.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/signal)
*/
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.
+ * The **`abort()`** method of the AbortController interface aborts an asynchronous operation before it has completed.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)
*/
abort(reason?: any): void;
@@ -942,24 +1122,32 @@
"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.
+ * The **`AbortSignal`** interface represents a signal object that allows you to communicate with an asynchronous operation (such as a fetch request) and abort it if required via an AbortController object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal)
*/
interface AbortSignal extends EventTarget {
/**
- * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+ * The **`aborted`** read-only property returns a value that indicates whether the asynchronous operations the signal is communicating with are aborted (`true`) or not (`false`).
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted)
*/
readonly aborted: boolean;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_event) */
onabort: ((this: AbortSignal, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason) */
+ /**
+ * The **`reason`** read-only property returns a JavaScript value that indicates the abort reason.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason)
+ */
readonly reason: any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted) */
+ /**
+ * The **`throwIfAborted()`** method throws the signal's abort AbortSignal.reason if the signal has been aborted; otherwise it does nothing.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted)
+ */
throwIfAborted(): void;
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;
@@ -968,11 +1156,25 @@
declare var AbortSignal: {
prototype: AbortSignal;
new(): AbortSignal;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static) */
+ /**
+ * The **`AbortSignal.abort()`** static method returns an AbortSignal that is already set as aborted (and which does not trigger an AbortSignal/abort_event event).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static)
+ */
abort(reason?: any): AbortSignal;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static) */
+ /**
+ * The **`AbortSignal.any()`** static method takes an iterable of abort signals and returns an AbortSignal.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/any_static)
+ */
+ any(signals: AbortSignal[]): AbortSignal;
+ /**
+ * The **`AbortSignal.timeout()`** static method returns an AbortSignal that will automatically abort after a specified time.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static)
+ */
timeout(milliseconds: number): AbortSignal;
};
interface AbstractWorkerEventMap {
@@ -995,24 +1197,271 @@
requestAnimationFrame(callback: FrameRequestCallback): number;
}
/**
- * 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.
+ * The **`AudioData`** interface of the WebCodecs API represents an audio sample.
*
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData)
+ */
+interface AudioData {
+ /**
+ * The **`duration`** read-only property of the AudioData interface returns the duration in microseconds of this `AudioData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/duration)
+ */
+ readonly duration: number;
+ /**
+ * The **`format`** read-only property of the AudioData interface returns the sample format of the `AudioData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/format)
+ */
+ readonly format: AudioSampleFormat | null;
+ /**
+ * The **`numberOfChannels`** read-only property of the AudioData interface returns the number of channels in the `AudioData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfChannels)
+ */
+ readonly numberOfChannels: number;
+ /**
+ * The **`numberOfFrames`** read-only property of the AudioData interface returns the number of frames in the `AudioData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfFrames)
+ */
+ readonly numberOfFrames: number;
+ /**
+ * The **`sampleRate`** read-only property of the AudioData interface returns the sample rate in Hz.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/sampleRate)
+ */
+ readonly sampleRate: number;
+ /**
+ * The **`timestamp`** read-only property of the AudioData interface returns the timestamp of this `AudioData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/timestamp)
+ */
+ readonly timestamp: number;
+ /**
+ * The **`allocationSize()`** method of the AudioData interface returns the size in bytes required to hold the current sample as filtered by options passed into the method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/allocationSize)
+ */
+ allocationSize(options: AudioDataCopyToOptions): number;
+ /**
+ * The **`clone()`** method of the AudioData interface creates a new `AudioData` object with reference to the same media resource as the original.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/clone)
+ */
+ clone(): AudioData;
+ /**
+ * The **`close()`** method of the AudioData interface clears all states and releases the reference to the media resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/close)
+ */
+ close(): void;
+ /**
+ * The **`copyTo()`** method of the AudioData interface copies a plane of an `AudioData` object to a destination buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/copyTo)
+ */
+ copyTo(destination: AllowSharedBufferSource, options: AudioDataCopyToOptions): void;
+}
+
+declare var AudioData: {
+ prototype: AudioData;
+ new(init: AudioDataInit): AudioData;
+};
+
+interface AudioDecoderEventMap {
+ "dequeue": Event;
+}
+
+/**
+ * The **`AudioDecoder`** interface of the WebCodecs API decodes chunks of audio.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder)
+ */
+interface AudioDecoder extends EventTarget {
+ /**
+ * The **`decodeQueueSize`** read-only property of the AudioDecoder interface returns the number of pending decode requests in the queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decodeQueueSize)
+ */
+ readonly decodeQueueSize: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/dequeue_event) */
+ ondequeue: ((this: AudioDecoder, ev: Event) => any) | null;
+ /**
+ * The **`state`** read-only property of the AudioDecoder interface returns the current state of the underlying codec.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/state)
+ */
+ readonly state: CodecState;
+ /**
+ * The **`close()`** method of the AudioDecoder interface ends all pending work and releases system resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/close)
+ */
+ close(): void;
+ /**
+ * The **`configure()`** method of the AudioDecoder interface enqueues a control message to configure the audio decoder for decoding chunks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/configure)
+ */
+ configure(config: AudioDecoderConfig): void;
+ /**
+ * The **`decode()`** method of the AudioDecoder interface enqueues a control message to decode a given chunk of audio.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decode)
+ */
+ decode(chunk: EncodedAudioChunk): void;
+ /**
+ * The **`flush()`** method of the AudioDecoder interface returns a Promise that resolves once all pending messages in the queue have been completed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/flush)
+ */
+ flush(): Promise<void>;
+ /**
+ * The **`reset()`** method of the AudioDecoder interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/reset)
+ */
+ reset(): void;
+ addEventListener<K extends keyof AudioDecoderEventMap>(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+ addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+ removeEventListener<K extends keyof AudioDecoderEventMap>(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare var AudioDecoder: {
+ prototype: AudioDecoder;
+ new(init: AudioDecoderInit): AudioDecoder;
+ /**
+ * The **`isConfigSupported()`** static method of the AudioDecoder interface checks if the given config is supported (that is, if AudioDecoder objects can be successfully configured with the given config).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/isConfigSupported_static)
+ */
+ isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>;
+};
+
+interface AudioEncoderEventMap {
+ "dequeue": Event;
+}
+
+/**
+ * The **`AudioEncoder`** interface of the WebCodecs API encodes AudioData objects.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder)
+ */
+interface AudioEncoder extends EventTarget {
+ /**
+ * The **`encodeQueueSize`** read-only property of the AudioEncoder interface returns the number of pending encode requests in the queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encodeQueueSize)
+ */
+ readonly encodeQueueSize: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/dequeue_event) */
+ ondequeue: ((this: AudioEncoder, ev: Event) => any) | null;
+ /**
+ * The **`state`** read-only property of the AudioEncoder interface returns the current state of the underlying codec.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/state)
+ */
+ readonly state: CodecState;
+ /**
+ * The **`close()`** method of the AudioEncoder interface ends all pending work and releases system resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/close)
+ */
+ close(): void;
+ /**
+ * The **`configure()`** method of the AudioEncoder interface enqueues a control message to configure the audio encoder for encoding chunks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/configure)
+ */
+ configure(config: AudioEncoderConfig): void;
+ /**
+ * The **`encode()`** method of the AudioEncoder interface enqueues a control message to encode a given AudioData object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encode)
+ */
+ encode(data: AudioData): void;
+ /**
+ * The **`flush()`** method of the AudioEncoder interface returns a Promise that resolves once all pending messages in the queue have been completed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/flush)
+ */
+ flush(): Promise<void>;
+ /**
+ * The **`reset()`** method of the AudioEncoder interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/reset)
+ */
+ reset(): void;
+ addEventListener<K extends keyof AudioEncoderEventMap>(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+ addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+ removeEventListener<K extends keyof AudioEncoderEventMap>(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare var AudioEncoder: {
+ prototype: AudioEncoder;
+ new(init: AudioEncoderInit): AudioEncoder;
+ /**
+ * The **`isConfigSupported()`** static method of the AudioEncoder interface checks if the given config is supported (that is, if AudioEncoder objects can be successfully configured with the given config).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/isConfigSupported_static)
+ */
+ isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
+};
+
+/**
+ * The **`Blob`** interface represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a ReadableStream so its methods can be used for processing the data.
+ *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob)
*/
interface Blob {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+ /**
+ * The **`size`** read-only property of the Blob interface returns the size of the Blob or File in bytes.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size)
+ */
readonly size: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+ /**
+ * The **`type`** read-only property of the Blob interface returns the MIME type of the file.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type)
+ */
readonly type: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/arrayBuffer) */
+ /**
+ * The **`arrayBuffer()`** method of the Blob interface returns a Promise that resolves with the contents of the blob as binary data contained in an ArrayBuffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/arrayBuffer)
+ */
arrayBuffer(): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+ /**
+ * The **`bytes()`** method of the Blob interface returns a Promise that resolves with a Uint8Array containing the contents of the blob as an array of bytes.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/bytes)
+ */
+ bytes(): Promise<Uint8Array<ArrayBuffer>>;
+ /**
+ * The **`slice()`** method of the Blob interface creates and returns a new `Blob` object which contains data from a subset of the blob on which it's called.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice)
+ */
slice(start?: number, end?: number, contentType?: string): Blob;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/stream) */
- stream(): ReadableStream<Uint8Array>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+ /**
+ * The **`stream()`** method of the Blob interface returns a ReadableStream which upon reading returns the data contained within the `Blob`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/stream)
+ */
+ stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
+ /**
+ * The **`text()`** method of the string containing the contents of the blob, interpreted as UTF-8.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text)
+ */
text(): Promise<string>;
}
declare var Blob: {
@@ -1021,15 +1470,17 @@
};
interface Body {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/body) */
- readonly body: ReadableStream<Uint8Array> | null;
+ readonly body: ReadableStream<Uint8Array<ArrayBuffer>> | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */
readonly bodyUsed: boolean;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/arrayBuffer) */
arrayBuffer(): Promise<ArrayBuffer>;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/blob) */
blob(): Promise<Blob>;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes) */
+ bytes(): Promise<Uint8Array<ArrayBuffer>>;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/formData) */
formData(): Promise<FormData>;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
json(): Promise<any>;
@@ -1041,12 +1492,16 @@
"message": MessageEvent;
"messageerror": MessageEvent;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel) */
+/**
+ * The **`BroadcastChannel`** interface represents a named channel that any browsing context of a given origin can subscribe to.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel)
+ */
interface BroadcastChannel extends EventTarget {
/**
- * Returns the channel name (as passed to the constructor).
+ * The **`name`** read-only property of the BroadcastChannel interface returns a string, which uniquely identifies the given channel with its name.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel/name)
*/
readonly name: string;
@@ -1054,15 +1509,15 @@
onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel/messageerror_event) */
onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
/**
- * Closes the BroadcastChannel object, opening it up to garbage collection.
+ * The **`close()`** method of the BroadcastChannel interface terminates the connection to the underlying channel, allowing the object to be garbage collected.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel/close)
*/
close(): void;
/**
- * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
+ * The **`postMessage()`** method of the BroadcastChannel interface sends a message, which can be of any kind of Object, to each listener in any browsing context with the same origin.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/BroadcastChannel/postMessage)
*/
postMessage(message: any): void;
@@ -1077,14 +1532,18 @@
new(name: string): BroadcastChannel;
};
/**
- * This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.
+ * The **`ByteLengthQueuingStrategy`** interface of the Streams API provides a built-in byte length queuing strategy that can be used when constructing streams.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy)
*/
interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/highWaterMark) */
+ /**
+ * The read-only **`ByteLengthQueuingStrategy.highWaterMark`** property returns the total number of bytes that can be contained in the internal queue before backpressure is applied.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/highWaterMark)
+ */
readonly highWaterMark: number;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/size) */
readonly size: QueuingStrategySize<ArrayBufferView>;
}
@@ -1093,20 +1552,32 @@
prototype: ByteLengthQueuingStrategy;
new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImageValue) */
+/**
+ * The **`CSSImageValue`** interface of the CSS Typed Object Model API represents values for properties that take an image, for example background-image, list-style-image, or border-image-source.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImageValue)
+ */
interface CSSImageValue extends CSSStyleValue {
}
declare var CSSImageValue: {
prototype: CSSImageValue;
new(): CSSImageValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeywordValue) */
+/**
+ * The **`CSSKeywordValue`** interface of the CSS Typed Object Model API creates an object to represent CSS keywords and other identifiers.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeywordValue)
+ */
interface CSSKeywordValue extends CSSStyleValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeywordValue/value) */
+ /**
+ * The **`value`** property of the `CSSKeywordValue`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeywordValue/value)
+ */
value: string;
}
declare var CSSKeywordValue: {
@@ -1124,99 +1595,171 @@
prototype: CSSMathClamp;
new(lower: CSSNumberish, value: CSSNumberish, upper: CSSNumberish): CSSMathClamp;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathInvert) */
+/**
+ * The **`CSSMathInvert`** interface of the CSS Typed Object Model API represents a CSS calc used as `calc(1 / <value>)`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathInvert)
+ */
interface CSSMathInvert extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathInvert/value) */
+ /**
+ * The CSSMathInvert.value read-only property of the A CSSNumericValue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathInvert/value)
+ */
readonly value: CSSNumericValue;
}
declare var CSSMathInvert: {
prototype: CSSMathInvert;
new(arg: CSSNumberish): CSSMathInvert;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMax) */
+/**
+ * The **`CSSMathMax`** interface of the CSS Typed Object Model API represents the CSS max function.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMax)
+ */
interface CSSMathMax extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMax/values) */
+ /**
+ * The CSSMathMax.values read-only property of the which contains one or more CSSNumericValue objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMax/values)
+ */
readonly values: CSSNumericArray;
}
declare var CSSMathMax: {
prototype: CSSMathMax;
new(...args: CSSNumberish[]): CSSMathMax;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMin) */
+/**
+ * The **`CSSMathMin`** interface of the CSS Typed Object Model API represents the CSS min function.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMin)
+ */
interface CSSMathMin extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMin/values) */
+ /**
+ * The CSSMathMin.values read-only property of the which contains one or more CSSNumericValue objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathMin/values)
+ */
readonly values: CSSNumericArray;
}
declare var CSSMathMin: {
prototype: CSSMathMin;
new(...args: CSSNumberish[]): CSSMathMin;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathNegate) */
+/**
+ * The **`CSSMathNegate`** interface of the CSS Typed Object Model API negates the value passed into it.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathNegate)
+ */
interface CSSMathNegate extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathNegate/value) */
+ /**
+ * The CSSMathNegate.value read-only property of the A CSSNumericValue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathNegate/value)
+ */
readonly value: CSSNumericValue;
}
declare var CSSMathNegate: {
prototype: CSSMathNegate;
new(arg: CSSNumberish): CSSMathNegate;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathProduct) */
+/**
+ * The **`CSSMathProduct`** interface of the CSS Typed Object Model API represents the result obtained by calling CSSNumericValue.add, CSSNumericValue.sub, or CSSNumericValue.toSum on CSSNumericValue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathProduct)
+ */
interface CSSMathProduct extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathProduct/values) */
+ /**
+ * The **`CSSMathProduct.values`** read-only property of the CSSMathProduct interface returns a A CSSNumericArray.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathProduct/values)
+ */
readonly values: CSSNumericArray;
}
declare var CSSMathProduct: {
prototype: CSSMathProduct;
new(...args: CSSNumberish[]): CSSMathProduct;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathSum) */
+/**
+ * The **`CSSMathSum`** interface of the CSS Typed Object Model API represents the result obtained by calling CSSNumericValue.add, CSSNumericValue.sub, or CSSNumericValue.toSum on CSSNumericValue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathSum)
+ */
interface CSSMathSum extends CSSMathValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathSum/values) */
+ /**
+ * The **`CSSMathSum.values`** read-only property of the CSSMathSum interface returns a CSSNumericArray object which contains one or more CSSNumericValue objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathSum/values)
+ */
readonly values: CSSNumericArray;
}
declare var CSSMathSum: {
prototype: CSSMathSum;
new(...args: CSSNumberish[]): CSSMathSum;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathValue) */
+/**
+ * The **`CSSMathValue`** interface of the CSS Typed Object Model API a base class for classes representing complex numeric values.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathValue)
+ */
interface CSSMathValue extends CSSNumericValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathValue/operator) */
+ /**
+ * The **`CSSMathValue.operator`** read-only property of the CSSMathValue interface indicates the operator that the current subtype represents.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMathValue/operator)
+ */
readonly operator: CSSMathOperator;
}
declare var CSSMathValue: {
prototype: CSSMathValue;
new(): CSSMathValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMatrixComponent) */
+/**
+ * The **`CSSMatrixComponent`** interface of the CSS Typed Object Model API represents the matrix() and matrix3d() values of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMatrixComponent)
+ */
interface CSSMatrixComponent extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMatrixComponent/matrix) */
+ /**
+ * The **`matrix`** property of the See the matrix() and matrix3d() pages for examples.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSMatrixComponent/matrix)
+ */
matrix: DOMMatrix;
}
declare var CSSMatrixComponent: {
prototype: CSSMatrixComponent;
new(matrix: DOMMatrixReadOnly, options?: CSSMatrixComponentOptions): CSSMatrixComponent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericArray) */
+/**
+ * The **`CSSNumericArray`** interface of the CSS Typed Object Model API contains a list of CSSNumericValue objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericArray)
+ */
interface CSSNumericArray {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericArray/length) */
+ /**
+ * The read-only **`length`** property of the An integer representing the number of CSSNumericValue objects in the list.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericArray/length)
+ */
readonly length: number;
forEach(callbackfn: (value: CSSNumericValue, key: number, parent: CSSNumericArray) => void, thisArg?: any): void;
[index: number]: CSSNumericValue;
}
@@ -1225,57 +1768,129 @@
prototype: CSSNumericArray;
new(): CSSNumericArray;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue) */
+/**
+ * The **`CSSNumericValue`** interface of the CSS Typed Object Model API represents operations that all numeric values can perform.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue)
+ */
interface CSSNumericValue extends CSSStyleValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/add) */
+ /**
+ * The **`add()`** method of the `CSSNumericValue`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/add)
+ */
add(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/div) */
+ /**
+ * The **`div()`** method of the supplied value.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/div)
+ */
div(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/equals) */
+ /**
+ * The **`equals()`** method of the value are strictly equal.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/equals)
+ */
equals(...value: CSSNumberish[]): boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/max) */
+ /**
+ * The **`max()`** method of the passed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/max)
+ */
max(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/min) */
+ /**
+ * The **`min()`** method of the values passed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/min)
+ */
min(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/mul) */
+ /**
+ * The **`mul()`** method of the the supplied value.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/mul)
+ */
mul(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/sub) */
+ /**
+ * The **`sub()`** method of the `CSSNumericValue`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/sub)
+ */
sub(...values: CSSNumberish[]): CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/to) */
+ /**
+ * The **`to()`** method of the another.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/to)
+ */
to(unit: string): CSSUnitValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/toSum) */
+ /**
+ * The **`toSum()`** method of the ```js-nolint toSum(units) ``` - `units` - : The units to convert to.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/toSum)
+ */
toSum(...units: string[]): CSSMathSum;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/type) */
+ /**
+ * The **`type()`** method of the `CSSNumericValue`, one of `angle`, `flex`, `frequency`, `length`, `resolution`, `percent`, `percentHint`, or `time`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSNumericValue/type)
+ */
type(): CSSNumericType;
}
declare var CSSNumericValue: {
prototype: CSSNumericValue;
new(): CSSNumericValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPerspective) */
+/**
+ * The **`CSSPerspective`** interface of the CSS Typed Object Model API represents the perspective() value of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPerspective)
+ */
interface CSSPerspective extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPerspective/length) */
+ /**
+ * The **`length`** property of the It is used to apply a perspective transform to the element and its content.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPerspective/length)
+ */
length: CSSPerspectiveValue;
}
declare var CSSPerspective: {
prototype: CSSPerspective;
new(length: CSSPerspectiveValue): CSSPerspective;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate) */
+/**
+ * The **`CSSRotate`** interface of the CSS Typed Object Model API represents the rotate value of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate)
+ */
interface CSSRotate extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/angle) */
+ /**
+ * The **`angle`** property of the denotes a clockwise rotation, a negative angle a counter-clockwise one.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/angle)
+ */
angle: CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/x) */
+ /**
+ * The **`x`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/x)
+ */
x: CSSNumberish;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/y) */
+ /**
+ * The **`y`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/y)
+ */
y: CSSNumberish;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/z) */
+ /**
+ * The **`z`** property of the vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSRotate/z)
+ */
z: CSSNumberish;
}
declare var CSSRotate: {
@@ -1283,59 +1898,107 @@
new(angle: CSSNumericValue): CSSRotate;
new(x: CSSNumberish, y: CSSNumberish, z: CSSNumberish, angle: CSSNumericValue): CSSRotate;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale) */
+/**
+ * The **`CSSScale`** interface of the CSS Typed Object Model API represents the scale() and scale3d() values of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale)
+ */
interface CSSScale extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/x) */
+ /**
+ * The **`x`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/x)
+ */
x: CSSNumberish;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/y) */
+ /**
+ * The **`y`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/y)
+ */
y: CSSNumberish;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/z) */
+ /**
+ * The **`z`** property of the vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSScale/z)
+ */
z: CSSNumberish;
}
declare var CSSScale: {
prototype: CSSScale;
new(x: CSSNumberish, y: CSSNumberish, z?: CSSNumberish): CSSScale;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew) */
+/**
+ * The **`CSSSkew`** interface of the CSS Typed Object Model API is part of the CSSTransformValue interface.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew)
+ */
interface CSSSkew extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew/ax) */
+ /**
+ * The **`ax`** property of the along the x-axis (or abscissa).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew/ax)
+ */
ax: CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew/ay) */
+ /**
+ * The **`ay`** property of the along the y-axis (or ordinate).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkew/ay)
+ */
ay: CSSNumericValue;
}
declare var CSSSkew: {
prototype: CSSSkew;
new(ax: CSSNumericValue, ay: CSSNumericValue): CSSSkew;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewX) */
+/**
+ * The **`CSSSkewX`** interface of the CSS Typed Object Model API represents the `skewX()` value of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewX)
+ */
interface CSSSkewX extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewX/ax) */
+ /**
+ * The **`ax`** property of the along the x-axis (or abscissa).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewX/ax)
+ */
ax: CSSNumericValue;
}
declare var CSSSkewX: {
prototype: CSSSkewX;
new(ax: CSSNumericValue): CSSSkewX;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewY) */
+/**
+ * The **`CSSSkewY`** interface of the CSS Typed Object Model API represents the `skewY()` value of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewY)
+ */
interface CSSSkewY extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewY/ay) */
+ /**
+ * The **`ay`** property of the along the y-axis (or ordinate).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSSkewY/ay)
+ */
ay: CSSNumericValue;
}
declare var CSSSkewY: {
prototype: CSSSkewY;
new(ay: CSSNumericValue): CSSSkewY;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSStyleValue) */
+/**
+ * The **`CSSStyleValue`** interface of the CSS Typed Object Model API is the base class of all CSS values accessible through the Typed OM API.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSStyleValue)
+ */
interface CSSStyleValue {
toString(): string;
}
@@ -1343,13 +2006,25 @@
prototype: CSSStyleValue;
new(): CSSStyleValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent) */
+/**
+ * The **`CSSTransformComponent`** interface of the CSS Typed Object Model API is part of the CSSTransformValue interface.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent)
+ */
interface CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent/is2D) */
+ /**
+ * The **`is2D`** read-only property of the CSSTransformComponent interface indicates where the transform is 2D or 3D.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent/is2D)
+ */
is2D: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent/toMatrix) */
+ /**
+ * The **`toMatrix()`** method of the object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformComponent/toMatrix)
+ */
toMatrix(): DOMMatrix;
toString(): string;
}
@@ -1357,15 +2032,31 @@
prototype: CSSTransformComponent;
new(): CSSTransformComponent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue) */
+/**
+ * The **`CSSTransformValue`** interface of the CSS Typed Object Model API represents `transform-list` values as used by the CSS transform property.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue)
+ */
interface CSSTransformValue extends CSSStyleValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/is2D) */
+ /**
+ * The read-only **`is2D`** property of the In the case of the `CSSTransformValue` this property returns true unless any of the individual functions return false for `Is2D`, in which case it returns false.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/is2D)
+ */
readonly is2D: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/length) */
+ /**
+ * The read-only **`length`** property of the the list.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/length)
+ */
readonly length: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/toMatrix) */
+ /**
+ * The **`toMatrix()`** method of the ```js-nolint toMatrix() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTransformValue/toMatrix)
+ */
toMatrix(): DOMMatrix;
forEach(callbackfn: (value: CSSTransformComponent, key: number, parent: CSSTransformValue) => void, thisArg?: any): void;
[index: number]: CSSTransformComponent;
}
@@ -1374,39 +2065,75 @@
prototype: CSSTransformValue;
new(transforms: CSSTransformComponent[]): CSSTransformValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate) */
+/**
+ * The **`CSSTranslate`** interface of the CSS Typed Object Model API represents the translate() value of the individual transform property in CSS.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate)
+ */
interface CSSTranslate extends CSSTransformComponent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/x) */
+ /**
+ * The **`x`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/x)
+ */
x: CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/y) */
+ /**
+ * The **`y`** property of the translating vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/y)
+ */
y: CSSNumericValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/z) */
+ /**
+ * The **`z`** property of the vector.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSTranslate/z)
+ */
z: CSSNumericValue;
}
declare var CSSTranslate: {
prototype: CSSTranslate;
new(x: CSSNumericValue, y: CSSNumericValue, z?: CSSNumericValue): CSSTranslate;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue) */
+/**
+ * The **`CSSUnitValue`** interface of the CSS Typed Object Model API represents values that contain a single unit type.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue)
+ */
interface CSSUnitValue extends CSSNumericValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue/unit) */
+ /**
+ * The **`CSSUnitValue.unit`** read-only property of the CSSUnitValue interface returns a string indicating the type of unit.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue/unit)
+ */
readonly unit: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue/value) */
+ /**
+ * The **`CSSUnitValue.value`** property of the A double.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnitValue/value)
+ */
value: number;
}
declare var CSSUnitValue: {
prototype: CSSUnitValue;
new(value: number, unit: string): CSSUnitValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnparsedValue) */
+/**
+ * The **`CSSUnparsedValue`** interface of the CSS Typed Object Model API represents property values that reference custom properties.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnparsedValue)
+ */
interface CSSUnparsedValue extends CSSStyleValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnparsedValue/length) */
+ /**
+ * The **`length`** read-only property of the An integer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSUnparsedValue/length)
+ */
readonly length: number;
forEach(callbackfn: (value: CSSUnparsedSegment, key: number, parent: CSSUnparsedValue) => void, thisArg?: any): void;
[index: number]: CSSUnparsedSegment;
}
@@ -1415,13 +2142,25 @@
prototype: CSSUnparsedValue;
new(members: CSSUnparsedSegment[]): CSSUnparsedValue;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue) */
+/**
+ * The **`CSSVariableReferenceValue`** interface of the CSS Typed Object Model API allows you to create a custom name for a built-in CSS value.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue)
+ */
interface CSSVariableReferenceValue {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue/fallback) */
+ /**
+ * The **`fallback`** read-only property of the A CSSUnparsedValue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue/fallback)
+ */
readonly fallback: CSSUnparsedValue | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue/variable) */
+ /**
+ * The **`variable`** property of the A string beginning with `--` (that is, a custom property name).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSVariableReferenceValue/variable)
+ */
variable: string;
}
declare var CSSVariableReferenceValue: {
@@ -1429,27 +2168,55 @@
new(variable: string, fallback?: CSSUnparsedValue | null): CSSVariableReferenceValue;
};
/**
- * Provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec.
+ * The **`Cache`** interface provides a persistent storage mechanism for Request / Response object pairs that are cached in long lived memory.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache)
*/
interface Cache {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/add) */
+ /**
+ * The **`add()`** method of the Cache interface takes a URL, retrieves it, and adds the resulting response object to the given cache.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/add)
+ */
add(request: RequestInfo | URL): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/addAll) */
+ /**
+ * The **`addAll()`** method of the Cache interface takes an array of URLs, retrieves them, and adds the resulting response objects to the given cache.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/addAll)
+ */
addAll(requests: RequestInfo[]): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/delete) */
+ /**
+ * The **`delete()`** method of the Cache interface finds the Cache entry whose key is the request, and if found, deletes the Cache entry and returns a Promise that resolves to `true`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/delete)
+ */
delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/keys) */
+ /**
+ * The **`keys()`** method of the Cache interface returns a representing the keys of the Cache.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/keys)
+ */
keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/match) */
+ /**
+ * The **`match()`** method of the Cache interface returns a Promise that resolves to the Response associated with the first matching request in the Cache object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/match)
+ */
match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/matchAll) */
+ /**
+ * The **`matchAll()`** method of the Cache interface returns a Promise that resolves to an array of all matching responses in the Cache object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/matchAll)
+ */
matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/put) */
+ /**
+ * The **`put()`** method of the Often, you will just want to Window/fetch one or more requests, then add the result straight to your cache.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Cache/put)
+ */
put(request: RequestInfo | URL, response: Response): Promise<void>;
}
declare var Cache: {
@@ -1457,23 +2224,43 @@
new(): Cache;
};
/**
- * The storage for Cache objects.
+ * The **`CacheStorage`** interface represents the storage for Cache objects.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage)
*/
interface CacheStorage {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/delete) */
+ /**
+ * The **`delete()`** method of the CacheStorage interface finds the Cache object matching the `cacheName`, and if found, deletes the Cache object and returns a Promise that resolves to `true`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/delete)
+ */
delete(cacheName: string): Promise<boolean>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/has) */
+ /**
+ * The **`has()`** method of the CacheStorage interface returns a Promise that resolves to `true` if a You can access `CacheStorage` through the Window.caches property in windows or through the WorkerGlobalScope.caches property in workers.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/has)
+ */
has(cacheName: string): Promise<boolean>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/keys) */
+ /**
+ * The **`keys()`** method of the CacheStorage interface returns a Promise that will resolve with an array containing strings corresponding to all of the named Cache objects tracked by the CacheStorage object in the order they were created.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/keys)
+ */
keys(): Promise<string[]>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/match) */
+ /**
+ * The **`match()`** method of the CacheStorage interface checks if a given Request or URL string is a key for a stored Response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/match)
+ */
match(request: RequestInfo | URL, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/open) */
+ /**
+ * The **`open()`** method of the the Cache object matching the `cacheName`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/open)
+ */
open(cacheName: string): Promise<Cache>;
}
declare var CacheStorage: {
@@ -1535,18 +2322,16 @@
filter: string;
}
/**
- * An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient().
+ * The **`CanvasGradient`** interface represents an opaque object describing a gradient.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasGradient)
*/
interface CanvasGradient {
/**
- * Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset at one end of the gradient, 1.0 is the offset at the other end.
+ * The **`CanvasGradient.addColorStop()`** method adds a new color stop, defined by an `offset` and a `color`, to a given canvas gradient.
*
- * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasGradient/addColorStop)
*/
addColorStop(offset: number, color: string): void;
}
@@ -1558,14 +2343,14 @@
interface CanvasImageData {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/createImageData) */
createImageData(sw: number, sh: number, settings?: ImageDataSettings): ImageData;
- createImageData(imagedata: ImageData): ImageData;
+ createImageData(imageData: ImageData): ImageData;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/getImageData) */
getImageData(sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings): ImageData;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/putImageData) */
- putImageData(imagedata: ImageData, dx: number, dy: number): void;
- putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
+ putImageData(imageData: ImageData, dx: number, dy: number): void;
+ putImageData(imageData: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
}
interface CanvasImageSmoothing {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/imageSmoothingEnabled) */
@@ -1614,15 +2399,15 @@
setLineDash(segments: number[]): void;
}
/**
- * An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method.
+ * The **`CanvasPattern`** interface represents an opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasPattern)
*/
interface CanvasPattern {
/**
- * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
+ * The **`CanvasPattern.setTransform()`** method uses a DOMMatrix object as the pattern's transformation matrix and invokes it on the pattern.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasPattern/setTransform)
*/
setTransform(transform?: DOMMatrix2DInit): void;
@@ -1653,8 +2438,10 @@
shadowOffsetY: number;
}
interface CanvasState {
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/isContextLost) */
+ isContextLost(): boolean;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/reset) */
reset(): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/restore) */
restore(): void;
@@ -1712,22 +2499,42 @@
translate(x: number, y: number): void;
}
/**
- * The Client interface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can get Client/WindowClient objects from methods such as Clients.matchAll() and Clients.get().
+ * The `Client` interface represents an executable context such as a Worker, or a SharedWorker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client)
*/
interface Client {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/frameType) */
+ /**
+ * The **`frameType`** read-only property of the Client interface indicates the type of browsing context of the current Client.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/frameType)
+ */
readonly frameType: FrameType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/id) */
+ /**
+ * The **`id`** read-only property of the Client interface returns the universally unique identifier of the Client object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/id)
+ */
readonly id: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/type) */
+ /**
+ * The **`type`** read-only property of the Client interface indicates the type of client the service worker is controlling.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/type)
+ */
readonly type: ClientTypes;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/url) */
+ /**
+ * The **`url`** read-only property of the Client interface returns the URL of the current service worker client.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/url)
+ */
readonly url: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/postMessage) */
+ /**
+ * The **`postMessage()`** method of the (a Window, Worker, or SharedWorker).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/postMessage)
+ */
postMessage(message: any, transfer: Transferable[]): void;
postMessage(message: any, options?: StructuredSerializeOptions): void;
}
@@ -1736,20 +2543,36 @@
new(): Client;
};
/**
- * Provides access to Client objects. Access it via self.clients within a service worker.
+ * The `Clients` interface provides access to Client objects.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients)
*/
interface Clients {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/claim) */
+ /**
+ * The **`claim()`** method of the Clients interface allows an active service worker to set itself as the ServiceWorkerContainer.controller for all clients within its ServiceWorkerRegistration.scope.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/claim)
+ */
claim(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/get) */
+ /**
+ * The **`get()`** method of the `id` and returns it in a Promise.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/get)
+ */
get(id: string): Promise<Client | undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/matchAll) */
+ /**
+ * The **`matchAll()`** method of the Clients interface returns a Promise for a list of service worker clients whose origin is the same as the associated service worker's origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/matchAll)
+ */
matchAll<T extends ClientQueryOptions>(options?: T): Promise<ReadonlyArray<T["type"] extends "window" ? WindowClient : Client>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/openWindow) */
+ /**
+ * The **`openWindow()`** method of the Clients interface creates a new top level browsing context and loads a given URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/openWindow)
+ */
openWindow(url: string | URL): Promise<WindowClient | null>;
}
declare var Clients: {
@@ -1757,27 +2580,27 @@
new(): Clients;
};
/**
- * A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute.
+ * A `CloseEvent` is sent to clients using WebSockets when the connection is closed.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent)
*/
interface CloseEvent extends Event {
/**
- * Returns the WebSocket connection close code provided by the server.
+ * The **`code`** read-only property of the CloseEvent interface returns a WebSocket connection close code indicating the reason the connection was closed.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/code)
*/
readonly code: number;
/**
- * Returns the WebSocket connection close reason provided by the server.
+ * The **`reason`** read-only property of the CloseEvent interface returns the WebSocket connection close reason the server gave for closing the connection; that is, a concise human-readable prose explanation for the closure.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/reason)
*/
readonly reason: string;
/**
- * Returns true if the connection closed cleanly; false otherwise.
+ * The **`wasClean`** read-only property of the CloseEvent interface returns `true` if the connection closed cleanly.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/wasClean)
*/
readonly wasClean: boolean;
@@ -1787,24 +2610,108 @@
prototype: CloseEvent;
new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream) */
+/**
+ * The **`CompressionStream`** interface of the Compression Streams API is an API for compressing a stream of data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream)
+ */
interface CompressionStream extends GenericTransformStream {
+ readonly readable: ReadableStream<Uint8Array<ArrayBuffer>>;
+ readonly writable: WritableStream<BufferSource>;
}
declare var CompressionStream: {
prototype: CompressionStream;
new(format: CompressionFormat): CompressionStream;
};
/**
- * This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.
+ * The **`CookieStore`** interface of the Cookie Store API provides methods for getting and setting cookies asynchronously from either a page or a service worker.
+ * Available only in secure contexts.
*
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStore)
+ */
+interface CookieStore extends EventTarget {
+ /**
+ * The **`delete()`** method of the CookieStore interface deletes a cookie that matches the given `name` or `options` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStore/delete)
+ */
+ delete(name: string): Promise<void>;
+ delete(options: CookieStoreDeleteOptions): Promise<void>;
+ /**
+ * The **`get()`** method of the CookieStore interface returns a Promise that resolves to a single cookie matching the given `name` or `options` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStore/get)
+ */
+ get(name: string): Promise<CookieListItem | null>;
+ get(options?: CookieStoreGetOptions): Promise<CookieListItem | null>;
+ /**
+ * The **`getAll()`** method of the CookieStore interface returns a Promise that resolves as an array of cookies that match the `name` or `options` passed to it.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStore/getAll)
+ */
+ getAll(name: string): Promise<CookieList>;
+ getAll(options?: CookieStoreGetOptions): Promise<CookieList>;
+ /**
+ * The **`set()`** method of the CookieStore interface sets a cookie with the given `name` and `value` or `options` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStore/set)
+ */
+ set(name: string, value: string): Promise<void>;
+ set(options: CookieInit): Promise<void>;
+}
+
+declare var CookieStore: {
+ prototype: CookieStore;
+ new(): CookieStore;
+};
+
+/**
+ * The **`CookieStoreManager`** interface of the Cookie Store API allows service workers to subscribe to cookie change events.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStoreManager)
+ */
+interface CookieStoreManager {
+ /**
+ * The **`getSubscriptions()`** method of the CookieStoreManager interface returns a list of all the cookie change subscriptions for this ServiceWorkerRegistration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStoreManager/getSubscriptions)
+ */
+ getSubscriptions(): Promise<CookieStoreGetOptions[]>;
+ /**
+ * The **`subscribe()`** method of the CookieStoreManager interface subscribes a ServiceWorkerRegistration to cookie change events.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStoreManager/subscribe)
+ */
+ subscribe(subscriptions: CookieStoreGetOptions[]): Promise<void>;
+ /**
+ * The **`unsubscribe()`** method of the CookieStoreManager interface stops the ServiceWorkerRegistration from receiving previously subscribed events.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CookieStoreManager/unsubscribe)
+ */
+ unsubscribe(subscriptions: CookieStoreGetOptions[]): Promise<void>;
+}
+
+declare var CookieStoreManager: {
+ prototype: CookieStoreManager;
+ new(): CookieStoreManager;
+};
+
+/**
+ * The **`CountQueuingStrategy`** interface of the Streams API provides a built-in chunk counting queuing strategy that can be used when constructing streams.
+ *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy)
*/
interface CountQueuingStrategy extends QueuingStrategy {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/highWaterMark) */
+ /**
+ * The read-only **`CountQueuingStrategy.highWaterMark`** property returns the total number of chunks that can be contained in the internal queue before backpressure is applied.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/highWaterMark)
+ */
readonly highWaterMark: number;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/size) */
readonly size: QueuingStrategySize;
}
@@ -1814,22 +2721,28 @@
new(init: QueuingStrategyInit): CountQueuingStrategy;
};
/**
- * Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.
+ * The **`Crypto`** interface represents basic cryptography features available in the current context.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto)
*/
interface Crypto {
/**
+ * The **`Crypto.subtle`** read-only property returns a cryptographic operations.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/subtle)
*/
readonly subtle: SubtleCrypto;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
- getRandomValues<T extends ArrayBufferView | null>(array: T): T;
/**
+ * The **`Crypto.getRandomValues()`** method lets you get cryptographically strong random values.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues)
+ */
+ getRandomValues<T extends ArrayBufferView>(array: T): T;
+ /**
+ * The **`randomUUID()`** method of the Crypto interface is used to generate a v4 UUID using a cryptographically secure random number generator.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
*/
@@ -1841,38 +2754,59 @@
new(): Crypto;
};
/**
- * The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.
+ * The **`CryptoKey`** interface of the Web Crypto API represents a cryptographic key obtained from one of the SubtleCrypto methods SubtleCrypto.generateKey, SubtleCrypto.deriveKey, SubtleCrypto.importKey, or SubtleCrypto.unwrapKey.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey)
*/
interface CryptoKey {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm) */
+ /**
+ * The read-only **`algorithm`** property of the CryptoKey interface returns an object describing the algorithm for which this key can be used, and any associated extra parameters.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm)
+ */
readonly algorithm: KeyAlgorithm;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable) */
+ /**
+ * The read-only **`extractable`** property of the CryptoKey interface indicates whether or not the key may be extracted using `SubtleCrypto.exportKey()` or `SubtleCrypto.wrapKey()`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable)
+ */
readonly extractable: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/type) */
+ /**
+ * The read-only **`type`** property of the CryptoKey interface indicates which kind of key is represented by the object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/type)
+ */
readonly type: KeyType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages) */
+ /**
+ * The read-only **`usages`** property of the CryptoKey interface indicates what can be done with the key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages)
+ */
readonly usages: KeyUsage[];
}
declare var CryptoKey: {
prototype: CryptoKey;
new(): CryptoKey;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent) */
+/**
+ * The **`CustomEvent`** interface represents events initialized by an application for any purpose.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent)
+ */
interface CustomEvent<T = any> extends Event {
/**
- * Returns any custom data event was created with. Typically used for synthetic events.
+ * The read-only **`detail`** property of the CustomEvent interface returns any data passed when initializing the event.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
*/
readonly detail: T;
/**
+ * The **`CustomEvent.initCustomEvent()`** method initializes a CustomEvent object.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/initCustomEvent)
*/
@@ -1884,22 +2818,31 @@
new<T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
};
/**
- * An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API.
+ * The **`DOMException`** interface represents an abnormal event (called an **exception**) that occurs as a result of calling a method or accessing a property of a web API.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException)
*/
interface DOMException extends Error {
/**
+ * The **`code`** read-only property of the DOMException interface returns one of the legacy error code constants, or `0` if none match.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/code)
*/
readonly code: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/message) */
+ /**
+ * The **`message`** read-only property of the a message or description associated with the given error name.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/message)
+ */
readonly message: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/name) */
+ /**
+ * The **`name`** read-only property of the one of the strings associated with an error name.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/name)
+ */
readonly name: string;
readonly INDEX_SIZE_ERR: 1;
readonly DOMSTRING_SIZE_ERR: 2;
readonly HIERARCHY_REQUEST_ERR: 3;
@@ -1956,206 +2899,443 @@
readonly INVALID_NODE_TYPE_ERR: 24;
readonly DATA_CLONE_ERR: 25;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix) */
+/**
+ * The **`DOMMatrix`** interface represents 4×4 matrices, suitable for 2D and 3D operations including rotation and translation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+ */
interface DOMMatrix extends DOMMatrixReadOnly {
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
a: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
b: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
c: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
d: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
e: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
f: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m11: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m12: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m13: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m14: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m21: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m22: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m23: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m24: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m31: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m32: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m33: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m34: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m41: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m42: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m43: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */
m44: number;
+ /**
+ * The **`invertSelf()`** method of the DOMMatrix interface inverts the original matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/invertSelf)
+ */
invertSelf(): DOMMatrix;
+ /**
+ * The **`multiplySelf()`** method of the DOMMatrix interface multiplies a matrix by the `otherMatrix` parameter, computing the dot product of the original matrix and the specified matrix: `A⋅B`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/multiplySelf)
+ */
multiplySelf(other?: DOMMatrixInit): DOMMatrix;
+ /**
+ * The **`preMultiplySelf()`** method of the DOMMatrix interface modifies the matrix by pre-multiplying it with the specified `DOMMatrix`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/preMultiplySelf)
+ */
preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
+ /**
+ * The `rotateAxisAngleSelf()` method of the DOMMatrix interface is a transformation method that rotates the source matrix by the given vector and angle, returning the altered matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/rotateAxisAngleSelf)
+ */
rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
+ /**
+ * The `rotateFromVectorSelf()` method of the DOMMatrix interface is a mutable transformation method that modifies a matrix by rotating the matrix by the angle between the specified vector and `(1, 0)`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/rotateFromVectorSelf)
+ */
rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
+ /**
+ * The `rotateSelf()` method of the DOMMatrix interface is a mutable transformation method that modifies a matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/rotateSelf)
+ */
rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/scale3dSelf) */
+ /**
+ * The **`scale3dSelf()`** method of the DOMMatrix interface is a mutable transformation method that modifies a matrix by applying a specified scaling factor to all three axes, centered on the given origin, with a default origin of `(0, 0, 0)`, returning the 3D-scaled matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/scale3dSelf)
+ */
scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/scaleSelf) */
+ /**
+ * The **`scaleSelf()`** method of the DOMMatrix interface is a mutable transformation method that modifies a matrix by applying a specified scaling factor, centered on the given origin, with a default origin of `(0, 0)`, returning the scaled matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/scaleSelf)
+ */
scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
+ /**
+ * The `skewXSelf()` method of the DOMMatrix interface is a mutable transformation method that modifies a matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/skewXSelf)
+ */
skewXSelf(sx?: number): DOMMatrix;
+ /**
+ * The `skewYSelf()` method of the DOMMatrix interface is a mutable transformation method that modifies a matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/skewYSelf)
+ */
skewYSelf(sy?: number): DOMMatrix;
+ /**
+ * The `translateSelf()` method of the DOMMatrix interface is a mutable transformation method that modifies a matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix/translateSelf)
+ */
translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
}
declare var DOMMatrix: {
prototype: DOMMatrix;
new(init?: string | number[]): DOMMatrix;
- fromFloat32Array(array32: Float32Array): DOMMatrix;
- fromFloat64Array(array64: Float64Array): DOMMatrix;
+ fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrix;
+ fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrix;
fromMatrix(other?: DOMMatrixInit): DOMMatrix;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly) */
+/**
+ * The **`DOMMatrixReadOnly`** interface represents a read-only 4×4 matrix, suitable for 2D and 3D operations.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
+ */
interface DOMMatrixReadOnly {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/a) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly a: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/b) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly b: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/c) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly c: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/d) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly d: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/e) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly e: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/f) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly f: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/is2D) */
+ /**
+ * The readonly **`is2D`** property of the DOMMatrixReadOnly interface is a Boolean flag that is `true` when the matrix is 2D.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/is2D)
+ */
readonly is2D: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/isIdentity) */
+ /**
+ * The readonly **`isIdentity`** property of the DOMMatrixReadOnly interface is a Boolean whose value is `true` if the matrix is the identity matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/isIdentity)
+ */
readonly isIdentity: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m11) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m11: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m12) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m12: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m13) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m13: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m14) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m14: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m21) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m21: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m22) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m22: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m23) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m23: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m24) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m24: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m31) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m31: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m32) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m32: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m33) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m33: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m34) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m34: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m41) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m41: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m42) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m42: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m43) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m43: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/m44) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */
readonly m44: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipX) */
+ /**
+ * The **`flipX()`** method of the DOMMatrixReadOnly interface creates a new matrix being the result of the original matrix flipped about the x-axis.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipX)
+ */
flipX(): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipY) */
+ /**
+ * The **`flipY()`** method of the DOMMatrixReadOnly interface creates a new matrix being the result of the original matrix flipped about the y-axis.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipY)
+ */
flipY(): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/inverse) */
+ /**
+ * The **`inverse()`** method of the DOMMatrixReadOnly interface creates a new matrix which is the inverse of the original matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/inverse)
+ */
inverse(): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/multiply) */
+ /**
+ * The **`multiply()`** method of the DOMMatrixReadOnly interface creates and returns a new matrix which is the dot product of the matrix and the `otherMatrix` parameter.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/multiply)
+ */
multiply(other?: DOMMatrixInit): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotate) */
+ /**
+ * The `rotate()` method of the DOMMatrixReadOnly interface returns a new DOMMatrix created by rotating the source matrix around each of its axes by the specified number of degrees.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotate)
+ */
rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle) */
+ /**
+ * The `rotateAxisAngle()` method of the DOMMatrixReadOnly interface returns a new DOMMatrix created by rotating the source matrix by the given vector and angle.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle)
+ */
rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotateFromVector) */
+ /**
+ * The `rotateFromVector()` method of the DOMMatrixReadOnly interface is returns a new DOMMatrix created by rotating the source matrix by the angle between the specified vector and `(1, 0)`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/rotateFromVector)
+ */
rotateFromVector(x?: number, y?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scale) */
+ /**
+ * The **`scale()`** method of the original matrix with a scale transform applied.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scale)
+ */
scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scale3d) */
- scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
/**
- * @deprecated
+ * The **`scale3d()`** method of the DOMMatrixReadOnly interface creates a new matrix which is the result of a 3D scale transform being applied to the matrix.
*
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scaleNonUniform)
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scale3d)
*/
+ scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
+ /** @deprecated */
scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/skewX) */
+ /**
+ * The `skewX()` method of the DOMMatrixReadOnly interface returns a new DOMMatrix created by applying the specified skew transformation to the source matrix along its x-axis.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/skewX)
+ */
skewX(sx?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/skewY) */
+ /**
+ * The `skewY()` method of the DOMMatrixReadOnly interface returns a new DOMMatrix created by applying the specified skew transformation to the source matrix along its y-axis.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/skewY)
+ */
skewY(sy?: number): DOMMatrix;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/toFloat32Array) */
- toFloat32Array(): Float32Array;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/toFloat64Array) */
- toFloat64Array(): Float64Array;
+ /**
+ * The **`toFloat32Array()`** method of the DOMMatrixReadOnly interface returns a new Float32Array containing all 16 elements (`m11`, `m12`, `m13`, `m14`, `m21`, `m22`, `m23`, `m24`, `m31`, `m32`, `m33`, `m34`, `m41`, `m42`, `m43`, `m44`) which comprise the matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/toFloat32Array)
+ */
+ toFloat32Array(): Float32Array<ArrayBuffer>;
+ /**
+ * The **`toFloat64Array()`** method of the DOMMatrixReadOnly interface returns a new Float64Array containing all 16 elements (`m11`, `m12`, `m13`, `m14`, `m21`, `m22`, `m23`, `m24`, `m31`, `m32`, `m33`, `m34`, `m41`, `m42`, `m43`, `m44`) which comprise the matrix.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/toFloat64Array)
+ */
+ toFloat64Array(): Float64Array<ArrayBuffer>;
+ /**
+ * The **`toJSON()`** method of the DOMMatrixReadOnly interface creates and returns a JSON object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/toJSON)
+ */
toJSON(): any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/transformPoint) */
+ /**
+ * The **`transformPoint`** method of the You can also create a new `DOMPoint` by applying a matrix to a point with the DOMPointReadOnly.matrixTransform() method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/transformPoint)
+ */
transformPoint(point?: DOMPointInit): DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/translate) */
+ /**
+ * The `translate()` method of the DOMMatrixReadOnly interface creates a new matrix being the result of the original matrix with a translation applied.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/translate)
+ */
translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
}
declare var DOMMatrixReadOnly: {
prototype: DOMMatrixReadOnly;
new(init?: string | number[]): DOMMatrixReadOnly;
- fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
- fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
+ fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrixReadOnly;
+ fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrixReadOnly;
fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint) */
+/**
+ * A **`DOMPoint`** object represents a 2D or 3D point in a coordinate system; it includes values for the coordinates in up to three dimensions, as well as an optional perspective value.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint)
+ */
interface DOMPoint extends DOMPointReadOnly {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/w) */
+ /**
+ * The **`DOMPoint`** interface's **`w`** property holds the point's perspective value, w, for a point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/w)
+ */
w: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/x) */
+ /**
+ * The **`DOMPoint`** interface's **`x`** property holds the horizontal coordinate, x, for a point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/x)
+ */
x: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/y) */
+ /**
+ * The **`DOMPoint`** interface's **`y`** property holds the vertical coordinate, _y_, for a point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/y)
+ */
y: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/z) */
+ /**
+ * The **`DOMPoint`** interface's **`z`** property specifies the depth coordinate of a point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/z)
+ */
z: number;
}
declare var DOMPoint: {
prototype: DOMPoint;
new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/fromPoint_static) */
+ /**
+ * The **`fromPoint()`** static method of the DOMPoint interface creates and returns a new mutable `DOMPoint` object given a source point.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPoint/fromPoint_static)
+ */
fromPoint(other?: DOMPointInit): DOMPoint;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly) */
+/**
+ * The **`DOMPointReadOnly`** interface specifies the coordinate and perspective fields used by DOMPoint to define a 2D or 3D point in a coordinate system.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly)
+ */
interface DOMPointReadOnly {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/w) */
+ /**
+ * The **`DOMPointReadOnly`** interface's **`w`** property holds the point's perspective value, `w`, for a read-only point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/w)
+ */
readonly w: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/x) */
+ /**
+ * The **`DOMPointReadOnly`** interface's **`x`** property holds the horizontal coordinate, x, for a read-only point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/x)
+ */
readonly x: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/y) */
+ /**
+ * The **`DOMPointReadOnly`** interface's **`y`** property holds the vertical coordinate, y, for a read-only point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/y)
+ */
readonly y: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/z) */
+ /**
+ * The **`DOMPointReadOnly`** interface's **`z`** property holds the depth coordinate, z, for a read-only point in space.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/z)
+ */
readonly z: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/matrixTransform) */
+ /**
+ * The **`matrixTransform()`** method of the DOMPointReadOnly interface applies a matrix transform specified as an object to the DOMPointReadOnly object, creating and returning a new `DOMPointReadOnly` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/matrixTransform)
+ */
matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/toJSON) */
+ /**
+ * The DOMPointReadOnly method `toJSON()` returns an object giving the ```js-nolint toJSON() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/toJSON)
+ */
toJSON(): any;
}
declare var DOMPointReadOnly: {
prototype: DOMPointReadOnly;
new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/fromPoint_static) */
+ /**
+ * The static **DOMPointReadOnly** method `fromPoint()` creates and returns a new `DOMPointReadOnly` object given a source point.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMPointReadOnly/fromPoint_static)
+ */
fromPoint(other?: DOMPointInit): DOMPointReadOnly;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad) */
+/**
+ * A `DOMQuad` is a collection of four `DOMPoint`s defining the corners of an arbitrary quadrilateral.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad)
+ */
interface DOMQuad {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p1) */
+ /**
+ * The **`DOMQuad`** interface's **`p1`** property holds the DOMPoint object that represents one of the four corners of the `DOMQuad`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p1)
+ */
readonly p1: DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p2) */
+ /**
+ * The **`DOMQuad`** interface's **`p2`** property holds the DOMPoint object that represents one of the four corners of the `DOMQuad`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p2)
+ */
readonly p2: DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p3) */
+ /**
+ * The **`DOMQuad`** interface's **`p3`** property holds the DOMPoint object that represents one of the four corners of the `DOMQuad`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p3)
+ */
readonly p3: DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p4) */
+ /**
+ * The **`DOMQuad`** interface's **`p4`** property holds the DOMPoint object that represents one of the four corners of the `DOMQuad`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/p4)
+ */
readonly p4: DOMPoint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/getBounds) */
+ /**
+ * The DOMQuad method `getBounds()` returns a DOMRect object representing the smallest rectangle that fully contains the `DOMQuad` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/getBounds)
+ */
getBounds(): DOMRect;
+ /**
+ * The DOMQuad method `toJSON()` returns a ```js-nolint toJSON() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMQuad/toJSON)
+ */
toJSON(): any;
}
declare var DOMQuad: {
@@ -2164,70 +3344,144 @@
fromQuad(other?: DOMQuadInit): DOMQuad;
fromRect(other?: DOMRectInit): DOMQuad;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect) */
+/**
+ * A **`DOMRect`** describes the size and position of a rectangle.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect)
+ */
interface DOMRect extends DOMRectReadOnly {
+ /**
+ * The **`height`** property of the DOMRect interface represents the height of the rectangle.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/height)
+ */
height: number;
+ /**
+ * The **`width`** property of the DOMRect interface represents the width of the rectangle.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/width)
+ */
width: number;
+ /**
+ * The **`x`** property of the DOMRect interface represents the x-coordinate of the rectangle, which is the horizontal distance between the viewport's left edge and the rectangle's origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/x)
+ */
x: number;
+ /**
+ * The **`y`** property of the DOMRect interface represents the y-coordinate of the rectangle, which is the vertical distance between the viewport's top edge and the rectangle's origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/y)
+ */
y: number;
}
declare var DOMRect: {
prototype: DOMRect;
new(x?: number, y?: number, width?: number, height?: number): DOMRect;
+ /**
+ * The **`fromRect()`** static method of the object with a given location and dimensions.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/fromRect_static)
+ */
fromRect(other?: DOMRectInit): DOMRect;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly) */
+/**
+ * The **`DOMRectReadOnly`** interface specifies the standard properties (also used by DOMRect) to define a rectangle whose properties are immutable.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly)
+ */
interface DOMRectReadOnly {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/bottom) */
+ /**
+ * The **`bottom`** read-only property of the **`DOMRectReadOnly`** interface returns the bottom coordinate value of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/bottom)
+ */
readonly bottom: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/height) */
+ /**
+ * The **`height`** read-only property of the **`DOMRectReadOnly`** interface represents the height of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/height)
+ */
readonly height: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/left) */
+ /**
+ * The **`left`** read-only property of the **`DOMRectReadOnly`** interface returns the left coordinate value of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/left)
+ */
readonly left: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/right) */
+ /**
+ * The **`right`** read-only property of the **`DOMRectReadOnly`** interface returns the right coordinate value of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/right)
+ */
readonly right: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/top) */
+ /**
+ * The **`top`** read-only property of the **`DOMRectReadOnly`** interface returns the top coordinate value of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/top)
+ */
readonly top: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/width) */
+ /**
+ * The **`width`** read-only property of the **`DOMRectReadOnly`** interface represents the width of the `DOMRect`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/width)
+ */
readonly width: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/x) */
+ /**
+ * The **`x`** read-only property of the **`DOMRectReadOnly`** interface represents the x coordinate of the `DOMRect`'s origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/x)
+ */
readonly x: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/y) */
+ /**
+ * The **`y`** read-only property of the **`DOMRectReadOnly`** interface represents the y coordinate of the `DOMRect`'s origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/y)
+ */
readonly y: number;
+ /**
+ * The DOMRectReadOnly method `toJSON()` returns a JSON representation of the `DOMRectReadOnly` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/toJSON)
+ */
toJSON(): any;
}
declare var DOMRectReadOnly: {
prototype: DOMRectReadOnly;
new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/fromRect_static) */
+ /**
+ * The **`fromRect()`** static method of the object with a given location and dimensions.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/fromRect_static)
+ */
fromRect(other?: DOMRectInit): DOMRectReadOnly;
};
/**
- * A type returned by some APIs which contains a list of DOMString (strings).
+ * The **`DOMStringList`** interface is a legacy type returned by some APIs and represents a non-modifiable list of strings (`DOMString`).
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringList)
*/
interface DOMStringList {
/**
- * Returns the number of strings in strings.
+ * The read-only **`length`** property indicates the number of strings in the DOMStringList.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringList/length)
*/
readonly length: number;
/**
- * Returns true if strings contains string, and false otherwise.
+ * The **`contains()`** method returns a boolean indicating whether the given string is in the list.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringList/contains)
*/
contains(string: string): boolean;
/**
- * Returns the string with index index from strings.
+ * The **`item()`** method returns a string from a `DOMStringList` by index.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringList/item)
*/
item(index: number): string | null;
@@ -2238,49 +3492,51 @@
prototype: DOMStringList;
new(): DOMStringList;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DecompressionStream) */
+/**
+ * The **`DecompressionStream`** interface of the Compression Streams API is an API for decompressing a stream of data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DecompressionStream)
+ */
interface DecompressionStream extends GenericTransformStream {
+ readonly readable: ReadableStream<Uint8Array<ArrayBuffer>>;
+ readonly writable: WritableStream<BufferSource>;
}
declare var DecompressionStream: {
prototype: DecompressionStream;
new(format: CompressionFormat): DecompressionStream;
};
-interface DedicatedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
+interface DedicatedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap, MessageEventTargetEventMap {
"message": MessageEvent;
"messageerror": MessageEvent;
- "rtctransform": Event;
+ "rtctransform": RTCTransformEvent;
}
/**
- * (the Worker global scope) is accessible through the self keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the JavaScript Reference. See also: Functions available to workers.
+ * The **`DedicatedWorkerGlobalScope`** object (the Worker global scope) is accessible through the WorkerGlobalScope.self keyword.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope)
*/
-interface DedicatedWorkerGlobalScope extends WorkerGlobalScope, AnimationFrameProvider {
+interface DedicatedWorkerGlobalScope extends WorkerGlobalScope, AnimationFrameProvider, MessageEventTarget<DedicatedWorkerGlobalScope> {
/**
- * Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging.
+ * The **`name`** read-only property of the the Worker.Worker constructor can pass to get a reference to the DedicatedWorkerGlobalScope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/name)
*/
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/message_event) */
- onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */
- onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/rtctransform_event) */
- onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
+ onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: RTCTransformEvent) => any) | null;
/**
- * Aborts dedicatedWorkerGlobal.
+ * The **`close()`** method of the DedicatedWorkerGlobalScope interface discards any tasks queued in the `DedicatedWorkerGlobalScope`'s event loop, effectively closing this particular scope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/close)
*/
close(): void;
/**
- * Clones message and transmits it to the Worker object associated with dedicatedWorkerGlobal. transfer can be passed as a list of objects that are to be transferred rather than cloned.
+ * The **`postMessage()`** method of the DedicatedWorkerGlobalScope interface sends a message to the main thread that spawned it.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/postMessage)
*/
postMessage(message: any, transfer: Transferable[]): void;
@@ -2295,77 +3551,113 @@
prototype: DedicatedWorkerGlobalScope;
new(): DedicatedWorkerGlobalScope;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_blend_minmax) */
+/**
+ * The **`EXT_blend_minmax`** extension is part of the WebGL API and extends blending capabilities by adding two new blend equations: the minimum or maximum color components of the source and destination colors.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_blend_minmax)
+ */
interface EXT_blend_minmax {
readonly MIN_EXT: 0x8007;
readonly MAX_EXT: 0x8008;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_color_buffer_float) */
+/**
+ * The **`EXT_color_buffer_float`** extension is part of WebGL and adds the ability to render a variety of floating point formats.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_color_buffer_float)
+ */
interface EXT_color_buffer_float {
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_color_buffer_half_float) */
+/**
+ * The **`EXT_color_buffer_half_float`** extension is part of the WebGL API and adds the ability to render to 16-bit floating-point color buffers.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_color_buffer_half_float)
+ */
interface EXT_color_buffer_half_float {
readonly RGBA16F_EXT: 0x881A;
readonly RGB16F_EXT: 0x881B;
readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 0x8211;
readonly UNSIGNED_NORMALIZED_EXT: 0x8C17;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_float_blend) */
+/**
+ * The WebGL API's `EXT_float_blend` extension allows blending and draw buffers with 32-bit floating-point components.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_float_blend)
+ */
interface EXT_float_blend {
}
/**
- * The EXT_frag_depth extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader.
+ * The **`EXT_frag_depth`** extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_frag_depth)
*/
interface EXT_frag_depth {
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_sRGB) */
+/**
+ * The **`EXT_sRGB`** extension is part of the WebGL API and adds sRGB support to textures and framebuffer objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_sRGB)
+ */
interface EXT_sRGB {
readonly SRGB_EXT: 0x8C40;
readonly SRGB_ALPHA_EXT: 0x8C42;
readonly SRGB8_ALPHA8_EXT: 0x8C43;
readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 0x8210;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_shader_texture_lod) */
+/**
+ * The **`EXT_shader_texture_lod`** extension is part of the WebGL API and adds additional texture functions to the OpenGL ES Shading Language which provide the shader writer with explicit control of LOD (Level of detail).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_shader_texture_lod)
+ */
interface EXT_shader_texture_lod {
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_compression_bptc) */
+/**
+ * The `EXT_texture_compression_bptc` extension is part of the WebGL API and exposes 4 BPTC compressed texture formats.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_compression_bptc)
+ */
interface EXT_texture_compression_bptc {
readonly COMPRESSED_RGBA_BPTC_UNORM_EXT: 0x8E8C;
readonly COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: 0x8E8D;
readonly COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: 0x8E8E;
readonly COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: 0x8E8F;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_compression_rgtc) */
+/**
+ * The `EXT_texture_compression_rgtc` extension is part of the WebGL API and exposes 4 RGTC compressed texture formats.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_compression_rgtc)
+ */
interface EXT_texture_compression_rgtc {
readonly COMPRESSED_RED_RGTC1_EXT: 0x8DBB;
readonly COMPRESSED_SIGNED_RED_RGTC1_EXT: 0x8DBC;
readonly COMPRESSED_RED_GREEN_RGTC2_EXT: 0x8DBD;
readonly COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 0x8DBE;
}
/**
- * The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF).
+ * The **`EXT_texture_filter_anisotropic`** extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF).
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_filter_anisotropic)
*/
interface EXT_texture_filter_anisotropic {
readonly TEXTURE_MAX_ANISOTROPY_EXT: 0x84FE;
readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: 0x84FF;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_norm16) */
+/**
+ * The **`EXT_texture_norm16`** extension is part of the WebGL API and provides a set of new 16-bit signed normalized and unsigned normalized formats (fixed-point texture, renderbuffer and texture buffer).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EXT_texture_norm16)
+ */
interface EXT_texture_norm16 {
readonly R16_EXT: 0x822A;
readonly RG16_EXT: 0x822C;
readonly RGB16_EXT: 0x8054;
@@ -2375,19 +3667,86 @@
readonly RGB16_SNORM_EXT: 0x8F9A;
readonly RGBA16_SNORM_EXT: 0x8F9B;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk) */
+/**
+ * The **`EncodedAudioChunk`** interface of the WebCodecs API represents a chunk of encoded audio data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk)
+ */
+interface EncodedAudioChunk {
+ /**
+ * The **`byteLength`** read-only property of the EncodedAudioChunk interface returns the length in bytes of the encoded audio data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/byteLength)
+ */
+ readonly byteLength: number;
+ /**
+ * The **`duration`** read-only property of the EncodedAudioChunk interface returns an integer indicating the duration of the audio in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/duration)
+ */
+ readonly duration: number | null;
+ /**
+ * The **`timestamp`** read-only property of the EncodedAudioChunk interface returns an integer indicating the timestamp of the audio in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/timestamp)
+ */
+ readonly timestamp: number;
+ /**
+ * The **`type`** read-only property of the EncodedAudioChunk interface returns a value indicating whether the audio chunk is a key chunk, which does not relying on other frames for decoding.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/type)
+ */
+ readonly type: EncodedAudioChunkType;
+ /**
+ * The **`copyTo()`** method of the EncodedAudioChunk interface copies the encoded chunk of audio data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/copyTo)
+ */
+ copyTo(destination: AllowSharedBufferSource): void;
+}
+
+declare var EncodedAudioChunk: {
+ prototype: EncodedAudioChunk;
+ new(init: EncodedAudioChunkInit): EncodedAudioChunk;
+};
+
+/**
+ * The **`EncodedVideoChunk`** interface of the WebCodecs API represents a chunk of encoded video data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk)
+ */
interface EncodedVideoChunk {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/byteLength) */
+ /**
+ * The **`byteLength`** read-only property of the EncodedVideoChunk interface returns the length in bytes of the encoded video data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/byteLength)
+ */
readonly byteLength: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/duration) */
+ /**
+ * The **`duration`** read-only property of the EncodedVideoChunk interface returns an integer indicating the duration of the video in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/duration)
+ */
readonly duration: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/timestamp) */
+ /**
+ * The **`timestamp`** read-only property of the EncodedVideoChunk interface returns an integer indicating the timestamp of the video in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/timestamp)
+ */
readonly timestamp: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/type) */
+ /**
+ * The **`type`** read-only property of the EncodedVideoChunk interface returns a value indicating whether the video chunk is a key chunk, which does not rely on other frames for decoding.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/type)
+ */
readonly type: EncodedVideoChunkType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/copyTo) */
+ /**
+ * The **`copyTo()`** method of the EncodedVideoChunk interface copies the encoded chunk of video data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/copyTo)
+ */
copyTo(destination: AllowSharedBufferSource): void;
}
declare var EncodedVideoChunk: {
@@ -2395,22 +3754,42 @@
new(init: EncodedVideoChunkInit): EncodedVideoChunk;
};
/**
- * Events providing information related to errors in scripts or in files.
+ * The **`ErrorEvent`** interface represents events providing information related to errors in scripts or in files.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent)
*/
interface ErrorEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/colno) */
+ /**
+ * The **`colno`** read-only property of the ErrorEvent interface returns an integer containing the column number of the script file on which the error occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/colno)
+ */
readonly colno: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/error) */
+ /**
+ * The **`error`** read-only property of the ErrorEvent interface returns a JavaScript value, such as an Error or DOMException, representing the error associated with this event.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/error)
+ */
readonly error: any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/filename) */
+ /**
+ * The **`filename`** read-only property of the ErrorEvent interface returns a string containing the name of the script file in which the error occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/filename)
+ */
readonly filename: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/lineno) */
+ /**
+ * The **`lineno`** read-only property of the ErrorEvent interface returns an integer containing the line number of the script file on which the error occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/lineno)
+ */
readonly lineno: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/message) */
+ /**
+ * The **`message`** read-only property of the ErrorEvent interface returns a string containing a human-readable error message describing the problem.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/message)
+ */
readonly message: string;
}
declare var ErrorEvent: {
@@ -2418,117 +3797,121 @@
new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
};
/**
- * An event which takes place in the DOM.
+ * The **`Event`** interface represents an event which takes place on an `EventTarget`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event)
*/
interface Event {
/**
- * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
+ * The **`bubbles`** read-only property of the Event interface indicates whether the event bubbles up through the DOM tree or not.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/bubbles)
*/
readonly bubbles: boolean;
/**
+ * The **`cancelBubble`** property of the Event interface is deprecated.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelBubble)
*/
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.
+ * The **`cancelable`** read-only property of the Event interface indicates whether the event can be canceled, and therefore prevented as if the event never happened.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelable)
*/
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.
+ * The read-only **`composed`** property of the or not the event will propagate across the shadow DOM boundary into the standard DOM.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composed)
*/
readonly composed: boolean;
/**
- * Returns the object whose event listener's callback is currently being invoked.
+ * The **`currentTarget`** read-only property of the Event interface identifies the element to which the event handler has been attached.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/currentTarget)
*/
readonly currentTarget: EventTarget | null;
/**
- * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
+ * The **`defaultPrevented`** read-only property of the Event interface returns a boolean value indicating whether or not the call to Event.preventDefault() canceled the event.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/defaultPrevented)
*/
readonly defaultPrevented: boolean;
/**
- * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
+ * The **`eventPhase`** read-only property of the being evaluated.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/eventPhase)
*/
readonly eventPhase: number;
/**
- * Returns true if event was dispatched by the user agent, and false otherwise.
+ * The **`isTrusted`** read-only property of the when the event was generated by the user agent (including via user actions and programmatic methods such as HTMLElement.focus()), and `false` when the event was dispatched via The only exception is the `click` event, which initializes the `isTrusted` property to `false` in user agents.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/isTrusted)
*/
readonly isTrusted: boolean;
/**
+ * The Event property **`returnValue`** indicates whether the default action for this event has been prevented or not.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/returnValue)
*/
returnValue: boolean;
/**
+ * The deprecated **`Event.srcElement`** is an alias for the Event.target property.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/srcElement)
*/
readonly srcElement: EventTarget | null;
/**
- * Returns the object to which event is dispatched (its target).
+ * The read-only **`target`** property of the dispatched.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/target)
*/
readonly target: EventTarget | null;
/**
- * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
+ * The **`timeStamp`** read-only property of the Event interface returns the time (in milliseconds) at which the event was created.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/timeStamp)
*/
readonly timeStamp: DOMHighResTimeStamp;
/**
- * Returns the type of event, e.g. "click", "hashchange", or "submit".
+ * The **`type`** read-only property of the Event interface returns a string containing the event's type.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/type)
*/
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.
+ * The **`composedPath()`** method of the Event interface returns the event's path which is an array of the objects on which listeners will be invoked.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composedPath)
*/
composedPath(): EventTarget[];
/**
+ * The **`Event.initEvent()`** method is used to initialize the value of an event created using Document.createEvent().
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/initEvent)
*/
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
/**
- * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
+ * The **`preventDefault()`** method of the Event interface tells the user agent that if the event does not get explicitly handled, its default action should not be taken as it normally would be.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/preventDefault)
*/
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.
+ * The **`stopImmediatePropagation()`** method of the If several listeners are attached to the same element for the same event type, they are called in the order in which they were added.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopImmediatePropagation)
*/
stopImmediatePropagation(): void;
/**
- * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
+ * The **`stopPropagation()`** method of the Event interface prevents further propagation of the current event in the capturing and bubbling phases.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopPropagation)
*/
stopPropagation(): void;
@@ -2560,36 +3943,40 @@
"message": MessageEvent;
"open": Event;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource) */
+/**
+ * The **`EventSource`** interface is web content's interface to server-sent events.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource)
+ */
interface EventSource extends EventTarget {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
onerror: ((this: EventSource, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
onopen: ((this: EventSource, ev: Event) => any) | null;
/**
- * Returns the state of this EventSource object's connection. It can have the values described below.
+ * The **`readyState`** read-only property of the connection.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
*/
readonly readyState: number;
/**
- * Returns the URL providing the event stream.
+ * The **`url`** read-only property of the URL of the source.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
*/
readonly url: string;
/**
- * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+ * The **`withCredentials`** read-only property of the the `EventSource` object was instantiated with CORS credentials set.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
*/
readonly withCredentials: boolean;
/**
- * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+ * The **`close()`** method of the EventSource interface closes the connection, if one is made, and sets the ```js-nolint close() ``` None.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
*/
close(): void;
@@ -2612,39 +3999,27 @@
readonly CLOSED: 2;
};
/**
- * EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them.
+ * The **`EventTarget`** interface is implemented by objects that can receive events and may have listeners for them.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget)
*/
interface EventTarget {
/**
- * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
+ * The **`addEventListener()`** method of the EventTarget interface sets up a function that will be called whenever the specified event is delivered to the target.
*
- * 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.
- *
- * If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.
- *
- * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener)
*/
addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): 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.
+ * The **`dispatchEvent()`** method of the EventTarget sends an Event to the object, (synchronously) invoking the affected event listeners in the appropriate order.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent)
*/
dispatchEvent(event: Event): boolean;
/**
- * Removes the event listener in target's event listener list with the same type, callback, and options.
+ * The **`removeEventListener()`** method of the EventTarget interface removes an event listener previously registered with EventTarget.addEventListener() from the target.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener)
*/
removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
@@ -2655,14 +4030,43 @@
new(): EventTarget;
};
/**
- * Extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.
+ * The **`ExtendableCookieChangeEvent`** interface of the Cookie Store API is the event type passed to ServiceWorkerGlobalScope/cookiechange_event event fired at the ServiceWorkerGlobalScope when any cookie changes occur which match the service worker's cookie change subscription list.
*
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableCookieChangeEvent)
+ */
+interface ExtendableCookieChangeEvent extends ExtendableEvent {
+ /**
+ * The **`changed`** read-only property of the ExtendableCookieChangeEvent interface returns any cookies that have been changed by the given `ExtendableCookieChangeEvent` instance.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableCookieChangeEvent/changed)
+ */
+ readonly changed: ReadonlyArray<CookieListItem>;
+ /**
+ * The **`deleted`** read-only property of the ExtendableCookieChangeEvent interface returns any cookies that have been deleted by the given `ExtendableCookieChangeEvent` instance.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableCookieChangeEvent/deleted)
+ */
+ readonly deleted: ReadonlyArray<CookieListItem>;
+}
+
+declare var ExtendableCookieChangeEvent: {
+ prototype: ExtendableCookieChangeEvent;
+ new(type: string, eventInitDict?: ExtendableCookieChangeEventInit): ExtendableCookieChangeEvent;
+};
+
+/**
+ * The **`ExtendableEvent`** interface extends the lifetime of the `install` and `activate` events dispatched on the global scope as part of the service worker lifecycle.
+ *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent)
*/
interface ExtendableEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) */
+ /**
+ * The **`ExtendableEvent.waitUntil()`** method tells the event dispatcher that work is ongoing.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil)
+ */
waitUntil(f: Promise<any>): void;
}
declare var ExtendableEvent: {
@@ -2670,22 +4074,42 @@
new(type: string, eventInitDict?: ExtendableEventInit): ExtendableEvent;
};
/**
- * This ServiceWorker API interface represents the event object of a message event fired on a service worker (when a channel message is received on the ServiceWorkerGlobalScope from another context) — extends the lifetime of such events.
+ * The **`ExtendableMessageEvent`** interface of the Service Worker API represents the event object of a ServiceWorkerGlobalScope/message_event event fired on a service worker (when a message is received on the ServiceWorkerGlobalScope from another context) — extends the lifetime of such events.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent)
*/
interface ExtendableMessageEvent extends ExtendableEvent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/data) */
+ /**
+ * The **`data`** read-only property of the data type.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/data)
+ */
readonly data: any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/lastEventId) */
+ /**
+ * The **`lastEventID`** read-only property of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/lastEventId)
+ */
readonly lastEventId: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/origin) */
+ /**
+ * The **`origin`** read-only property of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/origin)
+ */
readonly origin: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/ports) */
+ /**
+ * The **`ports`** read-only property of the channel (the channel the message is being sent through.) An array of MessagePort objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/ports)
+ */
readonly ports: ReadonlyArray<MessagePort>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/source) */
+ /**
+ * The **`source`** read-only property of the A Client, ServiceWorker or MessagePort object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableMessageEvent/source)
+ */
readonly source: Client | ServiceWorker | MessagePort | null;
}
declare var ExtendableMessageEvent: {
@@ -2693,24 +4117,48 @@
new(type: string, eventInitDict?: ExtendableMessageEventInit): ExtendableMessageEvent;
};
/**
- * This is the event type for fetch events dispatched on the service worker global scope. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the event.respondWith() method, which allows us to provide a response to this fetch.
+ * This is the event type for `fetch` events dispatched on the ServiceWorkerGlobalScope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent)
*/
interface FetchEvent extends ExtendableEvent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/clientId) */
+ /**
+ * The **`clientId`** read-only property of the current service worker is controlling.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/clientId)
+ */
readonly clientId: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/handled) */
- readonly handled: Promise<undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/preloadResponse) */
+ /**
+ * The **`handled`** property of the FetchEvent interface returns a promise indicating if the event has been handled by the fetch algorithm or not.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/handled)
+ */
+ readonly handled: Promise<void>;
+ /**
+ * The **`preloadResponse`** read-only property of the FetchEvent interface returns a Promise that resolves to the navigation preload Response if navigation preload was triggered, or `undefined` otherwise.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/preloadResponse)
+ */
readonly preloadResponse: Promise<any>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/request) */
+ /**
+ * The **`request`** read-only property of the the event handler.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/request)
+ */
readonly request: Request;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/resultingClientId) */
+ /**
+ * The **`resultingClientId`** read-only property of the navigation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/resultingClientId)
+ */
readonly resultingClientId: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/respondWith) */
+ /**
+ * The **`respondWith()`** method of allows you to provide a promise for a Response yourself.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/respondWith)
+ */
respondWith(r: Response | PromiseLike<Response>): void;
}
declare var FetchEvent: {
@@ -2718,18 +4166,30 @@
new(type: string, eventInitDict: FetchEventInit): FetchEvent;
};
/**
- * Provides information about files and allows JavaScript in a web page to access their content.
+ * The **`File`** interface provides information about files and allows JavaScript in a web page to access their content.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/File)
*/
interface File extends Blob {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+ /**
+ * The **`lastModified`** read-only property of the File interface provides the last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified)
+ */
readonly lastModified: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+ /**
+ * The **`name`** read-only property of the File interface returns the name of the file represented by a File object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name)
+ */
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/webkitRelativePath) */
+ /**
+ * The **`webkitRelativePath`** read-only property of the File interface contains a string which specifies the file's path relative to the directory selected by the user in an input element with its `webkitdirectory` attribute set.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/webkitRelativePath)
+ */
readonly webkitRelativePath: string;
}
declare var File: {
@@ -2737,16 +4197,24 @@
new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
};
/**
- * An object of this type is returned by the files property of the HTML <input> element; this lets you access the list of files selected with the <input type="file"> element. It's also used for a list of files dropped into web content when using the drag and drop API; see the DataTransfer object for details on this usage.
+ * The **`FileList`** interface represents an object of this type returned by the `files` property of the HTML input element; this lets you access the list of files selected with the `<input type='file'>` element.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileList)
*/
interface FileList {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileList/length) */
+ /**
+ * The **`length`** read-only property of the FileList interface returns the number of files in the `FileList`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileList/length)
+ */
readonly length: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileList/item) */
+ /**
+ * The **`item()`** method of the FileList interface returns a File object representing the file at the specified index in the file list.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileList/item)
+ */
item(index: number): File | null;
[index: number]: File;
}
@@ -2764,14 +4232,18 @@
"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.
+ * The **`FileReader`** interface 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.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader)
*/
interface FileReader extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/error) */
+ /**
+ * The **`error`** read-only property of the FileReader interface returns the error that occurred while reading the file.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/error)
+ */
readonly error: DOMException | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/abort_event) */
onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/error_event) */
@@ -2783,25 +4255,50 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/loadstart_event) */
onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/progress_event) */
onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readyState) */
+ /**
+ * The **`readyState`** read-only property of the FileReader interface provides the current state of the reading operation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readyState)
+ */
readonly readyState: typeof FileReader.EMPTY | typeof FileReader.LOADING | typeof FileReader.DONE;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/result) */
+ /**
+ * The **`result`** read-only property of the FileReader interface returns the file's contents.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/result)
+ */
readonly result: string | ArrayBuffer | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/abort) */
+ /**
+ * The **`abort()`** method of the FileReader interface aborts the read operation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/abort)
+ */
abort(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsArrayBuffer) */
+ /**
+ * The **`readAsArrayBuffer()`** method of the FileReader interface is used to start reading the contents of a specified Blob or File.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsArrayBuffer)
+ */
readAsArrayBuffer(blob: Blob): void;
/**
+ * The **`readAsBinaryString()`** method of the FileReader interface is used to start reading the contents of the specified Blob or File.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsBinaryString)
*/
readAsBinaryString(blob: Blob): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsDataURL) */
+ /**
+ * The **`readAsDataURL()`** method of the FileReader interface is used to read the contents of the specified file's data as a base64 encoded string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsDataURL)
+ */
readAsDataURL(blob: Blob): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsText) */
+ /**
+ * The **`readAsText()`** method of the FileReader interface is used to read the contents of the specified Blob or File.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReader/readAsText)
+ */
readAsText(blob: Blob, encoding?: string): void;
readonly EMPTY: 0;
readonly LOADING: 1;
readonly DONE: 2;
@@ -2819,24 +4316,37 @@
readonly DONE: 2;
};
/**
- * Allows to read File or Blob objects in a synchronous way.
+ * The **`FileReaderSync`** interface allows to read File or Blob objects synchronously.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync)
*/
interface FileReaderSync {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsArrayBuffer) */
+ /**
+ * The **`readAsArrayBuffer()`** method of the FileReaderSync interface allows to read File or Blob objects in a synchronous way into an ArrayBuffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsArrayBuffer)
+ */
readAsArrayBuffer(blob: Blob): ArrayBuffer;
/**
+ * The **`readAsBinaryString()`** method of the FileReaderSync interface allows to read File or Blob objects in a synchronous way into a string.
* @deprecated
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsBinaryString)
*/
readAsBinaryString(blob: Blob): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsDataURL) */
+ /**
+ * The **`readAsDataURL()`** method of the FileReaderSync interface allows to read File or Blob objects in a synchronous way into a string representing a data URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsDataURL)
+ */
readAsDataURL(blob: Blob): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsText) */
+ /**
+ * The **`readAsText()`** method of the FileReaderSync interface allows to read File or Blob objects in a synchronous way into a string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileReaderSync/readAsText)
+ */
readAsText(blob: Blob, encoding?: string): string;
}
declare var FileReaderSync: {
@@ -2844,21 +4354,38 @@
new(): FileReaderSync;
};
/**
+ * The **`FileSystemDirectoryHandle`** interface of the File System API provides a handle to a file system directory.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle)
*/
interface FileSystemDirectoryHandle extends FileSystemHandle {
readonly kind: "directory";
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/getDirectoryHandle) */
+ /**
+ * The **`getDirectoryHandle()`** method of the within the directory handle on which the method is called.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/getDirectoryHandle)
+ */
getDirectoryHandle(name: string, options?: FileSystemGetDirectoryOptions): Promise<FileSystemDirectoryHandle>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/getFileHandle) */
+ /**
+ * The **`getFileHandle()`** method of the directory the method is called.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/getFileHandle)
+ */
getFileHandle(name: string, options?: FileSystemGetFileOptions): Promise<FileSystemFileHandle>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/removeEntry) */
+ /**
+ * The **`removeEntry()`** method of the directory handle contains a file or directory called the name specified.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/removeEntry)
+ */
removeEntry(name: string, options?: FileSystemRemoveOptions): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/resolve) */
+ /**
+ * The **`resolve()`** method of the directory names from the parent handle to the specified child entry, with the name of the child entry as the last array item.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle/resolve)
+ */
resolve(possibleDescendant: FileSystemHandle): Promise<string[] | null>;
}
declare var FileSystemDirectoryHandle: {
@@ -2866,19 +4393,32 @@
new(): FileSystemDirectoryHandle;
};
/**
+ * The **`FileSystemFileHandle`** interface of the File System API represents a handle to a file system entry.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle)
*/
interface FileSystemFileHandle extends FileSystemHandle {
readonly kind: "file";
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/createSyncAccessHandle) */
+ /**
+ * The **`createSyncAccessHandle()`** method of the that can be used to synchronously read from and write to a file.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/createSyncAccessHandle)
+ */
createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/createWritable) */
+ /**
+ * The **`createWritable()`** method of the FileSystemFileHandle interface creates a FileSystemWritableFileStream that can be used to write to a file.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/createWritable)
+ */
createWritable(options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/getFile) */
+ /**
+ * The **`getFile()`** method of the If the file on disk changes or is removed after this method is called, the returned ```js-nolint getFile() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle/getFile)
+ */
getFile(): Promise<File>;
}
declare var FileSystemFileHandle: {
@@ -2886,18 +4426,31 @@
new(): FileSystemFileHandle;
};
/**
+ * The **`FileSystemHandle`** interface of the File System API is an object which represents a file or directory entry.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle)
*/
interface FileSystemHandle {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/kind) */
+ /**
+ * The **`kind`** read-only property of the `'file'` if the associated entry is a file or `'directory'`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/kind)
+ */
readonly kind: FileSystemHandleKind;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/name) */
+ /**
+ * The **`name`** read-only property of the handle.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/name)
+ */
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/isSameEntry) */
+ /**
+ * The **`isSameEntry()`** method of the ```js-nolint isSameEntry(fileSystemHandle) ``` - FileSystemHandle - : The `FileSystemHandle` to match against the handle on which the method is invoked.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/isSameEntry)
+ */
isSameEntry(other: FileSystemHandle): Promise<boolean>;
}
declare var FileSystemHandle: {
@@ -2905,24 +4458,49 @@
new(): FileSystemHandle;
};
/**
+ * The **`FileSystemSyncAccessHandle`** interface of the File System API represents a synchronous handle to a file system entry.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle)
*/
interface FileSystemSyncAccessHandle {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/close) */
+ /**
+ * The **`close()`** method of the ```js-nolint close() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/close)
+ */
close(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/flush) */
+ /**
+ * The **`flush()`** method of the Bear in mind that you only need to call this method if you need the changes committed to disk at a specific time, otherwise you can leave the underlying operating system to handle this when it sees fit, which should be OK in most cases.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/flush)
+ */
flush(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/getSize) */
+ /**
+ * The **`getSize()`** method of the ```js-nolint getSize() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/getSize)
+ */
getSize(): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/read) */
+ /**
+ * The **`read()`** method of the ```js-nolint read(buffer, options) ``` - `buffer` - : An ArrayBuffer or `ArrayBufferView` (such as a DataView) representing the buffer that the file content should be read into.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/read)
+ */
read(buffer: AllowSharedBufferSource, options?: FileSystemReadWriteOptions): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/truncate) */
+ /**
+ * The **`truncate()`** method of the ```js-nolint truncate(newSize) ``` - `newSize` - : The number of bytes to resize the file to.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/truncate)
+ */
truncate(newSize: number): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/write) */
+ /**
+ * The **`write()`** method of the Files within the origin private file system are not visible to end-users, therefore are not subject to the same security checks as methods running on files within the user-visible file system.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemSyncAccessHandle/write)
+ */
write(buffer: AllowSharedBufferSource, options?: FileSystemReadWriteOptions): number;
}
declare var FileSystemSyncAccessHandle: {
@@ -2930,82 +4508,171 @@
new(): FileSystemSyncAccessHandle;
};
/**
+ * The **`FileSystemWritableFileStream`** interface of the File System API is a WritableStream object with additional convenience methods, which operates on a single file on disk.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream)
*/
interface FileSystemWritableFileStream extends WritableStream {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/seek) */
+ /**
+ * The **`seek()`** method of the FileSystemWritableFileStream interface updates the current file cursor offset to the position (in bytes) specified when calling the method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/seek)
+ */
seek(position: number): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/truncate) */
+ /**
+ * The **`truncate()`** method of the FileSystemWritableFileStream interface resizes the file associated with the stream to the specified size in bytes.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/truncate)
+ */
truncate(size: number): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write) */
+ /**
+ * The **`write()`** method of the FileSystemWritableFileStream interface writes content into the file the method is called on, at the current file cursor offset.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+ */
write(data: FileSystemWriteChunkType): Promise<void>;
}
declare var FileSystemWritableFileStream: {
prototype: FileSystemWritableFileStream;
new(): FileSystemWritableFileStream;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace) */
+/**
+ * The **`FontFace`** interface of the CSS Font Loading API represents a single usable font face.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace)
+ */
interface FontFace {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/ascentOverride) */
+ /**
+ * The **`ascentOverride`** property of the FontFace interface returns and sets the ascent metric for the font, the height above the baseline that CSS uses to lay out line boxes in an inline formatting context.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/ascentOverride)
+ */
ascentOverride: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/descentOverride) */
+ /**
+ * The **`descentOverride`** property of the FontFace interface returns and sets the value of the @font-face/descent-override descriptor.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/descentOverride)
+ */
descentOverride: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/display) */
+ /**
+ * The **`display`** property of the FontFace interface determines how a font face is displayed based on whether and when it is downloaded and ready to use.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/display)
+ */
display: FontDisplay;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/family) */
+ /**
+ * The **`FontFace.family`** property allows the author to get or set the font family of a FontFace object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/family)
+ */
family: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/featureSettings) */
+ /**
+ * The **`featureSettings`** property of the FontFace interface retrieves or sets infrequently used font features that are not available from a font's variant properties.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/featureSettings)
+ */
featureSettings: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/lineGapOverride) */
+ /**
+ * The **`lineGapOverride`** property of the FontFace interface returns and sets the value of the @font-face/line-gap-override descriptor.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/lineGapOverride)
+ */
lineGapOverride: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/loaded) */
+ /**
+ * The **`loaded`** read-only property of the FontFace interface returns a Promise that resolves with the current `FontFace` object when the font specified in the object's constructor is done loading or rejects with a `SyntaxError`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/loaded)
+ */
readonly loaded: Promise<FontFace>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/status) */
+ /**
+ * The **`status`** read-only property of the FontFace interface returns an enumerated value indicating the status of the font, one of `'unloaded'`, `'loading'`, `'loaded'`, or `'error'`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/status)
+ */
readonly status: FontFaceLoadStatus;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/stretch) */
+ /**
+ * The **`stretch`** property of the FontFace interface retrieves or sets how the font stretches.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/stretch)
+ */
stretch: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/style) */
+ /**
+ * The **`style`** property of the FontFace interface retrieves or sets the font's style.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/style)
+ */
style: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/unicodeRange) */
+ /**
+ * The **`unicodeRange`** property of the FontFace interface retrieves or sets the range of unicode code points encompassing the font.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/unicodeRange)
+ */
unicodeRange: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/weight) */
+ /**
+ * The **`weight`** property of the FontFace interface retrieves or sets the weight of the font.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/weight)
+ */
weight: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/load) */
+ /**
+ * The **`load()`** method of the FontFace interface requests and loads a font whose `source` was specified as a URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFace/load)
+ */
load(): Promise<FontFace>;
}
declare var FontFace: {
prototype: FontFace;
- new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace;
+ new(family: string, source: string | BufferSource, descriptors?: FontFaceDescriptors): FontFace;
};
interface FontFaceSetEventMap {
- "loading": Event;
- "loadingdone": Event;
- "loadingerror": Event;
+ "loading": FontFaceSetLoadEvent;
+ "loadingdone": FontFaceSetLoadEvent;
+ "loadingerror": FontFaceSetLoadEvent;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet) */
+/**
+ * The **`FontFaceSet`** interface of the CSS Font Loading API manages the loading of font-faces and querying of their download status.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet)
+ */
interface FontFaceSet extends EventTarget {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loading_event) */
- onloading: ((this: FontFaceSet, ev: Event) => any) | null;
+ onloading: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingdone_event) */
- onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null;
+ onloadingdone: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingerror_event) */
- onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/ready) */
+ onloadingerror: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null;
+ /**
+ * The `ready` read-only property of the FontFaceSet interface returns a Promise that resolves to the given FontFaceSet.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/ready)
+ */
readonly ready: Promise<FontFaceSet>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/status) */
+ /**
+ * The **`status`** read-only property of the FontFaceSet interface returns the loading state of the fonts in the set.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/status)
+ */
readonly status: FontFaceSetLoadStatus;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/check) */
+ /**
+ * The `check()` method of the FontFaceSet returns `true` if you can render some text using the given font specification without attempting to use any fonts in this `FontFaceSet` that are not yet fully loaded.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/check)
+ */
check(font: string, text?: string): boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/load) */
+ /**
+ * The `load()` method of the FontFaceSet forces all the fonts given in parameters to be loaded.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/load)
+ */
load(font: string, text?: string): Promise<FontFace[]>;
forEach(callbackfn: (value: FontFace, key: FontFace, parent: FontFaceSet) => void, thisArg?: any): void;
addEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
@@ -3014,14 +4681,22 @@
}
declare var FontFaceSet: {
prototype: FontFaceSet;
- new(initialFaces: FontFace[]): FontFaceSet;
+ new(): FontFaceSet;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent) */
+/**
+ * The **`FontFaceSetLoadEvent`** interface of the CSS Font Loading API represents events fired at a FontFaceSet after it starts loading font faces.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent)
+ */
interface FontFaceSetLoadEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent/fontfaces) */
+ /**
+ * The **`fontfaces`** read-only property of the An array of FontFace instance.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent/fontfaces)
+ */
readonly fontfaces: ReadonlyArray<FontFace>;
}
declare var FontFaceSetLoadEvent: {
@@ -3034,26 +4709,50 @@
readonly fonts: FontFaceSet;
}
/**
- * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using the XMLHttpRequest.send() method. It uses the same format a form would use if the encoding type were set to "multipart/form-data".
+ * The **`FormData`** interface provides a way to construct a set of key/value pairs representing form fields and their values, which can be sent using the Window/fetch, XMLHttpRequest.send() or navigator.sendBeacon() methods.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData)
*/
interface FormData {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/append) */
+ /**
+ * The **`append()`** method of the FormData interface appends a new value onto an existing key inside a `FormData` object, or adds the key if it does not already exist.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/append)
+ */
append(name: string, value: string | Blob): void;
append(name: string, value: string): void;
append(name: string, blobValue: Blob, filename?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/delete) */
+ /**
+ * The **`delete()`** method of the FormData interface deletes a key and its value(s) from a `FormData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/delete)
+ */
delete(name: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/get) */
+ /**
+ * The **`get()`** method of the FormData interface returns the first value associated with a given key from within a `FormData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/get)
+ */
get(name: string): FormDataEntryValue | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/getAll) */
+ /**
+ * The **`getAll()`** method of the FormData interface returns all the values associated with a given key from within a `FormData` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/getAll)
+ */
getAll(name: string): FormDataEntryValue[];
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/has) */
+ /**
+ * The **`has()`** method of the FormData interface returns whether a `FormData` object contains a certain key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/has)
+ */
has(name: string): boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/set) */
+ /**
+ * The **`set()`** method of the FormData interface sets a new value for an existing key inside a `FormData` object, or adds the key/value if it does not already exist.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/set)
+ */
set(name: string, value: string | Blob): void;
set(name: string, value: string): void;
set(name: string, blobValue: Blob, filename?: string): void;
forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
@@ -3063,32 +4762,71 @@
prototype: FormData;
new(): FormData;
};
+/**
+ * The **`GPUError`** interface of the WebGPU API is the base interface for errors surfaced by GPUDevice.popErrorScope and the GPUDevice.uncapturederror_event event.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUError)
+ */
+interface GPUError {
+ /**
+ * The **`message`** read-only property of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUError/message)
+ */
+ readonly message: string;
+}
+
interface GenericTransformStream {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream/readable) */
readonly readable: ReadableStream;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream/writable) */
readonly writable: WritableStream;
}
/**
- * This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs. You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
+ * The **`Headers`** interface of the Fetch API allows you to perform various actions on HTTP request and response headers.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers)
*/
interface Headers {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/append) */
+ /**
+ * The **`append()`** method of the Headers interface appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/append)
+ */
append(name: string, value: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/delete) */
+ /**
+ * The **`delete()`** method of the Headers interface deletes a header from the current `Headers` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/delete)
+ */
delete(name: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/get) */
+ /**
+ * The **`get()`** method of the Headers interface returns a byte string of all the values of a header within a `Headers` object with a given name.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/get)
+ */
get(name: string): string | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/getSetCookie) */
+ /**
+ * The **`getSetCookie()`** method of the Headers interface returns an array containing the values of all Set-Cookie headers associated with a response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/getSetCookie)
+ */
getSetCookie(): string[];
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/has) */
+ /**
+ * The **`has()`** method of the Headers interface returns a boolean stating whether a `Headers` object contains a certain header.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/has)
+ */
has(name: string): boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/set) */
+ /**
+ * The **`set()`** method of the Headers interface sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/set)
+ */
set(name: string, value: string): void;
forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
}
@@ -3097,72 +4835,70 @@
new(init?: HeadersInit): Headers;
};
/**
- * This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database.
+ * The **`IDBCursor`** interface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor)
*/
interface IDBCursor {
/**
- * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
+ * The **`direction`** read-only property of the direction of traversal of the cursor (set using section below for possible values.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/direction)
*/
readonly direction: IDBCursorDirection;
/**
- * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
+ * The **`key`** read-only property of the position.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/key)
*/
readonly key: IDBValidKey;
/**
- * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
+ * The **`primaryKey`** read-only property of the cursor is currently being iterated or has iterated outside its range, this is set to undefined.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/primaryKey)
*/
readonly primaryKey: IDBValidKey;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/request) */
+ /**
+ * The **`request`** read-only property of the IDBCursor interface returns the IDBRequest used to obtain the cursor.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/request)
+ */
readonly request: IDBRequest;
/**
- * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
+ * The **`source`** read-only property of the null or throws an exception, even if the cursor is currently being iterated, has iterated past its end, or its transaction is not active.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/source)
*/
readonly source: IDBObjectStore | IDBIndex;
/**
- * Advances the cursor through the next count records in range.
+ * The **`advance()`** method of the IDBCursor interface sets the number of times a cursor should move its position forward.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/advance)
*/
advance(count: number): void;
/**
- * Advances the cursor to the next record in range.
+ * The **`continue()`** method of the IDBCursor interface advances the cursor to the next position along its direction, to the item whose key matches the optional key parameter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/continue)
*/
continue(key?: IDBValidKey): void;
/**
- * Advances the cursor to the next record in range matching or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
+ * The **`continuePrimaryKey()`** method of the matches the key parameter as well as whose primary key matches the primary key parameter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/continuePrimaryKey)
*/
continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
/**
- * Delete the record pointed at by the cursor with a new value.
+ * The **`delete()`** method of the IDBCursor interface returns an IDBRequest object, and, in a separate thread, deletes the record at the cursor's position, without changing the cursor's position.
*
- * If successful, request's result will be undefined.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/delete)
*/
delete(): IDBRequest<undefined>;
/**
- * Updated the record pointed at by the cursor with a new value.
+ * The **`update()`** method of the IDBCursor interface returns an IDBRequest object, and, in a separate thread, updates the value at the current position of the cursor in the object store.
*
- * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
- *
- * If successful, request's result will be the record's key.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/update)
*/
update(value: any): IDBRequest<IDBValidKey>;
}
@@ -3172,15 +4908,15 @@
new(): IDBCursor;
};
/**
- * This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property.
+ * The **`IDBCursorWithValue`** interface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursorWithValue)
*/
interface IDBCursorWithValue extends IDBCursor {
/**
- * Returns the cursor's current value.
+ * The **`value`** read-only property of the whatever that is.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursorWithValue/value)
*/
readonly value: any;
@@ -3198,21 +4934,21 @@
"versionchange": IDBVersionChangeEvent;
}
/**
- * This IndexedDB API interface provides a connection to a database; you can use an IDBDatabase object to open a transaction on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database.
+ * The **`IDBDatabase`** interface of the IndexedDB API provides a connection to a database; you can use an `IDBDatabase` object to open a transaction on your database then create, manipulate, and delete objects (data) in that database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase)
*/
interface IDBDatabase extends EventTarget {
/**
- * Returns the name of the database.
+ * The **`name`** read-only property of the `IDBDatabase` interface is a string that contains the name of the connected database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/name)
*/
readonly name: string;
/**
- * Returns a list of the names of object stores in the database.
+ * The **`objectStoreNames`** read-only property of the list of the names of the object stores currently in the connected database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/objectStoreNames)
*/
readonly objectStoreNames: DOMStringList;
@@ -3222,37 +4958,33 @@
onerror: ((this: IDBDatabase, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/versionchange_event) */
onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
/**
- * Returns the version of the database.
+ * The **`version`** property of the IDBDatabase interface is a 64-bit integer that contains the version of the connected database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/version)
*/
readonly version: number;
/**
- * Closes the connection once all running transactions have finished.
+ * The **`close()`** method of the IDBDatabase interface returns immediately and closes the connection in a separate thread.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/close)
*/
close(): void;
/**
- * Creates a new object store with the given name and options and returns a new IDBObjectStore.
+ * The **`createObjectStore()`** method of the The method takes the name of the store as well as a parameter object that lets you define important optional properties.
*
- * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/createObjectStore)
*/
createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
/**
- * Deletes the object store with the given name.
+ * The **`deleteObjectStore()`** method of the the connected database, along with any indexes that reference it.
*
- * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/deleteObjectStore)
*/
deleteObjectStore(name: string): void;
/**
- * Returns a new transaction with the given mode ("readonly" or "readwrite") and scope which can be a single object store name or an array of names.
+ * The **`transaction`** method of the IDBDatabase interface immediately returns a transaction object (IDBTransaction) containing the IDBTransaction.objectStore method, which you can use to access your object store.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/transaction)
*/
transaction(storeNames: string | string[], mode?: IDBTransactionMode, options?: IDBTransactionOptions): IDBTransaction;
@@ -3267,31 +4999,33 @@
new(): IDBDatabase;
};
/**
- * In the following code snippet, we make a request to open a database, and include handlers for the success and error cases. For a full working example, see our To-do Notifications app (view example live.)
+ * The **`IDBFactory`** interface of the IndexedDB API lets applications asynchronously access the indexed databases.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory)
*/
interface IDBFactory {
/**
- * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
+ * The **`cmp()`** method of the IDBFactory interface compares two values as keys to determine equality and ordering for IndexedDB operations, such as storing and iterating.
*
- * Throws a "DataError" DOMException if either input is not a valid key.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory/cmp)
*/
cmp(first: any, second: any): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory/databases) */
+ /**
+ * The **`databases`** method of the IDBFactory interface returns a Promise that fulfills with an array of objects containing the name and version of all the available databases.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory/databases)
+ */
databases(): Promise<IDBDatabaseInfo[]>;
/**
- * Attempts to delete the named database. If the database already exists and there are open connections that don't close in response to a versionchange event, the request will be blocked until all they close. If the request is successful request's result will be null.
+ * The **`deleteDatabase()`** method of the returns an IDBOpenDBRequest object immediately, and performs the deletion operation asynchronously.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory/deleteDatabase)
*/
deleteDatabase(name: string): IDBOpenDBRequest;
/**
- * Attempts to open a connection to the named database with the current version, or 1 if it does not already exist. If the request is successful request's result will be the connection.
+ * The **`open()`** method of the IDBFactory interface requests opening a connection to a database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBFactory/open)
*/
open(name: string, version?: number): IDBOpenDBRequest;
@@ -3302,84 +5036,82 @@
new(): IDBFactory;
};
/**
- * IDBIndex interface of the IndexedDB API provides asynchronous access to an index in a database. An index is a kind of object store for looking up records in another object store, called the referenced object store. You use this interface to retrieve data.
+ * `IDBIndex` interface of the IndexedDB API provides asynchronous access to an index in a database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex)
*/
interface IDBIndex {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/keyPath) */
+ /**
+ * The **`keyPath`** property of the IDBIndex interface returns the key path of the current index.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/keyPath)
+ */
readonly keyPath: string | string[];
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/multiEntry) */
+ /**
+ * The **`multiEntry`** read-only property of the behaves when the result of evaluating the index's key path yields an array.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/multiEntry)
+ */
readonly multiEntry: boolean;
/**
- * Returns the name of the index.
+ * The **`name`** property of the IDBIndex interface contains a string which names the index.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/name)
*/
name: string;
/**
- * Returns the IDBObjectStore the index belongs to.
+ * The **`objectStore`** property of the IDBIndex interface returns the object store referenced by the current index.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/objectStore)
*/
readonly objectStore: IDBObjectStore;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/unique) */
+ /**
+ * The **`unique`** read-only property returns a boolean that states whether the index allows duplicate keys.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/unique)
+ */
readonly unique: boolean;
/**
- * Retrieves the number of records matching the given key or key range in query.
+ * The **`count()`** method of the IDBIndex interface returns an IDBRequest object, and in a separate thread, returns the number of records within a key range.
*
- * If successful, request's result will be the count.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/count)
*/
count(query?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
/**
- * Retrieves the value of the first record matching the given key or key range in query.
+ * The **`get()`** method of the IDBIndex interface returns an IDBRequest object, and, in a separate thread, finds either the value in the referenced object store that corresponds to the given key or the first corresponding value, if `key` is set to an If a value is found, then a structured clone of it is created and set as the `result` of the request object: this returns the record the key is associated with.
*
- * If successful, request's result will be the value, or undefined if there was no matching record.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/get)
*/
get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
/**
- * Retrieves the values of the records matching the given key or key range in query (up to count if given).
+ * The **`getAll()`** method of the IDBIndex interface retrieves all objects that are inside the index.
*
- * If successful, request's result will be an Array of the values.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/getAll)
*/
getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
/**
- * Retrieves the keys of records matching the given key or key range in query (up to count if given).
+ * The **`getAllKeys()`** method of the IDBIndex interface asynchronously retrieves the primary keys of all objects inside the index, setting them as the `result` of the request object.
*
- * If successful, request's result will be an Array of the keys.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/getAllKeys)
*/
getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
/**
- * Retrieves the key of the first record matching the given key or key range in query.
+ * The **`getKey()`** method of the IDBIndex interface returns an IDBRequest object, and, in a separate thread, finds either the primary key that corresponds to the given key in this index or the first corresponding primary key, if `key` is set to an If a primary key is found, it is set as the `result` of the request object.
*
- * If successful, request's result will be the key, or undefined if there was no matching record.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/getKey)
*/
getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
/**
- * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
+ * The **`openCursor()`** method of the IDBIndex interface returns an IDBRequest object, and, in a separate thread, creates a cursor over the specified key range.
*
- * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/openCursor)
*/
openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
/**
- * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in index are matched.
+ * The **`openKeyCursor()`** method of the a separate thread, creates a cursor over the specified key range, as arranged by this index.
*
- * If successful, request's result will be an IDBCursor, or null if there were no matching records.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBIndex/openKeyCursor)
*/
openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
}
@@ -3389,39 +5121,39 @@
new(): IDBIndex;
};
/**
- * A key range can be a single value or a range with upper and lower bounds or endpoints. If the key range has both upper and lower bounds, then it is bounded; if it has no bounds, it is unbounded. A bounded key range can either be open (the endpoints are excluded) or closed (the endpoints are included). To retrieve all keys within a certain range, you can use the following code constructs:
+ * The **`IDBKeyRange`** interface of the IndexedDB API represents a continuous interval over some data type that is used for keys.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange)
*/
interface IDBKeyRange {
/**
- * Returns lower bound, or undefined if none.
+ * The **`lower`** read-only property of the The lower bound of the key range (can be any type.) The following example illustrates how you'd use a key range.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/lower)
*/
readonly lower: any;
/**
- * Returns true if the lower open flag is set, and false otherwise.
+ * The **`lowerOpen`** read-only property of the lower-bound value is included in the key range.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/lowerOpen)
*/
readonly lowerOpen: boolean;
/**
- * Returns upper bound, or undefined if none.
+ * The **`upper`** read-only property of the The upper bound of the key range (can be any type.) The following example illustrates how you'd use a key range.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/upper)
*/
readonly upper: any;
/**
- * Returns true if the upper open flag is set, and false otherwise.
+ * The **`upperOpen`** read-only property of the upper-bound value is included in the key range.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/upperOpen)
*/
readonly upperOpen: boolean;
/**
- * Returns true if key is included in the range, and false otherwise.
+ * The `includes()` method of the IDBKeyRange interface returns a boolean indicating whether a specified key is inside the key range.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/includes)
*/
includes(key: any): boolean;
@@ -3430,180 +5162,150 @@
declare var IDBKeyRange: {
prototype: IDBKeyRange;
new(): IDBKeyRange;
/**
- * Returns a new IDBKeyRange spanning from lower to upper. If lowerOpen is true, lower is not included in the range. If upperOpen is true, upper is not included in the range.
+ * The **`bound()`** static method of the IDBKeyRange interface creates a new key range with the specified upper and lower bounds.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/bound_static)
*/
bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
/**
- * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
+ * The **`lowerBound()`** static method of the By default, it includes the lower endpoint value and is closed.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/lowerBound_static)
*/
lowerBound(lower: any, open?: boolean): IDBKeyRange;
/**
- * Returns a new IDBKeyRange spanning only key.
+ * The **`only()`** static method of the IDBKeyRange interface creates a new key range containing a single value.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/only_static)
*/
only(value: any): IDBKeyRange;
/**
- * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
+ * The **`upperBound()`** static method of the it includes the upper endpoint value and is closed.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBKeyRange/upperBound_static)
*/
upperBound(upper: any, open?: boolean): IDBKeyRange;
};
/**
- * This example shows a variety of different uses of object stores, from updating the data structure with IDBObjectStore.createIndex inside an onupgradeneeded function, to adding a new item to our object store with IDBObjectStore.add. For a full working example, see our To-do Notifications app (view example live.)
+ * The **`IDBObjectStore`** interface of the IndexedDB API represents an object store in a database.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore)
*/
interface IDBObjectStore {
/**
- * Returns true if the store has a key generator, and false otherwise.
+ * The **`autoIncrement`** read-only property of the for this object store.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/autoIncrement)
*/
readonly autoIncrement: boolean;
/**
- * Returns a list of the names of indexes in the store.
+ * The **`indexNames`** read-only property of the in this object store.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/indexNames)
*/
readonly indexNames: DOMStringList;
/**
- * Returns the key path of the store, or null if none.
+ * The **`keyPath`** read-only property of the If this property is null, the application must provide a key for each modification operation.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/keyPath)
*/
- readonly keyPath: string | string[];
+ readonly keyPath: string | string[] | null;
/**
- * Returns the name of the store.
+ * The **`name`** property of the IDBObjectStore interface indicates the name of this object store.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/name)
*/
name: string;
/**
- * Returns the associated transaction.
+ * The **`transaction`** read-only property of the object store belongs.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/transaction)
*/
readonly transaction: IDBTransaction;
/**
- * Adds or updates a record in store with the given value and key.
+ * The **`add()`** method of the IDBObjectStore interface returns an IDBRequest object, and, in a separate thread, creates a structured clone of the value, and stores the cloned value in the object store.
*
- * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
- *
- * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
- *
- * If successful, request's result will be the record's key.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/add)
*/
add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
/**
- * Deletes all records in store.
+ * The **`clear()`** method of the IDBObjectStore interface creates and immediately returns an IDBRequest object, and clears this object store in a separate thread.
*
- * If successful, request's result will be undefined.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/clear)
*/
clear(): IDBRequest<undefined>;
/**
- * Retrieves the number of records matching the given key or key range in query.
+ * The **`count()`** method of the IDBObjectStore interface returns an IDBRequest object, and, in a separate thread, returns the total number of records that match the provided key or of records in the store.
*
- * If successful, request's result will be the count.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/count)
*/
count(query?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
/**
- * Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be satisfied with the data already in store the upgrade transaction will abort with a "ConstraintError" DOMException.
+ * The **`createIndex()`** method of the field/column defining a new data point for each database record to contain.
*
- * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/createIndex)
*/
createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
/**
- * Deletes records in store with the given key or in the given key range in query.
+ * The **`delete()`** method of the and, in a separate thread, deletes the specified record or records.
*
- * If successful, request's result will be undefined.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/delete)
*/
delete(query: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
/**
- * Deletes the index in store with the given name.
+ * The **`deleteIndex()`** method of the the connected database, used during a version upgrade.
*
- * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/deleteIndex)
*/
deleteIndex(name: string): void;
/**
- * Retrieves the value of the first record matching the given key or key range in query.
+ * The **`get()`** method of the IDBObjectStore interface returns an IDBRequest object, and, in a separate thread, returns the object selected by the specified key.
*
- * If successful, request's result will be the value, or undefined if there was no matching record.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/get)
*/
get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
/**
- * Retrieves the values of the records matching the given key or key range in query (up to count if given).
+ * The **`getAll()`** method of the containing all objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
*
- * If successful, request's result will be an Array of the values.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAll)
*/
getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
/**
- * Retrieves the keys of records matching the given key or key range in query (up to count if given).
+ * The `getAllKeys()` method of the IDBObjectStore interface returns an IDBRequest object retrieves record keys for all objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
*
- * If successful, request's result will be an Array of the keys.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAllKeys)
*/
getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
/**
- * Retrieves the key of the first record matching the given key or key range in query.
+ * The **`getKey()`** method of the and, in a separate thread, returns the key selected by the specified query.
*
- * If successful, request's result will be the key, or undefined if there was no matching record.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getKey)
*/
getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/index) */
+ /**
+ * The **`index()`** method of the IDBObjectStore interface opens a named index in the current object store, after which it can be used to, for example, return a series of records sorted by that index using a cursor.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/index)
+ */
index(name: string): IDBIndex;
/**
- * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
+ * The **`openCursor()`** method of the and, in a separate thread, returns a new IDBCursorWithValue object.
*
- * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/openCursor)
*/
openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
/**
- * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
+ * The **`openKeyCursor()`** method of the whose result will be set to an IDBCursor that can be used to iterate through matching results.
*
- * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/openKeyCursor)
*/
openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
/**
- * Adds or updates a record in store with the given value and key.
+ * The **`put()`** method of the IDBObjectStore interface updates a given record in a database, or inserts a new record if the given item does not already exist.
*
- * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
- *
- * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
- *
- * If successful, request's result will be the record's key.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/put)
*/
put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
}
@@ -3618,9 +5320,9 @@
"upgradeneeded": IDBVersionChangeEvent;
}
/**
- * Also inherits methods from its parents IDBRequest and EventTarget.
+ * The **`IDBOpenDBRequest`** interface of the IndexedDB API provides access to the results of requests to open or delete databases (performed using IDBFactory.open and IDBFactory.deleteDatabase), using specific event handler attributes.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBOpenDBRequest)
*/
interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
@@ -3644,15 +5346,15 @@
"success": Event;
}
/**
- * The request object does not initially contain any information about the result of the operation, but once information becomes available, an event is fired on the request, and the information becomes available through the properties of the IDBRequest instance.
+ * The **`IDBRequest`** interface of the IndexedDB API provides access to results of asynchronous requests to databases and database objects using event handler attributes.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest)
*/
interface IDBRequest<T = any> extends EventTarget {
/**
- * When a request is completed, returns the error (a DOMException), or null if the request succeeded. Throws a "InvalidStateError" DOMException if the request is still pending.
+ * The **`error`** read-only property of the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/error)
*/
readonly error: DOMException | null;
@@ -3660,27 +5362,27 @@
onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/success_event) */
onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
/**
- * Returns "pending" until a request is complete, then returns "done".
+ * The **`readyState`** read-only property of the Every request starts in the `pending` state.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/readyState)
*/
readonly readyState: IDBRequestReadyState;
/**
- * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
+ * The **`result`** read-only property of the any - `InvalidStateError` DOMException - : Thrown when attempting to access the property if the request is not completed, and therefore the result is not available.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/result)
*/
readonly result: T;
/**
- * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
+ * The **`source`** read-only property of the Index or an object store.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/source)
*/
readonly source: IDBObjectStore | IDBIndex | IDBCursor;
/**
- * Returns the IDBTransaction the request was made within. If this as an open request, then it returns an upgrade transaction while it is running, or null otherwise.
+ * The **`transaction`** read-only property of the IDBRequest interface returns the transaction for the request, that is, the transaction the request is being made inside.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBRequest/transaction)
*/
readonly transaction: IDBTransaction | null;
@@ -3700,32 +5402,40 @@
"complete": Event;
"error": Event;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction) */
+/**
+ * The **`IDBTransaction`** interface of the IndexedDB API provides a static, asynchronous transaction on a database using event handler attributes.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction)
+ */
interface IDBTransaction extends EventTarget {
/**
- * Returns the transaction's connection.
+ * The **`db`** read-only property of the IDBTransaction interface returns the database connection with which this transaction is associated.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/db)
*/
readonly db: IDBDatabase;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/durability) */
+ /**
+ * The **`durability`** read-only property of the IDBTransaction interface returns the durability hint the transaction was created with.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/durability)
+ */
readonly durability: IDBTransactionDurability;
/**
- * If the transaction was aborted, returns the error (a DOMException) providing the reason.
+ * The **`IDBTransaction.error`** property of the IDBTransaction interface returns the type of error when there is an unsuccessful transaction.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/error)
*/
readonly error: DOMException | null;
/**
- * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
+ * The **`mode`** read-only property of the data in the object stores in the scope of the transaction (i.e., is the mode to be read-only, or do you want to write to the object stores?) The default value is `readonly`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/mode)
*/
readonly mode: IDBTransactionMode;
/**
- * Returns a list of the names of object stores in the transaction's scope. For an upgrade transaction this is all object stores in the database.
+ * The **`objectStoreNames`** read-only property of the of IDBObjectStore objects.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/objectStoreNames)
*/
readonly objectStoreNames: DOMStringList;
@@ -3735,17 +5445,21 @@
oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/error_event) */
onerror: ((this: IDBTransaction, ev: Event) => any) | null;
/**
- * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
+ * The **`abort()`** method of the IDBTransaction interface rolls back all the changes to objects in the database associated with this transaction.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/abort)
*/
abort(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/commit) */
+ /**
+ * The **`commit()`** method of the IDBTransaction interface commits the transaction if it is called on an active transaction.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/commit)
+ */
commit(): void;
/**
- * Returns an IDBObjectStore in the transaction's scope.
+ * The **`objectStore()`** method of the added to the scope of this transaction.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/objectStore)
*/
objectStore(name: string): IDBObjectStore;
@@ -3760,40 +5474,52 @@
new(): IDBTransaction;
};
/**
- * This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function.
+ * The **`IDBVersionChangeEvent`** interface of the IndexedDB API indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.upgradeneeded_event event handler function.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBVersionChangeEvent)
*/
interface IDBVersionChangeEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBVersionChangeEvent/newVersion) */
+ /**
+ * The **`newVersion`** read-only property of the database.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBVersionChangeEvent/newVersion)
+ */
readonly newVersion: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBVersionChangeEvent/oldVersion) */
+ /**
+ * The **`oldVersion`** read-only property of the database.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBVersionChangeEvent/oldVersion)
+ */
readonly oldVersion: number;
}
declare var IDBVersionChangeEvent: {
prototype: IDBVersionChangeEvent;
new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmap) */
+/**
+ * The **`ImageBitmap`** interface represents a bitmap image which can be drawn to a canvas without undue latency.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmap)
+ */
interface ImageBitmap {
/**
- * Returns the intrinsic height of the image, in CSS pixels.
+ * The **`ImageBitmap.height`** read-only property returns the ImageBitmap object's height in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmap/height)
*/
readonly height: number;
/**
- * Returns the intrinsic width of the image, in CSS pixels.
+ * The **`ImageBitmap.width`** read-only property returns the ImageBitmap object's width in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmap/width)
*/
readonly width: number;
/**
- * Releases imageBitmap's underlying bitmap data.
+ * The **`ImageBitmap.close()`** method disposes of all graphical resources associated with an `ImageBitmap`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmap/close)
*/
close(): void;
@@ -3803,12 +5529,16 @@
prototype: ImageBitmap;
new(): ImageBitmap;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmapRenderingContext) */
+/**
+ * The **`ImageBitmapRenderingContext`** interface is a canvas rendering context that provides the functionality to replace the canvas's contents with the given ImageBitmap.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmapRenderingContext)
+ */
interface ImageBitmapRenderingContext {
/**
- * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
+ * The **`ImageBitmapRenderingContext.transferFromImageBitmap()`** method displays the given ImageBitmap in the canvas associated with this rendering context.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmapRenderingContext/transferFromImageBitmap)
*/
transferFromImageBitmap(bitmap: ImageBitmap | null): void;
@@ -3819,29 +5549,33 @@
new(): ImageBitmapRenderingContext;
};
/**
- * The underlying pixel data of an area of a <canvas> element. It is created using the ImageData() constructor or creator methods on the CanvasRenderingContext2D object associated with a canvas: createImageData() and getImageData(). It can also be used to set a part of the canvas by using putImageData().
+ * The **`ImageData`** interface represents the underlying pixel data of an area of a canvas element.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData)
*/
interface ImageData {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData/colorSpace) */
+ /**
+ * The read-only **`ImageData.colorSpace`** property is a string indicating the color space of the image data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData/colorSpace)
+ */
readonly colorSpace: PredefinedColorSpace;
/**
- * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
+ * The readonly **`ImageData.data`** property returns a pixel data.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData/data)
*/
- readonly data: Uint8ClampedArray;
+ readonly data: ImageDataArray;
/**
- * Returns the actual dimensions of the data in the ImageData object, in pixels.
+ * The readonly **`ImageData.height`** property returns the number of rows in the ImageData object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData/height)
*/
readonly height: number;
/**
- * Returns the actual dimensions of the data in the ImageData object, in pixels.
+ * The readonly **`ImageData.width`** property returns the number of pixels per row in the ImageData object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageData/width)
*/
readonly width: number;
@@ -3849,25 +5583,180 @@
declare var ImageData: {
prototype: ImageData;
new(sw: number, sh: number, settings?: ImageDataSettings): ImageData;
- new(data: Uint8ClampedArray, sw: number, sh?: number, settings?: ImageDataSettings): ImageData;
+ new(data: ImageDataArray, sw: number, sh?: number, settings?: ImageDataSettings): ImageData;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KHR_parallel_shader_compile) */
+/**
+ * The **`ImageDecoder`** interface of the WebCodecs API provides a way to unpack and decode encoded image data.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder)
+ */
+interface ImageDecoder {
+ /**
+ * The **`complete`** read-only property of the ImageDecoder interface returns true if encoded data has completed buffering.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/complete)
+ */
+ readonly complete: boolean;
+ /**
+ * The **`completed`** read-only property of the ImageDecoder interface returns a promise that resolves once encoded data has finished buffering.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/completed)
+ */
+ readonly completed: Promise<void>;
+ /**
+ * The **`tracks`** read-only property of the ImageDecoder interface returns a list of the tracks in the encoded image data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/tracks)
+ */
+ readonly tracks: ImageTrackList;
+ /**
+ * The **`type`** read-only property of the ImageDecoder interface reflects the MIME type configured during construction.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/type)
+ */
+ readonly type: string;
+ /**
+ * The **`close()`** method of the ImageDecoder interface ends all pending work and releases system resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/close)
+ */
+ close(): void;
+ /**
+ * The **`decode()`** method of the ImageDecoder interface enqueues a control message to decode the frame of an image.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/decode)
+ */
+ decode(options?: ImageDecodeOptions): Promise<ImageDecodeResult>;
+ /**
+ * The **`reset()`** method of the ImageDecoder interface aborts all pending `decode()` operations; rejecting all pending promises.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/reset)
+ */
+ reset(): void;
+}
+
+declare var ImageDecoder: {
+ prototype: ImageDecoder;
+ new(init: ImageDecoderInit): ImageDecoder;
+ /**
+ * The **`ImageDecoder.isTypeSupported()`** static method checks if a given MIME type can be decoded by the user agent.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageDecoder/isTypeSupported_static)
+ */
+ isTypeSupported(type: string): Promise<boolean>;
+};
+
+/**
+ * The **`ImageTrack`** interface of the WebCodecs API represents an individual image track.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrack)
+ */
+interface ImageTrack {
+ /**
+ * The **`animated`** property of the ImageTrack interface returns `true` if the track is animated and therefore has multiple frames.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrack/animated)
+ */
+ readonly animated: boolean;
+ /**
+ * The **`frameCount`** property of the ImageTrack interface returns the number of frames in the track.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrack/frameCount)
+ */
+ readonly frameCount: number;
+ /**
+ * The **`repetitionCount`** property of the ImageTrack interface returns the number of repetitions of this track.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrack/repetitionCount)
+ */
+ readonly repetitionCount: number;
+ /**
+ * The **`selected`** property of the ImageTrack interface returns `true` if the track is selected for decoding.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrack/selected)
+ */
+ selected: boolean;
+}
+
+declare var ImageTrack: {
+ prototype: ImageTrack;
+ new(): ImageTrack;
+};
+
+/**
+ * The **`ImageTrackList`** interface of the WebCodecs API represents a list of image tracks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrackList)
+ */
+interface ImageTrackList {
+ /**
+ * The **`length`** property of the ImageTrackList interface returns the length of the `ImageTrackList`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrackList/length)
+ */
+ readonly length: number;
+ /**
+ * The **`ready`** property of the ImageTrackList interface returns a Promise that resolves when the `ImageTrackList` is populated with ImageTrack.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrackList/ready)
+ */
+ readonly ready: Promise<void>;
+ /**
+ * The **`selectedIndex`** property of the ImageTrackList interface returns the `index` of the selected track.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrackList/selectedIndex)
+ */
+ readonly selectedIndex: number;
+ /**
+ * The **`selectedTrack`** property of the ImageTrackList interface returns an ImageTrack object representing the currently selected track.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageTrackList/selectedTrack)
+ */
+ readonly selectedTrack: ImageTrack | null;
+ [index: number]: ImageTrack;
+}
+
+declare var ImageTrackList: {
+ prototype: ImageTrackList;
+ new(): ImageTrackList;
+};
+
+interface ImportMeta {
+ url: string;
+ resolve(specifier: string): string;
+}
+
+/**
+ * The **`KHR_parallel_shader_compile`** extension is part of the WebGL API and enables a non-blocking poll operation, so that compile/link status availability (`COMPLETION_STATUS_KHR`) can be queried without potentially incurring stalls.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/KHR_parallel_shader_compile)
+ */
interface KHR_parallel_shader_compile {
readonly COMPLETION_STATUS_KHR: 0x91B1;
}
/**
+ * The **`Lock`** interface of the Web Locks API provides the name and mode of a lock.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Lock)
*/
interface Lock {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Lock/mode) */
+ /**
+ * The **`mode`** read-only property of the Lock interface returns the access mode passed to LockManager.request() when the lock was requested.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Lock/mode)
+ */
readonly mode: LockMode;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Lock/name) */
+ /**
+ * The **`name`** read-only property of the Lock interface returns the _name_ passed to The name of a lock is passed by script when the lock is requested.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Lock/name)
+ */
readonly name: string;
}
declare var Lock: {
@@ -3875,30 +5764,51 @@
new(): Lock;
};
/**
+ * The **`LockManager`** interface of the Web Locks API provides methods for requesting a new Lock object and querying for an existing `Lock` object.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/LockManager)
*/
interface LockManager {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/LockManager/query) */
+ /**
+ * The **`query()`** method of the LockManager interface returns a Promise that resolves with an object containing information about held and pending locks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/LockManager/query)
+ */
query(): Promise<LockManagerSnapshot>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/LockManager/request) */
- request(name: string, callback: LockGrantedCallback): Promise<any>;
- request(name: string, options: LockOptions, callback: LockGrantedCallback): Promise<any>;
+ /**
+ * The **`request()`** method of the LockManager interface requests a Lock object with parameters specifying its name and characteristics.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/LockManager/request)
+ */
+ request<T>(name: string, callback: LockGrantedCallback<T>): Promise<T>;
+ request<T>(name: string, options: LockOptions, callback: LockGrantedCallback<T>): Promise<T>;
}
declare var LockManager: {
prototype: LockManager;
new(): LockManager;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities) */
+/**
+ * The **`MediaCapabilities`** interface of the Media Capabilities API provides information about the decoding abilities of the device, system and browser.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities)
+ */
interface MediaCapabilities {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities/decodingInfo) */
+ /**
+ * The **`decodingInfo()`** method of the MediaCapabilities interface returns a promise that fulfils with information about how well the user agent can decode/display media with a given configuration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities/decodingInfo)
+ */
decodingInfo(configuration: MediaDecodingConfiguration): Promise<MediaCapabilitiesDecodingInfo>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities/encodingInfo) */
+ /**
+ * The **`encodingInfo()`** method of the MediaCapabilities interface returns a promise that fulfills with the tested media configuration's capabilities for encoding media.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaCapabilities/encodingInfo)
+ */
encodingInfo(configuration: MediaEncodingConfiguration): Promise<MediaCapabilitiesEncodingInfo>;
}
declare var MediaCapabilities: {
@@ -3906,21 +5816,53 @@
new(): MediaCapabilities;
};
/**
- * This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties.
+ * The **`MediaSourceHandle`** interface of the Media Source Extensions API is a proxy for a MediaSource that can be transferred from a dedicated worker back to the main thread and attached to a media element via its HTMLMediaElement.srcObject property.
*
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaSourceHandle)
+ */
+interface MediaSourceHandle {
+}
+
+declare var MediaSourceHandle: {
+ prototype: MediaSourceHandle;
+ new(): MediaSourceHandle;
+};
+
+/**
+ * The **`MediaStreamTrackProcessor`** interface of the Insertable Streams for MediaStreamTrack API consumes a video MediaStreamTrack object's source and generates a stream of VideoFrame objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaStreamTrackProcessor)
+ */
+interface MediaStreamTrackProcessor {
+ /**
+ * The **`readable`** property of the MediaStreamTrackProcessor interface returns a ReadableStream of VideoFrames.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaStreamTrackProcessor/readable)
+ */
+ readonly readable: ReadableStream;
+}
+
+declare var MediaStreamTrackProcessor: {
+ prototype: MediaStreamTrackProcessor;
+ new(init: MediaStreamTrackProcessorInit): MediaStreamTrackProcessor;
+};
+
+/**
+ * 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.
+ *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel)
*/
interface MessageChannel {
/**
- * Returns the first MessagePort object.
+ * The **`port1`** read-only property of the the port attached to the context that originated the channel.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel/port1)
*/
readonly port1: MessagePort;
/**
- * Returns the second MessagePort object.
+ * The **`port2`** read-only property of the the port attached to the context at the other end of the channel, which the message is initially sent to.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel/port2)
*/
readonly port2: MessagePort;
@@ -3931,88 +5873,94 @@
new(): MessageChannel;
};
/**
- * A message received by a target object.
+ * The **`MessageEvent`** interface represents a message received by a target object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent)
*/
interface MessageEvent<T = any> extends Event {
/**
- * Returns the data of the message.
+ * The **`data`** read-only property of the The data sent by the message emitter; this can be any data type, depending on what originated this event.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/data)
*/
readonly data: T;
/**
- * Returns the last event ID string, for server-sent events.
+ * The **`lastEventId`** read-only property of the unique ID for the event.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/lastEventId)
*/
readonly lastEventId: string;
/**
- * Returns the origin of the message, for server-sent events and cross-document messaging.
+ * The **`origin`** read-only property of the origin of the message emitter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/origin)
*/
readonly origin: string;
/**
- * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
+ * The **`ports`** read-only property of the containing all MessagePort objects sent with the message, in order.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/ports)
*/
readonly ports: ReadonlyArray<MessagePort>;
/**
- * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
+ * The **`source`** read-only property of the a WindowProxy, MessagePort, or a `MessageEventSource` (which can be a WindowProxy, message emitter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/source)
*/
readonly source: MessageEventSource | null;
- /**
- * @deprecated
- *
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/initMessageEvent)
- */
+ /** @deprecated */
initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
}
declare var MessageEvent: {
prototype: MessageEvent;
new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
};
-interface MessagePortEventMap {
+interface MessageEventTargetEventMap {
"message": MessageEvent;
"messageerror": MessageEvent;
}
+interface MessageEventTarget<T> {
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/message_event) */
+ onmessage: ((this: T, ev: MessageEvent) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */
+ onmessageerror: ((this: T, ev: MessageEvent) => any) | null;
+ addEventListener<K extends keyof MessageEventTargetEventMap>(type: K, listener: (this: T, ev: MessageEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+ addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+ removeEventListener<K extends keyof MessageEventTargetEventMap>(type: K, listener: (this: T, ev: MessageEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+interface MessagePortEventMap extends MessageEventTargetEventMap {
+ "message": MessageEvent;
+ "messageerror": MessageEvent;
+}
+
/**
- * This Channel Messaging API interface 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.
+ * 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.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort)
*/
-interface MessagePort extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/message_event) */
- onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/messageerror_event) */
- onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
+interface MessagePort extends EventTarget, MessageEventTarget<MessagePort> {
/**
- * Disconnects the port, so that it is no longer active.
+ * The **`close()`** method of the MessagePort interface disconnects the port, so it is no longer active.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/close)
*/
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.
+ * The **`postMessage()`** method of the transfers ownership of objects to other browsing contexts.
*
- * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/postMessage)
*/
postMessage(message: any, transfer: Transferable[]): void;
postMessage(message: any, options?: StructuredSerializeOptions): void;
/**
- * Begins dispatching messages received on the port.
+ * The **`start()`** method of the MessagePort interface starts the sending of messages queued on the port.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/start)
*/
start(): void;
@@ -4027,20 +5975,37 @@
new(): MessagePort;
};
/**
+ * The **`NavigationPreloadManager`** interface of the Service Worker API provides methods for managing the preloading of resources in parallel with service worker bootup.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager)
*/
interface NavigationPreloadManager {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/disable) */
+ /**
+ * The **`disable()`** method of the NavigationPreloadManager interface halts the automatic preloading of service-worker-managed resources previously started using NavigationPreloadManager.enable() It returns a promise that resolves with `undefined`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/disable)
+ */
disable(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/enable) */
+ /**
+ * The **`enable()`** method of the NavigationPreloadManager interface is used to enable preloading of resources managed by the service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/enable)
+ */
enable(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/getState) */
+ /**
+ * The **`getState()`** method of the NavigationPreloadManager interface returns a Promise that resolves to an object with properties that indicate whether preload is enabled and what value will be sent in the Service-Worker-Navigation-Preload HTTP header.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/getState)
+ */
getState(): Promise<NavigationPreloadState>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/setHeaderValue) */
+ /**
+ * The **`setHeaderValue()`** method of the NavigationPreloadManager interface sets the value of the Service-Worker-Navigation-Preload header that will be sent with requests resulting from a Window/fetch operation made during service worker navigation preloading.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NavigationPreloadManager/setHeaderValue)
+ */
setHeaderValue(value: string): Promise<void>;
}
declare var NavigationPreloadManager: {
@@ -4127,24 +6092,48 @@
"show": Event;
}
/**
- * This Notifications API interface is used to configure and display desktop notifications to the user.
+ * The **`Notification`** interface of the Notifications API is used to configure and display desktop notifications to the user.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification)
*/
interface Notification extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/badge) */
+ /**
+ * The **`badge`** read-only property of the Notification interface returns a string containing the URL of an image to represent the notification when there is not enough space to display the notification itself such as for example, the Android Notification Bar.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/badge)
+ */
readonly badge: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/body) */
+ /**
+ * The **`body`** read-only property of the specified in the `body` option of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/body)
+ */
readonly body: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/data) */
+ /**
+ * The **`data`** read-only property of the data, as specified in the `data` option of the The notification's data can be any arbitrary data that you want associated with the notification.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/data)
+ */
readonly data: any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/dir) */
+ /**
+ * The **`dir`** read-only property of the Notification interface indicates the text direction of the notification, as specified in the `dir` option of the Notification.Notification constructor.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/dir)
+ */
readonly dir: NotificationDirection;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/icon) */
+ /**
+ * The **`icon`** read-only property of the part of the notification, as specified in the `icon` option of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/icon)
+ */
readonly icon: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/lang) */
+ /**
+ * The **`lang`** read-only property of the as specified in the `lang` option of the The language itself is specified using a string representing a language tag according to MISSING: RFC(5646, 'Tags for Identifying Languages (also known as BCP 47)')].
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/lang)
+ */
readonly lang: string;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/click_event) */
onclick: ((this: Notification, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/close_event) */
@@ -4152,17 +6141,37 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/error_event) */
onerror: ((this: Notification, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/show_event) */
onshow: ((this: Notification, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/requireInteraction) */
+ /**
+ * The **`requireInteraction`** read-only property of the Notification interface returns a boolean value indicating that a notification should remain active until the user clicks or dismisses it, rather than closing automatically.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/requireInteraction)
+ */
readonly requireInteraction: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/silent) */
+ /**
+ * The **`silent`** read-only property of the silent, i.e., no sounds or vibrations should be issued regardless of the device settings.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/silent)
+ */
readonly silent: boolean | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/tag) */
+ /**
+ * The **`tag`** read-only property of the as specified in the `tag` option of the The idea of notification tags is that more than one notification can share the same tag, linking them together.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/tag)
+ */
readonly tag: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/title) */
+ /**
+ * The **`title`** read-only property of the specified in the `title` parameter of the A string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/title)
+ */
readonly title: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/close) */
+ /**
+ * The **`close()`** method of the Notification interface is used to close/remove a previously displayed notification.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/close)
+ */
close(): void;
addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -4171,117 +6180,193 @@
declare var Notification: {
prototype: Notification;
new(title: string, options?: NotificationOptions): Notification;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/permission_static) */
+ /**
+ * The **`permission`** read-only static property of the Notification interface indicates the current permission granted by the user for the current origin to display web notifications.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Notification/permission_static)
+ */
readonly permission: NotificationPermission;
};
/**
- * The parameter passed into the onnotificationclick handler, the NotificationEvent interface represents a notification click event that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.
+ * The **`NotificationEvent`** interface of the Notifications API represents a notification event dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/NotificationEvent)
*/
interface NotificationEvent extends ExtendableEvent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NotificationEvent/action) */
+ /**
+ * The **`action`** read-only property of the NotificationEvent interface returns the string ID of the notification button the user clicked.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NotificationEvent/action)
+ */
readonly action: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NotificationEvent/notification) */
+ /**
+ * The **`notification`** read-only property of the NotificationEvent interface returns the instance of the Notification that was clicked to fire the event.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NotificationEvent/notification)
+ */
readonly notification: Notification;
}
declare var NotificationEvent: {
prototype: NotificationEvent;
new(type: string, eventInitDict: NotificationEventInit): NotificationEvent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed) */
+/**
+ * The **`OES_draw_buffers_indexed`** extension is part of the WebGL API and enables the use of different blend options when writing to multiple color buffers simultaneously.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed)
+ */
interface OES_draw_buffers_indexed {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendEquationSeparateiOES) */
+ /**
+ * The `blendEquationSeparateiOES()` method of the OES_draw_buffers_indexed WebGL extension sets the RGB and alpha blend equations separately for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendEquationSeparateiOES)
+ */
blendEquationSeparateiOES(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendEquationiOES) */
+ /**
+ * The `blendEquationiOES()` method of the `OES_draw_buffers_indexed` WebGL extension sets both the RGB blend and alpha blend equations for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendEquationiOES)
+ */
blendEquationiOES(buf: GLuint, mode: GLenum): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendFuncSeparateiOES) */
+ /**
+ * The `blendFuncSeparateiOES()` method of the OES_draw_buffers_indexed WebGL extension defines which function is used when blending pixels for RGB and alpha components separately for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendFuncSeparateiOES)
+ */
blendFuncSeparateiOES(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendFunciOES) */
+ /**
+ * The `blendFunciOES()` method of the OES_draw_buffers_indexed WebGL extension defines which function is used when blending pixels for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/blendFunciOES)
+ */
blendFunciOES(buf: GLuint, src: GLenum, dst: GLenum): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/colorMaskiOES) */
+ /**
+ * The `colorMaskiOES()` method of the OES_draw_buffers_indexed WebGL extension sets which color components to enable or to disable when drawing or rendering for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/colorMaskiOES)
+ */
colorMaskiOES(buf: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/disableiOES) */
+ /**
+ * The `disableiOES()` method of the OES_draw_buffers_indexed WebGL extension enables blending for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/disableiOES)
+ */
disableiOES(target: GLenum, index: GLuint): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/enableiOES) */
+ /**
+ * The `enableiOES()` method of the OES_draw_buffers_indexed WebGL extension enables blending for a particular draw buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_draw_buffers_indexed/enableiOES)
+ */
enableiOES(target: GLenum, index: GLuint): void;
}
/**
- * The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements().
+ * The **`OES_element_index_uint`** extension is part of the WebGL API and adds support for `gl.UNSIGNED_INT` types to WebGLRenderingContext.drawElements().
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_element_index_uint)
*/
interface OES_element_index_uint {
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_fbo_render_mipmap) */
+/**
+ * The `OES_fbo_render_mipmap` extension is part of the WebGL API and makes it possible to attach any level of a texture to a framebuffer object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_fbo_render_mipmap)
+ */
interface OES_fbo_render_mipmap {
}
/**
- * The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth.
+ * The **`OES_standard_derivatives`** extension is part of the WebGL API and adds the GLSL derivative functions `dFdx`, `dFdy`, and `fwidth`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_standard_derivatives)
*/
interface OES_standard_derivatives {
readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 0x8B8B;
}
/**
- * The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures.
+ * The **`OES_texture_float`** extension is part of the WebGL API and exposes floating-point pixel types for textures.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_texture_float)
*/
interface OES_texture_float {
}
/**
- * The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures.
+ * The **`OES_texture_float_linear`** extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_texture_float_linear)
*/
interface OES_texture_float_linear {
}
/**
- * The OES_texture_half_float extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components.
+ * The **`OES_texture_half_float`** extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_texture_half_float)
*/
interface OES_texture_half_float {
readonly HALF_FLOAT_OES: 0x8D61;
}
/**
- * The OES_texture_half_float_linear extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures.
+ * The **`OES_texture_half_float_linear`** extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_texture_half_float_linear)
*/
interface OES_texture_half_float_linear {
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object) */
+/**
+ * The **OES_vertex_array_object** extension is part of the WebGL API and provides vertex array objects (VAOs) which encapsulate vertex array states.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object)
+ */
interface OES_vertex_array_object {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/bindVertexArrayOES) */
+ /**
+ * The **`OES_vertex_array_object.bindVertexArrayOES()`** method of the WebGL API binds a passed WebGLVertexArrayObject object to the buffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/bindVertexArrayOES)
+ */
bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/createVertexArrayOES) */
- createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/deleteVertexArrayOES) */
+ /**
+ * The **`OES_vertex_array_object.createVertexArrayOES()`** method of the WebGL API creates and initializes a pointing to vertex array data and which provides names for different sets of vertex data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/createVertexArrayOES)
+ */
+ createVertexArrayOES(): WebGLVertexArrayObjectOES;
+ /**
+ * The **`OES_vertex_array_object.deleteVertexArrayOES()`** method of the WebGL API deletes a given ```js-nolint deleteVertexArrayOES(arrayObject) ``` - `arrayObject` - : A WebGLVertexArrayObject (VAO) object to delete.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/deleteVertexArrayOES)
+ */
deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/isVertexArrayOES) */
+ /**
+ * The **`OES_vertex_array_object.isVertexArrayOES()`** method of the WebGL API returns `true` if the passed object is a WebGLVertexArrayObject object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/isVertexArrayOES)
+ */
isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
readonly VERTEX_ARRAY_BINDING_OES: 0x85B5;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OVR_multiview2) */
+/**
+ * The `OVR_multiview2` extension is part of the WebGL API and adds support for rendering into multiple views simultaneously.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OVR_multiview2)
+ */
interface OVR_multiview2 {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OVR_multiview2/framebufferTextureMultiviewOVR) */
+ /**
+ * The **`OVR_multiview2.framebufferTextureMultiviewOVR()`** method of the WebGL API attaches a multiview texture to a WebGLFramebuffer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OVR_multiview2/framebufferTextureMultiviewOVR)
+ */
framebufferTextureMultiviewOVR(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, baseViewIndex: GLint, numViews: GLsizei): void;
readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: 0x9630;
readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: 0x9632;
readonly MAX_VIEWS_OVR: 0x9631;
@@ -4292,52 +6377,48 @@
"contextlost": Event;
"contextrestored": Event;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas) */
+/**
+ * When using the canvas element or the Canvas API, rendering, animation, and user interaction usually happen on the main execution thread of a web application.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas)
+ */
interface OffscreenCanvas extends EventTarget {
/**
- * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
+ * The **`height`** property returns and sets the height of an OffscreenCanvas object.
*
- * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/height)
*/
height: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/contextlost_event) */
oncontextlost: ((this: OffscreenCanvas, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/contextrestored_event) */
oncontextrestored: ((this: OffscreenCanvas, ev: Event) => any) | null;
/**
- * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
+ * The **`width`** property returns and sets the width of an OffscreenCanvas object.
*
- * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/width)
*/
width: number;
/**
- * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
+ * The **`OffscreenCanvas.convertToBlob()`** method creates a Blob object representing the image contained in the canvas.
*
- * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/convertToBlob)
*/
convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
/**
- * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
+ * The **`OffscreenCanvas.getContext()`** method returns a drawing context for an offscreen canvas, or `null` if the context identifier is not supported, or the offscreen canvas has already been set to a different context mode.
*
- * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
- *
- * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/getContext)
*/
getContext(contextId: "2d", options?: any): OffscreenCanvasRenderingContext2D | null;
getContext(contextId: "bitmaprenderer", options?: any): ImageBitmapRenderingContext | null;
getContext(contextId: "webgl", options?: any): WebGLRenderingContext | null;
getContext(contextId: "webgl2", options?: any): WebGL2RenderingContext | null;
getContext(contextId: OffscreenRenderingContextId, options?: any): OffscreenRenderingContext | null;
/**
- * Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image.
+ * The **`OffscreenCanvas.transferToImageBitmap()`** method creates an ImageBitmap object from the most recently rendered image of the `OffscreenCanvas`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas/transferToImageBitmap)
*/
transferToImageBitmap(): ImageBitmap;
@@ -4351,28 +6432,31 @@
prototype: OffscreenCanvas;
new(width: number, height: number): OffscreenCanvas;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvasRenderingContext2D) */
+/**
+ * The **`OffscreenCanvasRenderingContext2D`** interface is a CanvasRenderingContext2D rendering context for drawing to the bitmap of an `OffscreenCanvas` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvasRenderingContext2D)
+ */
interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/canvas) */
readonly canvas: OffscreenCanvas;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvasRenderingContext2D/commit) */
- commit(): void;
}
declare var OffscreenCanvasRenderingContext2D: {
prototype: OffscreenCanvasRenderingContext2D;
new(): OffscreenCanvasRenderingContext2D;
};
/**
- * This Canvas 2D API interface is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of the CanvasRenderingContext2D interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired.
+ * The **`Path2D`** interface of the Canvas 2D API is used to declare a path that can then be used on a CanvasRenderingContext2D object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Path2D)
*/
interface Path2D extends CanvasPath {
/**
- * Adds to the path the path given by the argument.
+ * The **`Path2D.addPath()`** method of the Canvas 2D API adds one Path2D object to another `Path2D` object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Path2D/addPath)
*/
addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
@@ -4387,38 +6471,86 @@
"resourcetimingbufferfull": Event;
}
/**
- * Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API.
+ * The **`Performance`** interface provides access to performance-related information for the current page.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance)
*/
interface Performance extends EventTarget {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/resourcetimingbufferfull_event) */
onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/timeOrigin) */
+ /**
+ * The **`timeOrigin`** read-only property of the Performance interface returns the high resolution timestamp that is used as the baseline for performance-related timestamps.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/timeOrigin)
+ */
readonly timeOrigin: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearMarks) */
+ /**
+ * The **`clearMarks()`** method removes all or specific PerformanceMark objects from the browser's performance timeline.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearMarks)
+ */
clearMarks(markName?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearMeasures) */
+ /**
+ * The **`clearMeasures()`** method removes all or specific PerformanceMeasure objects from the browser's performance timeline.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearMeasures)
+ */
clearMeasures(measureName?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearResourceTimings) */
+ /**
+ * The **`clearResourceTimings()`** method removes all performance entries with an PerformanceEntry.entryType of `'resource'` from the browser's performance timeline and sets the size of the performance resource data buffer to zero.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/clearResourceTimings)
+ */
clearResourceTimings(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntries) */
+ /**
+ * The **`getEntries()`** method returns an array of all PerformanceEntry objects currently present in the performance timeline.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntries)
+ */
getEntries(): PerformanceEntryList;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntriesByName) */
+ /**
+ * The **`getEntriesByName()`** method returns an array of PerformanceEntry objects currently present in the performance timeline with the given _name_ and _type_.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntriesByName)
+ */
getEntriesByName(name: string, type?: string): PerformanceEntryList;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntriesByType) */
+ /**
+ * The **`getEntriesByType()`** method returns an array of PerformanceEntry objects currently present in the performance timeline for a given _type_.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/getEntriesByType)
+ */
getEntriesByType(type: string): PerformanceEntryList;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/mark) */
+ /**
+ * The **`mark()`** method creates a named PerformanceMark object representing a high resolution timestamp marker in the browser's performance timeline.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/mark)
+ */
mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/measure) */
+ /**
+ * The **`measure()`** method creates a named PerformanceMeasure object representing a time measurement between two marks in the browser's performance timeline.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/measure)
+ */
measure(measureName: string, startOrMeasureOptions?: string | PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/now) */
+ /**
+ * The **`performance.now()`** method returns a high resolution timestamp in milliseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/now)
+ */
now(): DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/setResourceTimingBufferSize) */
+ /**
+ * The **`setResourceTimingBufferSize()`** method sets the desired size of the browser's resource timing buffer which stores the `'resource'` performance entries.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/setResourceTimingBufferSize)
+ */
setResourceTimingBufferSize(maxSize: number): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/toJSON) */
+ /**
+ * The **`toJSON()`** method of the Performance interface is a Serialization; it returns a JSON representation of the Performance object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/toJSON)
+ */
toJSON(): any;
addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -4430,22 +6562,42 @@
new(): Performance;
};
/**
- * Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the mark() method) at an explicit point in an application. Performance entries are also created in indirect ways such as loading a resource (such as an image).
+ * The **`PerformanceEntry`** object encapsulates a single performance metric that is part of the browser's performance timeline.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry)
*/
interface PerformanceEntry {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/duration) */
+ /**
+ * The read-only **`duration`** property returns a DOMHighResTimeStamp that is the duration of the PerformanceEntry.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/duration)
+ */
readonly duration: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/entryType) */
+ /**
+ * The read-only **`entryType`** property returns a string representing the type of performance metric that this entry represents.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/entryType)
+ */
readonly entryType: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/name) */
+ /**
+ * The read-only **`name`** property of the PerformanceEntry interface is a string representing the name for a performance entry.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/name)
+ */
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/startTime) */
+ /**
+ * The read-only **`startTime`** property returns the first DOMHighResTimeStamp recorded for this PerformanceEntry.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/startTime)
+ */
readonly startTime: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/toJSON) */
+ /**
+ * The **`toJSON()`** method is a Serialization; it returns a JSON representation of the PerformanceEntry object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceEntry/toJSON)
+ */
toJSON(): any;
}
declare var PerformanceEntry: {
@@ -4453,14 +6605,18 @@
new(): PerformanceEntry;
};
/**
- * PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline.
+ * **`PerformanceMark`** is an interface for PerformanceEntry objects with an PerformanceEntry.entryType of `'mark'`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMark)
*/
interface PerformanceMark extends PerformanceEntry {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMark/detail) */
+ /**
+ * The read-only **`detail`** property returns arbitrary metadata that was included in the mark upon construction (either when using Performance.mark or the PerformanceMark.PerformanceMark constructor).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMark/detail)
+ */
readonly detail: any;
}
declare var PerformanceMark: {
@@ -4468,46 +6624,86 @@
new(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
};
/**
- * PerformanceMeasure is an abstract interface for PerformanceEntry objects with an entryType of "measure". Entries of this type are created by calling performance.measure() to add a named DOMHighResTimeStamp (the measure) between two marks to the browser's performance timeline.
+ * **`PerformanceMeasure`** is an _abstract_ interface for PerformanceEntry objects with an PerformanceEntry.entryType of `'measure'`.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMeasure)
*/
interface PerformanceMeasure extends PerformanceEntry {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMeasure/detail) */
+ /**
+ * The read-only **`detail`** property returns arbitrary metadata that was included in the mark upon construction (when using Performance.measure.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceMeasure/detail)
+ */
readonly detail: any;
}
declare var PerformanceMeasure: {
prototype: PerformanceMeasure;
new(): PerformanceMeasure;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver) */
+/**
+ * The **`PerformanceObserver`** interface is used to observe performance measurement events and be notified of new PerformanceEntry as they are recorded in the browser's _performance timeline_.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver)
+ */
interface PerformanceObserver {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/disconnect) */
+ /**
+ * The **`disconnect()`** method of the PerformanceObserver interface is used to stop the performance observer from receiving any PerformanceEntry events.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/disconnect)
+ */
disconnect(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/observe) */
+ /**
+ * The **`observe()`** method of the **PerformanceObserver** interface is used to specify the set of performance entry types to observe.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/observe)
+ */
observe(options?: PerformanceObserverInit): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/takeRecords) */
+ /**
+ * The **`takeRecords()`** method of the PerformanceObserver interface returns the current list of PerformanceEntry objects stored in the performance observer, emptying it out.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/takeRecords)
+ */
takeRecords(): PerformanceEntryList;
}
declare var PerformanceObserver: {
prototype: PerformanceObserver;
new(callback: PerformanceObserverCallback): PerformanceObserver;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/supportedEntryTypes_static) */
+ /**
+ * The static **`supportedEntryTypes`** read-only property of the PerformanceObserver interface returns an array of the PerformanceEntry.entryType values supported by the user agent.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserver/supportedEntryTypes_static)
+ */
readonly supportedEntryTypes: ReadonlyArray<string>;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList) */
+/**
+ * The **`PerformanceObserverEntryList`** interface is a list of PerformanceEntry that were explicitly observed via the PerformanceObserver.observe method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList)
+ */
interface PerformanceObserverEntryList {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntries) */
+ /**
+ * The **`getEntries()`** method of the PerformanceObserverEntryList interface returns a list of explicitly observed PerformanceEntry objects.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntries)
+ */
getEntries(): PerformanceEntryList;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntriesByName) */
+ /**
+ * The **`getEntriesByName()`** method of the PerformanceObserverEntryList interface returns a list of explicitly observed PerformanceEntry objects for a given PerformanceEntry.name and PerformanceEntry.entryType.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntriesByName)
+ */
getEntriesByName(name: string, type?: string): PerformanceEntryList;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntriesByType) */
+ /**
+ * The **`getEntriesByType()`** method of the PerformanceObserverEntryList returns a list of explicitly _observed_ PerformanceEntry objects for a given PerformanceEntry.entryType.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceObserverEntryList/getEntriesByType)
+ */
getEntriesByType(type: string): PerformanceEntryList;
}
declare var PerformanceObserverEntryList: {
@@ -4515,67 +6711,169 @@
new(): PerformanceObserverEntryList;
};
/**
- * Enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources. An application can use the timing metrics to determine, for example, the length of time it takes to fetch a specific resource, such as an XMLHttpRequest, <SVG>, image, or script.
+ * The **`PerformanceResourceTiming`** interface enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming)
*/
interface PerformanceResourceTiming extends PerformanceEntry {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/connectEnd) */
+ /**
+ * The **`connectEnd`** read-only property returns the DOMHighResTimeStamp immediately after the browser finishes establishing the connection to the server to retrieve the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/connectEnd)
+ */
readonly connectEnd: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/connectStart) */
+ /**
+ * The **`connectStart`** read-only property returns the DOMHighResTimeStamp immediately before the user agent starts establishing the connection to the server to retrieve the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/connectStart)
+ */
readonly connectStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/decodedBodySize) */
+ /**
+ * The **`decodedBodySize`** read-only property returns the size (in octets) received from the fetch (HTTP or cache) of the message body after removing any applied content encoding (like gzip or Brotli).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/decodedBodySize)
+ */
readonly decodedBodySize: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/domainLookupEnd) */
+ /**
+ * The **`domainLookupEnd`** read-only property returns the DOMHighResTimeStamp immediately after the browser finishes the domain-name lookup for the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/domainLookupEnd)
+ */
readonly domainLookupEnd: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/domainLookupStart) */
+ /**
+ * The **`domainLookupStart`** read-only property returns the DOMHighResTimeStamp immediately before the browser starts the domain name lookup for the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/domainLookupStart)
+ */
readonly domainLookupStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/encodedBodySize) */
+ /**
+ * The **`encodedBodySize`** read-only property represents the size (in octets) received from the fetch (HTTP or cache) of the payload body before removing any applied content encodings (like gzip or Brotli).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/encodedBodySize)
+ */
readonly encodedBodySize: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/fetchStart) */
+ /**
+ * The **`fetchStart`** read-only property represents a DOMHighResTimeStamp immediately before the browser starts to fetch the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/fetchStart)
+ */
readonly fetchStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/initiatorType) */
+ /**
+ * The **`initiatorType`** read-only property is a string representing web platform feature that initiated the resource load.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/initiatorType)
+ */
readonly initiatorType: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/nextHopProtocol) */
+ /**
+ * The **`nextHopProtocol`** read-only property is a string representing the network protocol used to fetch the resource, as identified by the ALPN Protocol ID (RFC7301).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/nextHopProtocol)
+ */
readonly nextHopProtocol: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/redirectEnd) */
+ /**
+ * The **`redirectEnd`** read-only property returns a DOMHighResTimeStamp immediately after receiving the last byte of the response of the last redirect.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/redirectEnd)
+ */
readonly redirectEnd: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/redirectStart) */
+ /**
+ * The **`redirectStart`** read-only property returns a DOMHighResTimeStamp representing the start time of the fetch which that initiates the redirect.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/redirectStart)
+ */
readonly redirectStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/requestStart) */
+ /**
+ * The **`requestStart`** read-only property returns a DOMHighResTimeStamp of the time immediately before the browser starts requesting the resource from the server, cache, or local resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/requestStart)
+ */
readonly requestStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseEnd) */
+ /**
+ * The **`responseEnd`** read-only property returns a DOMHighResTimeStamp immediately after the browser receives the last byte of the resource or immediately before the transport connection is closed, whichever comes first.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseEnd)
+ */
readonly responseEnd: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStart) */
+ /**
+ * The **`responseStart`** read-only property returns a DOMHighResTimeStamp immediately after the browser receives the first byte of the response from the server, cache, or local resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStart)
+ */
readonly responseStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/secureConnectionStart) */
+ /**
+ * The **`responseStatus`** read-only property represents the HTTP response status code returned when fetching the resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStatus)
+ */
+ readonly responseStatus: number;
+ /**
+ * The **`secureConnectionStart`** read-only property returns a DOMHighResTimeStamp immediately before the browser starts the handshake process to secure the current connection.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/secureConnectionStart)
+ */
readonly secureConnectionStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/serverTiming) */
+ /**
+ * The **`serverTiming`** read-only property returns an array of PerformanceServerTiming entries containing server timing metrics.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/serverTiming)
+ */
readonly serverTiming: ReadonlyArray<PerformanceServerTiming>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/transferSize) */
+ /**
+ * The **`transferSize`** read-only property represents the size (in octets) of the fetched resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/transferSize)
+ */
readonly transferSize: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/workerStart) */
+ /**
+ * The **`workerStart`** read-only property of the PerformanceResourceTiming interface returns a The `workerStart` property can have the following values: - A DOMHighResTimeStamp.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/workerStart)
+ */
readonly workerStart: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/toJSON) */
+ /**
+ * The **`toJSON()`** method of the PerformanceResourceTiming interface is a Serialization; it returns a JSON representation of the PerformanceResourceTiming object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/toJSON)
+ */
toJSON(): any;
}
declare var PerformanceResourceTiming: {
prototype: PerformanceResourceTiming;
new(): PerformanceResourceTiming;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming) */
+/**
+ * The **`PerformanceServerTiming`** interface surfaces server metrics that are sent with the response in the Server-Timing HTTP header.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming)
+ */
interface PerformanceServerTiming {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/description) */
+ /**
+ * The **`description`** read-only property returns a string value of the server-specified metric description, or an empty string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/description)
+ */
readonly description: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/duration) */
+ /**
+ * The **`duration`** read-only property returns a double that contains the server-specified metric duration, or the value `0.0`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/duration)
+ */
readonly duration: DOMHighResTimeStamp;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/name) */
+ /**
+ * The **`name`** read-only property returns a string value of the server-specified metric name.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/name)
+ */
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/toJSON) */
+ /**
+ * The **`toJSON()`** method of the PerformanceServerTiming interface is a Serialization; it returns a JSON representation of the PerformanceServerTiming object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceServerTiming/toJSON)
+ */
toJSON(): any;
}
declare var PerformanceServerTiming: {
@@ -4586,15 +6884,27 @@
interface PermissionStatusEventMap {
"change": Event;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus) */
+/**
+ * The **`PermissionStatus`** interface of the Permissions API provides the state of an object and an event handler for monitoring changes to said state.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus)
+ */
interface PermissionStatus extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus/name) */
+ /**
+ * The **`name`** read-only property of the PermissionStatus interface returns the name of a requested permission.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus/name)
+ */
readonly name: string;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus/change_event) */
onchange: ((this: PermissionStatus, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus/state) */
+ /**
+ * The **`state`** read-only property of the This property returns one of `'granted'`, `'denied'`, or `'prompt'`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PermissionStatus/state)
+ */
readonly state: PermissionState;
addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -4605,11 +6915,19 @@
prototype: PermissionStatus;
new(): PermissionStatus;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Permissions) */
+/**
+ * The **`Permissions`** interface of the Permissions API provides the core Permission API functionality, such as methods for querying and revoking permissions - Permissions.query - : Returns the user permission status for a given API.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Permissions)
+ */
interface Permissions {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Permissions/query) */
+ /**
+ * The **`query()`** method of the Permissions interface returns the state of a user permission on the global scope.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Permissions/query)
+ */
query(permissionDesc: PermissionDescriptor): Promise<PermissionStatus>;
}
declare var Permissions: {
@@ -4617,32 +6935,56 @@
new(): Permissions;
};
/**
- * 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>).
+ * The **`ProgressEvent`** interface represents events that measure the progress of an underlying process, like an HTTP request (e.g., an `XMLHttpRequest`, or the loading of the underlying resource of an img, audio, video, style or link).
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent)
*/
interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/lengthComputable) */
+ /**
+ * The **`ProgressEvent.lengthComputable`** read-only property is a boolean flag indicating if the resource concerned by the A boolean.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/lengthComputable)
+ */
readonly lengthComputable: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/loaded) */
+ /**
+ * The **`ProgressEvent.loaded`** read-only property is a number indicating the size of the data already transmitted or processed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/loaded)
+ */
readonly loaded: number;
readonly target: T | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/total) */
+ /**
+ * The **`ProgressEvent.total`** read-only property is a number indicating the total size of the data being transmitted or processed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ProgressEvent/total)
+ */
readonly total: number;
}
declare var ProgressEvent: {
prototype: ProgressEvent;
new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent) */
+/**
+ * The **`PromiseRejectionEvent`** interface represents events which are sent to the global script context when JavaScript Promises are rejected.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent)
+ */
interface PromiseRejectionEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/promise) */
+ /**
+ * The PromiseRejectionEvent interface's **`promise`** read-only property indicates the JavaScript rejected.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/promise)
+ */
readonly promise: Promise<any>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/reason) */
+ /**
+ * The PromiseRejectionEvent **`reason`** read-only property is any JavaScript value or Object which provides the reason passed into Promise.reject().
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/reason)
+ */
readonly reason: any;
}
declare var PromiseRejectionEvent: {
@@ -4650,15 +6992,19 @@
new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
};
/**
- * This Push API interface represents a push message that has been received. This event is sent to the global scope of a ServiceWorker. It contains the information sent from an application server to a PushSubscription.
+ * The **`PushEvent`** interface of the Push API represents a push message that has been received.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushEvent)
*/
interface PushEvent extends ExtendableEvent {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushEvent/data) */
+ /**
+ * The `data` read-only property of the **`PushEvent`** interface returns a reference to a PushMessageData object containing data sent to the PushSubscription.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushEvent/data)
+ */
readonly data: PushMessageData | null;
}
declare var PushEvent: {
@@ -4666,43 +7012,81 @@
new(type: string, eventInitDict?: PushEventInit): PushEvent;
};
/**
- * This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
+ * The **`PushManager`** interface of the Push API provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager)
*/
interface PushManager {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/getSubscription) */
+ /**
+ * The **`PushManager.getSubscription()`** method of the PushManager interface retrieves an existing push subscription.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/getSubscription)
+ */
getSubscription(): Promise<PushSubscription | null>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/permissionState) */
+ /**
+ * The **`permissionState()`** method of the string indicating the permission state of the push manager.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/permissionState)
+ */
permissionState(options?: PushSubscriptionOptionsInit): Promise<PermissionState>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/subscribe) */
+ /**
+ * The **`subscribe()`** method of the PushManager interface subscribes to a push service.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/subscribe)
+ */
subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
}
declare var PushManager: {
prototype: PushManager;
new(): PushManager;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/supportedContentEncodings_static) */
+ /**
+ * The **`supportedContentEncodings`** read-only static property of the PushManager interface returns an array of supported content codings that can be used to encrypt the payload of a push message.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushManager/supportedContentEncodings_static)
+ */
readonly supportedContentEncodings: ReadonlyArray<string>;
};
/**
- * This Push API interface provides methods which let you retrieve the push data sent by a server in various formats.
+ * The **`PushMessageData`** interface of the Push API provides methods which let you retrieve the push data sent by a server in various formats.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData)
*/
interface PushMessageData {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/arrayBuffer) */
+ /**
+ * The **`arrayBuffer()`** method of the PushMessageData interface extracts push message data as an ArrayBuffer object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/arrayBuffer)
+ */
arrayBuffer(): ArrayBuffer;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/blob) */
+ /**
+ * The **`blob()`** method of the PushMessageData interface extracts push message data as a Blob object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/blob)
+ */
blob(): Blob;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/json) */
+ /**
+ * The **`bytes()`** method of the PushMessageData interface extracts push message data as an Uint8Array object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/bytes)
+ */
+ bytes(): Uint8Array<ArrayBuffer>;
+ /**
+ * The **`json()`** method of the PushMessageData interface extracts push message data by parsing it as a JSON string and returning the result.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/json)
+ */
json(): any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/text) */
+ /**
+ * The **`text()`** method of the PushMessageData interface extracts push message data as a plain text string.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/text)
+ */
text(): string;
}
declare var PushMessageData: {
@@ -4710,123 +7094,370 @@
new(): PushMessageData;
};
/**
- * This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service.
+ * The `PushSubscription` interface of the Push API provides a subscription's URL endpoint along with the public key and secrets that should be used for encrypting push messages to this subscription.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription)
*/
interface PushSubscription {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/endpoint) */
+ /**
+ * The **`endpoint`** read-only property of the the endpoint associated with the push subscription.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/endpoint)
+ */
readonly endpoint: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/expirationTime) */
+ /**
+ * The **`expirationTime`** read-only property of the of the subscription expiration time associated with the push subscription, if there is one, or `null` otherwise.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/expirationTime)
+ */
readonly expirationTime: EpochTimeStamp | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/options) */
+ /**
+ * The **`options`** read-only property of the PushSubscription interface is an object containing the options used to create the subscription.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/options)
+ */
readonly options: PushSubscriptionOptions;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/getKey) */
+ /**
+ * The `getKey()` method of the PushSubscription interface returns an ArrayBuffer representing a client public key, which can then be sent to a server and used in encrypting push message data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/getKey)
+ */
getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/toJSON) */
+ /**
+ * The `toJSON()` method of the PushSubscription interface is a standard serializer: it returns a JSON representation of the subscription properties, providing a useful shortcut.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/toJSON)
+ */
toJSON(): PushSubscriptionJSON;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/unsubscribe) */
+ /**
+ * The `unsubscribe()` method of the PushSubscription interface returns a Promise that resolves to a boolean value when the current subscription is successfully unsubscribed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscription/unsubscribe)
+ */
unsubscribe(): Promise<boolean>;
}
declare var PushSubscription: {
prototype: PushSubscription;
new(): PushSubscription;
};
+/** Available only in secure contexts. */
+interface PushSubscriptionChangeEvent extends ExtendableEvent {
+ readonly newSubscription: PushSubscription | null;
+ readonly oldSubscription: PushSubscription | null;
+}
+
+declare var PushSubscriptionChangeEvent: {
+ prototype: PushSubscriptionChangeEvent;
+ new(type: string, eventInitDict?: PushSubscriptionChangeEventInit): PushSubscriptionChangeEvent;
+};
+
/**
+ * The **`PushSubscriptionOptions`** interface of the Push API represents the options associated with a push subscription.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscriptionOptions)
*/
interface PushSubscriptionOptions {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscriptionOptions/applicationServerKey) */
+ /**
+ * The **`applicationServerKey`** read-only property of the PushSubscriptionOptions interface contains the public key used by the push server.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscriptionOptions/applicationServerKey)
+ */
readonly applicationServerKey: ArrayBuffer | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscriptionOptions/userVisibleOnly) */
+ /**
+ * The **`userVisibleOnly`** read-only property of the PushSubscriptionOptions interface indicates if the returned push subscription will only be used for messages whose effect is made visible to the user.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushSubscriptionOptions/userVisibleOnly)
+ */
readonly userVisibleOnly: boolean;
}
declare var PushSubscriptionOptions: {
prototype: PushSubscriptionOptions;
new(): PushSubscriptionOptions;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame) */
+interface RTCDataChannelEventMap {
+ "bufferedamountlow": Event;
+ "close": Event;
+ "closing": Event;
+ "error": Event;
+ "message": MessageEvent;
+ "open": Event;
+}
+
+/**
+ * The **`RTCDataChannel`** interface represents a network channel which can be used for bidirectional peer-to-peer transfers of arbitrary data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel)
+ */
+interface RTCDataChannel extends EventTarget {
+ /**
+ * The property **`binaryType`** on the the type of object which should be used to represent binary data received on the RTCDataChannel.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/binaryType)
+ */
+ binaryType: BinaryType;
+ /**
+ * The read-only `RTCDataChannel` property **`bufferedAmount`** returns the number of bytes of data currently queued to be sent over the data channel.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/bufferedAmount)
+ */
+ readonly bufferedAmount: number;
+ /**
+ * The `RTCDataChannel` property **`bufferedAmountLowThreshold`** is used to specify the number of bytes of buffered outgoing data that is considered 'low.' The default value is 0\.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/bufferedAmountLowThreshold)
+ */
+ bufferedAmountLowThreshold: number;
+ /**
+ * The read-only `RTCDataChannel` property **`id`** returns an ID number (between 0 and 65,534) which uniquely identifies the RTCDataChannel.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/id)
+ */
+ readonly id: number | null;
+ /**
+ * The read-only `RTCDataChannel` property **`label`** returns a string containing a name describing the data channel.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/label)
+ */
+ readonly label: string;
+ /**
+ * The read-only `RTCDataChannel` property **`maxPacketLifeTime`** returns the amount of time, in milliseconds, the browser is allowed to take to attempt to transmit a message, as set when the data channel was created, or `null`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/maxPacketLifeTime)
+ */
+ readonly maxPacketLifeTime: number | null;
+ /**
+ * The read-only `RTCDataChannel` property **`maxRetransmits`** returns the maximum number of times the browser should try to retransmit a message before giving up, as set when the data channel was created, or `null`, which indicates that there is no maximum.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/maxRetransmits)
+ */
+ readonly maxRetransmits: number | null;
+ /**
+ * The read-only `RTCDataChannel` property **`negotiated`** indicates whether the (`true`) or by the WebRTC layer (`false`).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/negotiated)
+ */
+ readonly negotiated: boolean;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/bufferedamountlow_event) */
+ onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/close_event) */
+ onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/closing_event) */
+ onclosing: ((this: RTCDataChannel, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/error_event) */
+ onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/message_event) */
+ onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/open_event) */
+ onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
+ /**
+ * The read-only `RTCDataChannel` property **`ordered`** indicates whether or not the data channel guarantees in-order delivery of messages; the default is `true`, which indicates that the data channel is indeed ordered.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/ordered)
+ */
+ readonly ordered: boolean;
+ /**
+ * The read-only `RTCDataChannel` property **`protocol`** returns a string containing the name of the subprotocol in use.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/protocol)
+ */
+ readonly protocol: string;
+ /**
+ * The read-only `RTCDataChannel` property **`readyState`** returns a string which indicates the state of the data channel's underlying data connection.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/readyState)
+ */
+ readonly readyState: RTCDataChannelState;
+ /**
+ * The **`RTCDataChannel.close()`** method closes the closure of the channel.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/close)
+ */
+ close(): void;
+ /**
+ * The **`send()`** method of the remote peer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send)
+ */
+ send(data: string): void;
+ send(data: Blob): void;
+ send(data: ArrayBuffer): void;
+ send(data: ArrayBufferView<ArrayBuffer>): void;
+ addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+ addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+ removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare var RTCDataChannel: {
+ prototype: RTCDataChannel;
+ new(): RTCDataChannel;
+};
+
+/**
+ * The **`RTCEncodedAudioFrame`** of the WebRTC API represents an encoded audio frame in the WebRTC receiver or sender pipeline, which may be modified using a WebRTC Encoded Transform.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame)
+ */
interface RTCEncodedAudioFrame {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame/data) */
+ /**
+ * The **`data`** property of the RTCEncodedAudioFrame interface returns a buffer containing the data for an encoded frame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame/data)
+ */
data: ArrayBuffer;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame/timestamp) */
readonly timestamp: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame/getMetadata) */
+ /**
+ * The **`getMetadata()`** method of the RTCEncodedAudioFrame interface returns an object containing the metadata associated with the frame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedAudioFrame/getMetadata)
+ */
getMetadata(): RTCEncodedAudioFrameMetadata;
}
declare var RTCEncodedAudioFrame: {
prototype: RTCEncodedAudioFrame;
new(): RTCEncodedAudioFrame;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame) */
+/**
+ * The **`RTCEncodedVideoFrame`** of the WebRTC API represents an encoded video frame in the WebRTC receiver or sender pipeline, which may be modified using a WebRTC Encoded Transform.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame)
+ */
interface RTCEncodedVideoFrame {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/data) */
+ /**
+ * The **`data`** property of the RTCEncodedVideoFrame interface returns a buffer containing the frame data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/data)
+ */
data: ArrayBuffer;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/timestamp) */
readonly timestamp: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/type) */
+ /**
+ * The **`type`** read-only property of the RTCEncodedVideoFrame interface indicates whether this frame is a key frame, delta frame, or empty frame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/type)
+ */
readonly type: RTCEncodedVideoFrameType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/getMetadata) */
+ /**
+ * The **`getMetadata()`** method of the RTCEncodedVideoFrame interface returns an object containing the metadata associated with the frame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCEncodedVideoFrame/getMetadata)
+ */
getMetadata(): RTCEncodedVideoFrameMetadata;
}
declare var RTCEncodedVideoFrame: {
prototype: RTCEncodedVideoFrame;
new(): RTCEncodedVideoFrame;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer) */
+/**
+ * The **`RTCRtpScriptTransformer`** interface of the WebRTC API provides a worker-side Stream API interface that a WebRTC Encoded Transform can use to modify encoded media frames in the incoming and outgoing WebRTC pipelines.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer)
+ */
interface RTCRtpScriptTransformer extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/options) */
+ /**
+ * The **`options`** read-only property of the RTCRtpScriptTransformer interface returns the object that was (optionally) passed as the second argument during construction of the corresponding RTCRtpScriptTransform.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/options)
+ */
readonly options: any;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/readable) */
+ /**
+ * The **`readable`** read-only property of the RTCRtpScriptTransformer interface returns a ReadableStream instance is a source for encoded media frames.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/readable)
+ */
readonly readable: ReadableStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/writable) */
+ /**
+ * The **`writable`** read-only property of the RTCRtpScriptTransformer interface returns a WritableStream instance that can be used as a sink for encoded media frames enqueued on the corresponding RTCRtpScriptTransformer.readable.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/writable)
+ */
readonly writable: WritableStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/generateKeyFrame) */
+ /**
+ * The **`generateKeyFrame()`** method of the RTCRtpScriptTransformer interface causes a video encoder to generate a key frame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/generateKeyFrame)
+ */
generateKeyFrame(rid?: string): Promise<number>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/sendKeyFrameRequest) */
+ /**
+ * The **`sendKeyFrameRequest()`** method of the RTCRtpScriptTransformer interface may be called by a WebRTC Encoded Transform that is processing incoming encoded video frames, in order to request a key frame from the sender.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCRtpScriptTransformer/sendKeyFrameRequest)
+ */
sendKeyFrameRequest(): Promise<void>;
}
declare var RTCRtpScriptTransformer: {
prototype: RTCRtpScriptTransformer;
new(): RTCRtpScriptTransformer;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCTransformEvent) */
+/**
+ * The **`RTCTransformEvent`** of the WebRTC API represent an event that is fired in a dedicated worker when an encoded frame has been queued for processing by a WebRTC Encoded Transform.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCTransformEvent)
+ */
interface RTCTransformEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCTransformEvent/transformer) */
+ /**
+ * The read-only **`transformer`** property of the RTCTransformEvent interface returns the RTCRtpScriptTransformer associated with the event.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCTransformEvent/transformer)
+ */
readonly transformer: RTCRtpScriptTransformer;
}
declare var RTCTransformEvent: {
prototype: RTCTransformEvent;
new(): RTCTransformEvent;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController) */
+/**
+ * The **`ReadableByteStreamController`** interface of the Streams API represents a controller for a readable byte stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController)
+ */
interface ReadableByteStreamController {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/byobRequest) */
+ /**
+ * The **`byobRequest`** read-only property of the ReadableByteStreamController interface returns the current BYOB request, or `null` if there are no pending requests.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/byobRequest)
+ */
readonly byobRequest: ReadableStreamBYOBRequest | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/desiredSize) */
+ /**
+ * The **`desiredSize`** read-only property of the ReadableByteStreamController interface returns the number of bytes required to fill the stream's internal queue to its 'desired size'.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/desiredSize)
+ */
readonly desiredSize: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/close) */
+ /**
+ * The **`close()`** method of the ReadableByteStreamController interface closes the associated stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/close)
+ */
close(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/enqueue) */
- enqueue(chunk: ArrayBufferView): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/error) */
+ /**
+ * The **`enqueue()`** method of the ReadableByteStreamController interface enqueues a given chunk on the associated readable byte stream (the chunk is copied into the stream's internal queues).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/enqueue)
+ */
+ enqueue(chunk: ArrayBufferView<ArrayBuffer>): void;
+ /**
+ * The **`error()`** method of the ReadableByteStreamController interface causes any future interactions with the associated stream to error with the specified reason.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/error)
+ */
error(e?: any): void;
}
declare var ReadableByteStreamController: {
@@ -4834,86 +7465,170 @@
new(): ReadableByteStreamController;
};
/**
- * 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.
+ * The `ReadableStream` interface of the Streams API represents a readable stream of byte data.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream)
*/
interface ReadableStream<R = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/locked) */
+ /**
+ * The **`locked`** read-only property of the ReadableStream interface returns whether or not the readable stream is locked to a reader.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/locked)
+ */
readonly locked: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel) */
+ /**
+ * The **`cancel()`** method of the ReadableStream interface returns a Promise that resolves when the stream is canceled.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel)
+ */
cancel(reason?: any): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader) */
+ /**
+ * The **`getReader()`** method of the ReadableStream interface creates a reader and locks the stream to it.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader)
+ */
getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
getReader(): ReadableStreamDefaultReader<R>;
getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeThrough) */
+ /**
+ * The **`pipeThrough()`** method of the ReadableStream interface provides a chainable way of piping the current stream through a transform stream or any other writable/readable pair.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeThrough)
+ */
pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeTo) */
+ /**
+ * The **`pipeTo()`** method of the ReadableStream interface pipes the current `ReadableStream` to a given WritableStream and returns a Promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeTo)
+ */
pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee) */
+ /**
+ * The **`tee()`** method of the two-element array containing the two resulting branches as new ReadableStream instances.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee)
+ */
tee(): [ReadableStream<R>, ReadableStream<R>];
}
declare var ReadableStream: {
prototype: ReadableStream;
- new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream<Uint8Array>;
+ new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream<Uint8Array<ArrayBuffer>>;
new<R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */
+/**
+ * The `ReadableStreamBYOBReader` interface of the Streams API defines a reader for a ReadableStream that supports zero-copy reading from an underlying byte source.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader)
+ */
interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */
+ /**
+ * The **`read()`** method of the ReadableStreamBYOBReader interface is used to read data into a view on a user-supplied buffer from an associated readable byte stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read)
+ */
read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */
+ /**
+ * The **`releaseLock()`** method of the ReadableStreamBYOBReader interface releases the reader's lock on the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock)
+ */
releaseLock(): void;
}
declare var ReadableStreamBYOBReader: {
prototype: ReadableStreamBYOBReader;
- new(stream: ReadableStream): ReadableStreamBYOBReader;
+ new(stream: ReadableStream<Uint8Array<ArrayBuffer>>): ReadableStreamBYOBReader;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */
+/**
+ * The **`ReadableStreamBYOBRequest`** interface of the Streams API represents a 'pull request' for data from an underlying source that will made as a zero-copy transfer to a consumer (bypassing the stream's internal queues).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest)
+ */
interface ReadableStreamBYOBRequest {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */
- readonly view: ArrayBufferView | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */
+ /**
+ * The **`view`** getter property of the ReadableStreamBYOBRequest interface returns the current view.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view)
+ */
+ readonly view: ArrayBufferView<ArrayBuffer> | null;
+ /**
+ * The **`respond()`** method of the ReadableStreamBYOBRequest interface is used to signal to the associated readable byte stream that the specified number of bytes were written into the ReadableStreamBYOBRequest.view.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond)
+ */
respond(bytesWritten: number): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */
- respondWithNewView(view: ArrayBufferView): void;
+ /**
+ * The **`respondWithNewView()`** method of the ReadableStreamBYOBRequest interface specifies a new view that the consumer of the associated readable byte stream should write to instead of ReadableStreamBYOBRequest.view.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView)
+ */
+ respondWithNewView(view: ArrayBufferView<ArrayBuffer>): void;
}
declare var ReadableStreamBYOBRequest: {
prototype: ReadableStreamBYOBRequest;
new(): ReadableStreamBYOBRequest;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController) */
+/**
+ * The **`ReadableStreamDefaultController`** interface of the Streams API represents a controller allowing control of a ReadableStream's state and internal queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController)
+ */
interface ReadableStreamDefaultController<R = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/desiredSize) */
+ /**
+ * The **`desiredSize`** read-only property of the required to fill the stream's internal queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/desiredSize)
+ */
readonly desiredSize: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/close) */
+ /**
+ * The **`close()`** method of the ReadableStreamDefaultController interface closes the associated stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/close)
+ */
close(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/enqueue) */
+ /**
+ * The **`enqueue()`** method of the ```js-nolint enqueue(chunk) ``` - `chunk` - : The chunk to enqueue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/enqueue)
+ */
enqueue(chunk?: R): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/error) */
+ /**
+ * The **`error()`** method of the with the associated stream to error.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/error)
+ */
error(e?: any): void;
}
declare var ReadableStreamDefaultController: {
prototype: ReadableStreamDefaultController;
new(): ReadableStreamDefaultController;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader) */
+/**
+ * The **`ReadableStreamDefaultReader`** interface of the Streams API represents a default reader that can be used to read stream data supplied from a network (such as a fetch request).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader)
+ */
interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/read) */
+ /**
+ * The **`read()`** method of the ReadableStreamDefaultReader interface returns a Promise providing access to the next chunk in the stream's internal queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/read)
+ */
read(): Promise<ReadableStreamReadResult<R>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/releaseLock) */
+ /**
+ * The **`releaseLock()`** method of the ReadableStreamDefaultReader interface releases the reader's lock on the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/releaseLock)
+ */
releaseLock(): void;
}
declare var ReadableStreamDefaultReader: {
@@ -4922,20 +7637,36 @@
};
interface ReadableStreamGenericReader {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/closed) */
- readonly closed: Promise<undefined>;
+ readonly closed: Promise<void>;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/cancel) */
cancel(reason?: any): Promise<void>;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report) */
+/**
+ * The `Report` interface of the Reporting API represents a single report.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report)
+ */
interface Report {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/body) */
+ /**
+ * The **`body`** read-only property of the Report interface returns the body of the report, which is a `ReportBody` object containing the detailed report information.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/body)
+ */
readonly body: ReportBody | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/type) */
+ /**
+ * The **`type`** read-only property of the Report interface returns the type of report generated, e.g., `deprecation` or `intervention`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/type)
+ */
readonly type: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/url) */
+ /**
+ * The **`url`** read-only property of the Report interface returns the URL of the document that generated the report.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Report/url)
+ */
readonly url: string;
toJSON(): any;
}
@@ -4943,25 +7674,50 @@
prototype: Report;
new(): Report;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportBody) */
+/**
+ * The **`ReportBody`** interface of the Reporting API represents the body of a report.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportBody)
+ */
interface ReportBody {
+ /**
+ * The **`toJSON()`** method of the ReportBody interface is a _serializer_, and returns a JSON representation of the `ReportBody` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportBody/toJSON)
+ */
toJSON(): any;
}
declare var ReportBody: {
prototype: ReportBody;
new(): ReportBody;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver) */
+/**
+ * The `ReportingObserver` interface of the Reporting API allows you to collect and access reports.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver)
+ */
interface ReportingObserver {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/disconnect) */
+ /**
+ * The **`disconnect()`** method of the previously started observing from collecting reports.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/disconnect)
+ */
disconnect(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/observe) */
+ /**
+ * The **`observe()`** method of the collecting reports in its report queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/observe)
+ */
observe(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/takeRecords) */
+ /**
+ * The **`takeRecords()`** method of the in the observer's report queue, and empties the queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReportingObserver/takeRecords)
+ */
takeRecords(): ReportList;
}
declare var ReportingObserver: {
@@ -4969,92 +7725,96 @@
new(callback: ReportingObserverCallback, options?: ReportingObserverOptions): ReportingObserver;
};
/**
- * This Fetch API interface represents a resource request.
+ * The **`Request`** interface of the Fetch API represents a resource request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request)
*/
interface Request extends Body {
/**
- * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
+ * The **`cache`** read-only property of the Request interface contains the cache mode of the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/cache)
*/
readonly cache: RequestCache;
/**
- * Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL.
+ * The **`credentials`** read-only property of the Request interface reflects the value given to the Request.Request() constructor in the `credentials` option.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/credentials)
*/
readonly credentials: RequestCredentials;
/**
- * Returns the kind of resource requested by request, e.g., "document" or "script".
+ * The **`destination`** read-only property of the **Request** interface returns a string describing the type of content being requested.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/destination)
*/
readonly destination: RequestDestination;
/**
- * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
+ * The **`headers`** read-only property of the with the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/headers)
*/
readonly headers: Headers;
/**
- * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
+ * The **`integrity`** read-only property of the Request interface contains the subresource integrity value of the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/integrity)
*/
readonly integrity: string;
/**
- * Returns a boolean indicating whether or not request can outlive the global in which it was created.
+ * The **`keepalive`** read-only property of the Request interface contains the request's `keepalive` setting (`true` or `false`), which indicates whether the browser will keep the associated request alive if the page that initiated it is unloaded before the request is complete.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/keepalive)
*/
readonly keepalive: boolean;
/**
- * Returns request's HTTP method, which is "GET" by default.
+ * The **`method`** read-only property of the `POST`, etc.) A String indicating the method of the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/method)
*/
readonly method: string;
/**
- * Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs.
+ * The **`mode`** read-only property of the Request interface contains the mode of the request (e.g., `cors`, `no-cors`, `same-origin`, or `navigate`.) This is used to determine if cross-origin requests lead to valid responses, and which properties of the response are readable.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/mode)
*/
readonly mode: RequestMode;
/**
- * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
+ * The **`redirect`** read-only property of the Request interface contains the mode for how redirects are handled.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/redirect)
*/
readonly redirect: RequestRedirect;
/**
- * Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default. This is used during fetching to determine the value of the `Referer` header of the request being made.
+ * The **`referrer`** read-only property of the Request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/referrer)
*/
readonly referrer: string;
/**
- * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
+ * The **`referrerPolicy`** read-only property of the referrer information, sent in the Referer header, should be included with the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/referrerPolicy)
*/
readonly referrerPolicy: ReferrerPolicy;
/**
- * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
+ * The read-only **`signal`** property of the Request interface returns the AbortSignal associated with the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/signal)
*/
readonly signal: AbortSignal;
/**
- * Returns the URL of request as a string.
+ * The **`url`** read-only property of the Request interface contains the URL of the request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/url)
*/
readonly url: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/clone) */
+ /**
+ * The **`clone()`** method of the Request interface creates a copy of the current `Request` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/clone)
+ */
clone(): Request;
}
declare var Request: {
@@ -5062,71 +7822,163 @@
new(input: RequestInfo | URL, init?: RequestInit): Request;
};
/**
- * This Fetch API interface represents the response to a request.
+ * The **`Response`** interface of the Fetch API represents the response to a request.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response)
*/
interface Response extends Body {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/headers) */
+ /**
+ * The **`headers`** read-only property of the with the response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/headers)
+ */
readonly headers: Headers;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/ok) */
+ /**
+ * The **`ok`** read-only property of the Response interface contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/ok)
+ */
readonly ok: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirected) */
+ /**
+ * The **`redirected`** read-only property of the Response interface indicates whether or not the response is the result of a request you made which was redirected.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirected)
+ */
readonly redirected: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status) */
+ /**
+ * The **`status`** read-only property of the Response interface contains the HTTP status codes of the response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)
+ */
readonly status: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText) */
+ /**
+ * The **`statusText`** read-only property of the Response interface contains the status message corresponding to the HTTP status code in Response.status.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText)
+ */
readonly statusText: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/type) */
+ /**
+ * The **`type`** read-only property of the Response interface contains the type of the response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/type)
+ */
readonly type: ResponseType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/url) */
+ /**
+ * The **`url`** read-only property of the Response interface contains the URL of the response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/url)
+ */
readonly url: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/clone) */
+ /**
+ * The **`clone()`** method of the Response interface creates a clone of a response object, identical in every way, but stored in a different variable.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/clone)
+ */
clone(): Response;
}
declare var Response: {
prototype: Response;
new(body?: BodyInit | null, init?: ResponseInit): Response;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/error_static) */
+ /**
+ * The **`error()`** static method of the Response interface returns a new `Response` object associated with a network error.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/error_static)
+ */
error(): Response;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/json_static) */
+ /**
+ * The **`json()`** static method of the Response interface returns a `Response` that contains the provided JSON data as body, and a Content-Type header which is set to `application/json`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/json_static)
+ */
json(data: any, init?: ResponseInit): Response;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirect_static) */
+ /**
+ * The **`redirect()`** static method of the Response interface returns a `Response` resulting in a redirect to the specified URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirect_static)
+ */
redirect(url: string | URL, status?: number): Response;
};
/**
- * Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated.
+ * The **`SecurityPolicyViolationEvent`** interface inherits from Event, and represents the event object of a `securitypolicyviolation` event sent on an Element/securitypolicyviolation_event, Document/securitypolicyviolation_event, or WorkerGlobalScope/securitypolicyviolation_event when its Content Security Policy (CSP) is violated.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent)
*/
interface SecurityPolicyViolationEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/blockedURI) */
+ /**
+ * The **`blockedURI`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the URI of the resource that was blocked because it violates a Content Security Policy (CSP).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/blockedURI)
+ */
readonly blockedURI: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/columnNumber) */
+ /**
+ * The **`columnNumber`** read-only property of the SecurityPolicyViolationEvent interface is the column number in the document or worker script at which the Content Security Policy (CSP) violation occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/columnNumber)
+ */
readonly columnNumber: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/disposition) */
+ /**
+ * The **`disposition`** read-only property of the SecurityPolicyViolationEvent interface indicates how the violated Content Security Policy (CSP) is configured to be treated by the user agent.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/disposition)
+ */
readonly disposition: SecurityPolicyViolationEventDisposition;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/documentURI) */
+ /**
+ * The **`documentURI`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the URI of the document or worker in which the Content Security Policy (CSP) violation occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/documentURI)
+ */
readonly documentURI: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/effectiveDirective) */
+ /**
+ * The **`effectiveDirective`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the Content Security Policy (CSP) directive that was violated.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/effectiveDirective)
+ */
readonly effectiveDirective: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/lineNumber) */
+ /**
+ * The **`lineNumber`** read-only property of the SecurityPolicyViolationEvent interface is the line number in the document or worker script at which the Content Security Policy (CSP) violation occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/lineNumber)
+ */
readonly lineNumber: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/originalPolicy) */
+ /**
+ * The **`originalPolicy`** read-only property of the SecurityPolicyViolationEvent interface is a string containing the Content Security Policy (CSP) whose enforcement uncovered the violation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/originalPolicy)
+ */
readonly originalPolicy: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/referrer) */
+ /**
+ * The **`referrer`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the referrer for the resources whose Content Security Policy (CSP) was violated.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/referrer)
+ */
readonly referrer: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/sample) */
+ /**
+ * The **`sample`** read-only property of the SecurityPolicyViolationEvent interface is a string representing a sample of the resource that caused the Content Security Policy (CSP) violation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/sample)
+ */
readonly sample: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/sourceFile) */
+ /**
+ * The **`sourceFile`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the URL of the script in which the Content Security Policy (CSP) violation occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/sourceFile)
+ */
readonly sourceFile: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/statusCode) */
+ /**
+ * The **`statusCode`** read-only property of the SecurityPolicyViolationEvent interface is a number representing the HTTP status code of the window or worker in which the Content Security Policy (CSP) violation occurred.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/statusCode)
+ */
readonly statusCode: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/violatedDirective) */
+ /**
+ * The **`violatedDirective`** read-only property of the SecurityPolicyViolationEvent interface is a string representing the Content Security Policy (CSP) directive that was violated.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SecurityPolicyViolationEvent/violatedDirective)
+ */
readonly violatedDirective: string;
}
declare var SecurityPolicyViolationEvent: {
@@ -5138,21 +7990,33 @@
"statechange": Event;
}
/**
- * This ServiceWorker API interface provides a reference to a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same service worker, each through a unique ServiceWorker object.
+ * The **`ServiceWorker`** interface of the Service Worker API provides a reference to a service worker.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker)
*/
interface ServiceWorker extends EventTarget, AbstractWorker {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/statechange_event) */
onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/scriptURL) */
+ /**
+ * Returns the `ServiceWorker` serialized script URL defined as part of `ServiceWorkerRegistration`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/scriptURL)
+ */
readonly scriptURL: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/state) */
+ /**
+ * The **`state`** read-only property of the of the service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/state)
+ */
readonly state: ServiceWorkerState;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/postMessage) */
+ /**
+ * The **`postMessage()`** method of the ServiceWorker interface sends a message to the worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/postMessage)
+ */
postMessage(message: any, transfer: Transferable[]): void;
postMessage(message: any, options?: StructuredSerializeOptions): void;
addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
@@ -5171,31 +8035,55 @@
"messageerror": MessageEvent;
}
/**
- * The ServiceWorkerContainer interface of the ServiceWorker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.
+ * The **`ServiceWorkerContainer`** interface of the Service Worker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer)
*/
interface ServiceWorkerContainer extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/controller) */
+ /**
+ * The **`controller`** read-only property of the ServiceWorkerContainer interface returns a `activated` (the same object returned by `null` if the request is a force refresh (_Shift_ + refresh) or if there is no active worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/controller)
+ */
readonly controller: ServiceWorker | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/controllerchange_event) */
oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/message_event) */
onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/messageerror_event) */
onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/ready) */
+ /**
+ * The **`ready`** read-only property of the ServiceWorkerContainer interface provides a way of delaying code execution until a service worker is active.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/ready)
+ */
readonly ready: Promise<ServiceWorkerRegistration>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/getRegistration) */
+ /**
+ * The **`getRegistration()`** method of the client URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/getRegistration)
+ */
getRegistration(clientURL?: string | URL): Promise<ServiceWorkerRegistration | undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/getRegistrations) */
+ /**
+ * The **`getRegistrations()`** method of the `ServiceWorkerContainer`, in an array.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/getRegistrations)
+ */
getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/register) */
+ /**
+ * The **`register()`** method of the ServiceWorkerContainer interface creates or updates a ServiceWorkerRegistration for the given scope.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/register)
+ */
register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/startMessages) */
+ /**
+ * The **`startMessages()`** method of the ServiceWorkerContainer interface explicitly starts the flow of messages being dispatched from a service worker to pages under its control (e.g., sent via Client.postMessage()).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerContainer/startMessages)
+ */
startMessages(): void;
addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -5208,28 +8096,42 @@
};
interface ServiceWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
"activate": ExtendableEvent;
+ "cookiechange": ExtendableCookieChangeEvent;
"fetch": FetchEvent;
"install": ExtendableEvent;
"message": ExtendableMessageEvent;
"messageerror": MessageEvent;
"notificationclick": NotificationEvent;
"notificationclose": NotificationEvent;
"push": PushEvent;
- "pushsubscriptionchange": Event;
+ "pushsubscriptionchange": PushSubscriptionChangeEvent;
}
/**
- * This ServiceWorker API interface represents the global execution context of a service worker.
+ * The **`ServiceWorkerGlobalScope`** interface of the Service Worker API represents the global execution context of a service worker.
+ * Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope)
*/
interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/clients) */
+ /**
+ * The **`clients`** read-only property of the object associated with the service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/clients)
+ */
readonly clients: Clients;
+ /**
+ * The **`cookieStore`** read-only property of the ServiceWorkerGlobalScope interface returns a reference to the CookieStore object associated with this service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/cookieStore)
+ */
+ readonly cookieStore: CookieStore;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/activate_event) */
onactivate: ((this: ServiceWorkerGlobalScope, ev: ExtendableEvent) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/cookiechange_event) */
+ oncookiechange: ((this: ServiceWorkerGlobalScope, ev: ExtendableCookieChangeEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/fetch_event) */
onfetch: ((this: ServiceWorkerGlobalScope, ev: FetchEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/install_event) */
oninstall: ((this: ServiceWorkerGlobalScope, ev: ExtendableEvent) => any) | null;
@@ -5243,14 +8145,26 @@
onnotificationclose: ((this: ServiceWorkerGlobalScope, ev: NotificationEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/push_event) */
onpush: ((this: ServiceWorkerGlobalScope, ev: PushEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/pushsubscriptionchange_event) */
- onpushsubscriptionchange: ((this: ServiceWorkerGlobalScope, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/registration) */
+ onpushsubscriptionchange: ((this: ServiceWorkerGlobalScope, ev: PushSubscriptionChangeEvent) => any) | null;
+ /**
+ * The **`registration`** read-only property of the ServiceWorkerGlobalScope interface returns a reference to the ServiceWorkerRegistration object, which represents the service worker's registration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/registration)
+ */
readonly registration: ServiceWorkerRegistration;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/serviceWorker) */
+ /**
+ * The **`serviceWorker`** read-only property of the ServiceWorkerGlobalScope interface returns a reference to the ServiceWorker object, which represents the service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/serviceWorker)
+ */
readonly serviceWorker: ServiceWorker;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting) */
+ /**
+ * The **`skipWaiting()`** method of the ServiceWorkerGlobalScope interface forces the waiting service worker to become the active service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting)
+ */
skipWaiting(): Promise<void>;
addEventListener<K extends keyof ServiceWorkerGlobalScopeEventMap>(type: K, listener: (this: ServiceWorkerGlobalScope, ev: ServiceWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof ServiceWorkerGlobalScopeEventMap>(type: K, listener: (this: ServiceWorkerGlobalScope, ev: ServiceWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -5266,38 +8180,88 @@
"updatefound": Event;
}
/**
- * This ServiceWorker API interface represents the service worker registration. You register a service worker to control one or more pages that share the same origin.
+ * The **`ServiceWorkerRegistration`** interface of the Service Worker API represents the service worker registration.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration)
*/
interface ServiceWorkerRegistration extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/active) */
+ /**
+ * The **`active`** read-only property of the This property is initially set to `null`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/active)
+ */
readonly active: ServiceWorker | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/installing) */
+ /**
+ * The **`cookies`** read-only property of the ServiceWorkerRegistration interface returns a reference to the CookieStoreManager interface, which enables a web app to subscribe to and unsubscribe from cookie change events in a service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/cookies)
+ */
+ readonly cookies: CookieStoreManager;
+ /**
+ * The **`installing`** read-only property of the initially set to `null`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/installing)
+ */
readonly installing: ServiceWorker | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/navigationPreload) */
+ /**
+ * The **`navigationPreload`** read-only property of the ServiceWorkerRegistration interface returns the NavigationPreloadManager associated with the current service worker registration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/navigationPreload)
+ */
readonly navigationPreload: NavigationPreloadManager;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/updatefound_event) */
onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/pushManager) */
+ /**
+ * The **`pushManager`** read-only property of the support for subscribing, getting an active subscription, and accessing push permission status.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/pushManager)
+ */
readonly pushManager: PushManager;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/scope) */
+ /**
+ * The **`scope`** read-only property of the ServiceWorkerRegistration interface returns a string representing a URL that defines a service worker's registration scope; that is, the range of URLs a service worker can control.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/scope)
+ */
readonly scope: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/updateViaCache) */
+ /**
+ * The **`updateViaCache`** read-only property of the ServiceWorkerRegistration interface returns the value of the setting used to determine the circumstances in which the browser will consult the HTTP cache when it tries to update the service worker or any scripts that are imported via WorkerGlobalScope.importScripts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/updateViaCache)
+ */
readonly updateViaCache: ServiceWorkerUpdateViaCache;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/waiting) */
+ /**
+ * The **`waiting`** read-only property of the set to `null`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/waiting)
+ */
readonly waiting: ServiceWorker | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/getNotifications) */
+ /**
+ * The **`getNotifications()`** method of the ServiceWorkerRegistration interface returns a list of the notifications in the order that they were created from the current origin via the current service worker registration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/getNotifications)
+ */
getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/showNotification) */
+ /**
+ * The **`showNotification()`** method of the service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/showNotification)
+ */
showNotification(title: string, options?: NotificationOptions): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/unregister) */
+ /**
+ * The **`unregister()`** method of the registration and returns a Promise.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/unregister)
+ */
unregister(): Promise<boolean>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/update) */
- update(): Promise<void>;
+ /**
+ * The **`update()`** method of the worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerRegistration/update)
+ */
+ update(): Promise<ServiceWorkerRegistration>;
addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
@@ -5311,20 +8275,24 @@
interface SharedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
"connect": MessageEvent;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SharedWorkerGlobalScope) */
+/**
+ * The **`SharedWorkerGlobalScope`** object (the SharedWorker global scope) is accessible through the window.self keyword.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SharedWorkerGlobalScope)
+ */
interface SharedWorkerGlobalScope extends WorkerGlobalScope {
/**
- * Returns sharedWorkerGlobal's name, i.e. the value given to the SharedWorker constructor. Multiple SharedWorker objects can correspond to the same shared worker (and SharedWorkerGlobalScope), by reusing the same name.
+ * The **`name`** read-only property of the that the SharedWorker.SharedWorker constructor can pass to get a reference to the SharedWorkerGlobalScope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SharedWorkerGlobalScope/name)
*/
readonly name: string;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SharedWorkerGlobalScope/connect_event) */
onconnect: ((this: SharedWorkerGlobalScope, ev: MessageEvent) => any) | null;
/**
- * Aborts sharedWorkerGlobal.
+ * The **`close()`** method of the SharedWorkerGlobalScope interface discards any tasks queued in the `SharedWorkerGlobalScope`'s event loop, effectively closing this particular scope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SharedWorkerGlobalScope/close)
*/
close(): void;
@@ -5339,35 +8307,68 @@
new(): SharedWorkerGlobalScope;
};
/**
+ * The **`StorageManager`** interface of the Storage API provides an interface for managing persistence permissions and estimating available storage.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager)
*/
interface StorageManager {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/estimate) */
+ /**
+ * The **`estimate()`** method of the StorageManager interface asks the Storage Manager for how much storage the current origin takes up (`usage`), and how much space is available (`quota`).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/estimate)
+ */
estimate(): Promise<StorageEstimate>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/getDirectory) */
+ /**
+ * The **`getDirectory()`** method of the StorageManager interface is used to obtain a reference to a FileSystemDirectoryHandle object allowing access to a directory and its contents, stored in the origin private file system (OPFS).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/getDirectory)
+ */
getDirectory(): Promise<FileSystemDirectoryHandle>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/persisted) */
+ /**
+ * The **`persisted()`** method of the StorageManager interface returns a Promise that resolves to `true` if your site's storage bucket is persistent.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StorageManager/persisted)
+ */
persisted(): Promise<boolean>;
}
declare var StorageManager: {
prototype: StorageManager;
new(): StorageManager;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly) */
+/**
+ * The **`StylePropertyMapReadOnly`** interface of the CSS Typed Object Model API provides a read-only representation of a CSS declaration block that is an alternative to CSSStyleDeclaration.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly)
+ */
interface StylePropertyMapReadOnly {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/size) */
+ /**
+ * The **`size`** read-only property of the containing the size of the `StylePropertyMapReadOnly` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/size)
+ */
readonly size: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/get) */
+ /**
+ * The **`get()`** method of the object for the first value of the specified property.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/get)
+ */
get(property: string): undefined | CSSStyleValue;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/getAll) */
+ /**
+ * The **`getAll()`** method of the ```js-nolint getAll(property) ``` - `property` - : The name of the property to retrieve all values of.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/getAll)
+ */
getAll(property: string): CSSStyleValue[];
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/has) */
+ /**
+ * The **`has()`** method of the property is in the `StylePropertyMapReadOnly` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/StylePropertyMapReadOnly/has)
+ */
has(property: string): boolean;
forEach(callbackfn: (value: CSSStyleValue[], key: string, parent: StylePropertyMapReadOnly) => void, thisArg?: any): void;
}
@@ -5376,43 +8377,91 @@
new(): StylePropertyMapReadOnly;
};
/**
- * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto).
+ * The **`SubtleCrypto`** interface of the Web Crypto API provides a number of low-level cryptographic functions.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto)
*/
interface SubtleCrypto {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt) */
+ /**
+ * The **`decrypt()`** method of the SubtleCrypto interface decrypts some encrypted data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt)
+ */
decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits) */
- deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */
+ /**
+ * The **`deriveBits()`** method of the key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits)
+ */
+ deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length?: number | null): Promise<ArrayBuffer>;
+ /**
+ * The **`deriveKey()`** method of the SubtleCrypto interface can be used to derive a secret key from a master key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey)
+ */
deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest) */
+ /**
+ * The **`digest()`** method of the SubtleCrypto interface generates a _digest_ of the given data, using the specified hash function.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest)
+ */
digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/encrypt) */
+ /**
+ * The **`encrypt()`** method of the SubtleCrypto interface encrypts data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/encrypt)
+ */
encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/exportKey) */
+ /**
+ * The **`exportKey()`** method of the SubtleCrypto interface exports a key: that is, it takes as input a CryptoKey object and gives you the key in an external, portable format.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/exportKey)
+ */
exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
exportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey) */
- generateKey(algorithm: "Ed25519", extractable: boolean, keyUsages: ReadonlyArray<"sign" | "verify">): Promise<CryptoKeyPair>;
+ /**
+ * The **`generateKey()`** method of the SubtleCrypto interface is used to generate a new key (for symmetric algorithms) or key pair (for public-key algorithms).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey)
+ */
+ generateKey(algorithm: "Ed25519" | { name: "Ed25519" }, extractable: boolean, keyUsages: ReadonlyArray<"sign" | "verify">): Promise<CryptoKeyPair>;
generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;
generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKey>;
generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey) */
+ /**
+ * The **`importKey()`** method of the SubtleCrypto interface imports a key: that is, it takes as input a key in an external, portable format and gives you a CryptoKey object that you can use in the Web Crypto API.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey)
+ */
importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKey>;
importKey(format: Exclude<KeyFormat, "jwk">, keyData: BufferSource, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/sign) */
+ /**
+ * The **`sign()`** method of the SubtleCrypto interface generates a digital signature.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/sign)
+ */
sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey) */
+ /**
+ * The **`unwrapKey()`** method of the SubtleCrypto interface 'unwraps' a key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey)
+ */
unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/verify) */
+ /**
+ * The **`verify()`** method of the SubtleCrypto interface verifies a digital signature.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/verify)
+ */
verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<boolean>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey) */
+ /**
+ * The **`wrapKey()`** method of the SubtleCrypto interface 'wraps' a key.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey)
+ */
wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
}
declare var SubtleCrypto: {
@@ -5420,26 +8469,16 @@
new(): SubtleCrypto;
};
/**
- * A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc. A decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays.
+ * The **`TextDecoder`** interface represents a decoder for a specific text encoding, such as `UTF-8`, `ISO-8859-2`, `KOI8-R`, `GBK`, etc.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
*/
interface TextDecoder extends TextDecoderCommon {
/**
- * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
+ * The **`TextDecoder.decode()`** method returns a string containing text decoded from the buffer passed as a parameter.
*
- * ```
- * var string = "", decoder = new TextDecoder(encoding), buffer;
- * while(buffer = next_chunk()) {
- * string += decoder.decode(buffer, {stream:true});
- * }
- * string += decoder.decode(); // end-of-queue
- * ```
- *
- * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder/decode)
*/
decode(input?: AllowSharedBufferSource, options?: TextDecodeOptions): string;
}
@@ -5469,9 +8508,13 @@
*/
readonly ignoreBOM: boolean;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoderStream) */
+/**
+ * The **`TextDecoderStream`** interface of the Encoding API converts a stream of text in a binary encoding, such as UTF-8 etc., to a stream of strings.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoderStream)
+ */
interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
readonly readable: ReadableStream<string>;
readonly writable: WritableStream<BufferSource>;
}
@@ -5481,25 +8524,25 @@
new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
};
/**
- * TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays.
+ * The **`TextEncoder`** interface takes a stream of code points as input and emits a stream of UTF-8 bytes.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder)
*/
interface TextEncoder extends TextEncoderCommon {
/**
- * Returns the result of running UTF-8's encoder.
+ * The **`TextEncoder.encode()`** method takes a string as input, and returns a Global_Objects/Uint8Array containing the text given in parameters encoded with the specific method for that TextEncoder object.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encode)
*/
- encode(input?: string): Uint8Array;
+ encode(input?: string): Uint8Array<ArrayBuffer>;
/**
- * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination.
+ * The **`TextEncoder.encodeInto()`** method takes a string to encode and a destination Uint8Array to put resulting UTF-8 encoded text into, and returns a dictionary object indicating the progress of the encoding.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encodeInto)
*/
- encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+ encodeInto(source: string, destination: Uint8Array<ArrayBufferLike>): TextEncoderEncodeIntoResult;
}
declare var TextEncoder: {
prototype: TextEncoder;
@@ -5514,11 +8557,15 @@
*/
readonly encoding: string;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoderStream) */
+/**
+ * The **`TextEncoderStream`** interface of the Encoding API converts a stream of strings into bytes in the UTF-8 encoding.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoderStream)
+ */
interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
- readonly readable: ReadableStream<Uint8Array>;
+ readonly readable: ReadableStream<Uint8Array<ArrayBuffer>>;
readonly writable: WritableStream<string>;
}
declare var TextEncoderStream: {
@@ -5526,81 +8573,81 @@
new(): TextEncoderStream;
};
/**
- * The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method.
+ * The **`TextMetrics`** interface represents the dimensions of a piece of text in the canvas; a `TextMetrics` instance can be retrieved using the CanvasRenderingContext2D.measureText() method.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics)
*/
interface TextMetrics {
/**
- * Returns the measurement described below.
+ * The read-only **`actualBoundingBoxAscent`** property of the TextMetrics interface is a `double` giving the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline attribute to the top of the bounding rectangle used to render the text, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/actualBoundingBoxAscent)
*/
readonly actualBoundingBoxAscent: number;
/**
- * Returns the measurement described below.
+ * The read-only `actualBoundingBoxDescent` property of the TextMetrics interface is a `double` giving the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline attribute to the bottom of the bounding rectangle used to render the text, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/actualBoundingBoxDescent)
*/
readonly actualBoundingBoxDescent: number;
/**
- * Returns the measurement described below.
+ * The read-only `actualBoundingBoxLeft` property of the TextMetrics interface is a `double` giving the distance parallel to the baseline from the alignment point given by the CanvasRenderingContext2D.textAlign property to the left side of the bounding rectangle of the given text, in CSS pixels; positive numbers indicating a distance going left from the given alignment point.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/actualBoundingBoxLeft)
*/
readonly actualBoundingBoxLeft: number;
/**
- * Returns the measurement described below.
+ * The read-only `actualBoundingBoxRight` property of the TextMetrics interface is a `double` giving the distance parallel to the baseline from the alignment point given by the CanvasRenderingContext2D.textAlign property to the right side of the bounding rectangle of the given text, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/actualBoundingBoxRight)
*/
readonly actualBoundingBoxRight: number;
/**
- * Returns the measurement described below.
+ * The read-only `alphabeticBaseline` property of the TextMetrics interface is a `double` giving the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline property to the alphabetic baseline of the line box, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/alphabeticBaseline)
*/
readonly alphabeticBaseline: number;
/**
- * Returns the measurement described below.
+ * The read-only `emHeightAscent` property of the TextMetrics interface returns the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline property to the top of the _em_ square in the line box, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/emHeightAscent)
*/
readonly emHeightAscent: number;
/**
- * Returns the measurement described below.
+ * The read-only `emHeightDescent` property of the TextMetrics interface returns the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline property to the bottom of the _em_ square in the line box, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/emHeightDescent)
*/
readonly emHeightDescent: number;
/**
- * Returns the measurement described below.
+ * The read-only `fontBoundingBoxAscent` property of the TextMetrics interface returns the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline attribute, to the top of the highest bounding rectangle of all the fonts used to render the text, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/fontBoundingBoxAscent)
*/
readonly fontBoundingBoxAscent: number;
/**
- * Returns the measurement described below.
+ * The read-only `fontBoundingBoxDescent` property of the TextMetrics interface returns the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline attribute to the bottom of the bounding rectangle of all the fonts used to render the text, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/fontBoundingBoxDescent)
*/
readonly fontBoundingBoxDescent: number;
/**
- * Returns the measurement described below.
+ * The read-only `hangingBaseline` property of the TextMetrics interface is a `double` giving the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline property to the hanging baseline of the line box, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/hangingBaseline)
*/
readonly hangingBaseline: number;
/**
- * Returns the measurement described below.
+ * The read-only `ideographicBaseline` property of the TextMetrics interface is a `double` giving the distance from the horizontal line indicated by the CanvasRenderingContext2D.textBaseline property to the ideographic baseline of the line box, in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/ideographicBaseline)
*/
readonly ideographicBaseline: number;
/**
- * Returns the measurement described below.
+ * The read-only **`width`** property of the TextMetrics interface contains the text's advance width (the width of that inline box) in CSS pixels.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextMetrics/width)
*/
readonly width: number;
@@ -5610,30 +8657,62 @@
prototype: TextMetrics;
new(): TextMetrics;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream) */
+/**
+ * The **`TransformStream`** interface of the Streams API represents a concrete implementation of the pipe chain _transform stream_ concept.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream)
+ */
interface TransformStream<I = any, O = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/readable) */
+ /**
+ * The **`readable`** read-only property of the TransformStream interface returns the ReadableStream instance controlled by this `TransformStream`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/readable)
+ */
readonly readable: ReadableStream<O>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/writable) */
+ /**
+ * The **`writable`** read-only property of the TransformStream interface returns the WritableStream instance controlled by this `TransformStream`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/writable)
+ */
readonly writable: WritableStream<I>;
}
declare var TransformStream: {
prototype: TransformStream;
new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController) */
+/**
+ * The **`TransformStreamDefaultController`** interface of the Streams API provides methods to manipulate the associated ReadableStream and WritableStream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController)
+ */
interface TransformStreamDefaultController<O = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/desiredSize) */
+ /**
+ * The **`desiredSize`** read-only property of the TransformStreamDefaultController interface returns the desired size to fill the queue of the associated ReadableStream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/desiredSize)
+ */
readonly desiredSize: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/enqueue) */
+ /**
+ * The **`enqueue()`** method of the TransformStreamDefaultController interface enqueues the given chunk in the readable side of the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/enqueue)
+ */
enqueue(chunk?: O): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/error) */
+ /**
+ * The **`error()`** method of the TransformStreamDefaultController interface errors both sides of the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/error)
+ */
error(reason?: any): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/terminate) */
+ /**
+ * The **`terminate()`** method of the TransformStreamDefaultController interface closes the readable side and errors the writable side of the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/terminate)
+ */
terminate(): void;
}
declare var TransformStreamDefaultController: {
@@ -5641,96 +8720,177 @@
new(): TransformStreamDefaultController;
};
/**
- * The URL interface represents an object providing static methods used for creating object URLs.
+ * The **`URL`** interface is used to parse, construct, normalize, and encode URL.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL)
*/
interface URL {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hash) */
+ /**
+ * The **`hash`** property of the URL interface is a string containing a `'#'` followed by the fragment identifier of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hash)
+ */
hash: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/host) */
+ /**
+ * The **`host`** property of the URL interface is a string containing the host, which is the URL.hostname, and then, if the port of the URL is nonempty, a `':'`, followed by the URL.port of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/host)
+ */
host: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hostname) */
+ /**
+ * The **`hostname`** property of the URL interface is a string containing either the domain name or IP address of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hostname)
+ */
hostname: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/href) */
+ /**
+ * The **`href`** property of the URL interface is a string containing the whole URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/href)
+ */
href: string;
toString(): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/origin) */
+ /**
+ * The **`origin`** read-only property of the URL interface returns a string containing the Unicode serialization of the origin of the represented URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/origin)
+ */
readonly origin: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/password) */
+ /**
+ * The **`password`** property of the URL interface is a string containing the password component of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/password)
+ */
password: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/pathname) */
+ /**
+ * The **`pathname`** property of the URL interface represents a location in a hierarchical structure.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/pathname)
+ */
pathname: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/port) */
+ /**
+ * The **`port`** property of the URL interface is a string containing the port number of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/port)
+ */
port: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/protocol) */
+ /**
+ * The **`protocol`** property of the URL interface is a string containing the protocol or scheme of the URL, including the final `':'`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/protocol)
+ */
protocol: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/search) */
+ /**
+ * The **`search`** property of the URL interface is a search string, also called a _query string_, that is a string containing a `'?'` followed by the parameters of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/search)
+ */
search: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/searchParams) */
+ /**
+ * The **`searchParams`** read-only property of the access to the [MISSING: httpmethod('GET')] decoded query arguments contained in the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/searchParams)
+ */
readonly searchParams: URLSearchParams;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/username) */
+ /**
+ * The **`username`** property of the URL interface is a string containing the username component of the URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/username)
+ */
username: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/toJSON) */
+ /**
+ * The **`toJSON()`** method of the URL interface returns a string containing a serialized version of the URL, although in practice it seems to have the same effect as ```js-nolint toJSON() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/toJSON)
+ */
toJSON(): string;
}
declare var URL: {
prototype: URL;
new(url: string | URL, base?: string | URL): URL;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/canParse_static) */
- canParse(url: string | URL, base?: string): boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/createObjectURL_static) */
+ /**
+ * The **`URL.canParse()`** static method of the URL interface returns a boolean indicating whether or not an absolute URL, or a relative URL combined with a base URL, are parsable and valid.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/canParse_static)
+ */
+ canParse(url: string | URL, base?: string | URL): boolean;
+ /**
+ * The **`createObjectURL()`** static method of the URL interface creates a string containing a URL representing the object given in the parameter.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/createObjectURL_static)
+ */
createObjectURL(obj: Blob): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/revokeObjectURL_static) */
+ /**
+ * The **`URL.parse()`** static method of the URL interface returns a newly created URL object representing the URL defined by the parameters.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/parse_static)
+ */
+ parse(url: string | URL, base?: string | URL): URL | null;
+ /**
+ * The **`revokeObjectURL()`** static method of the URL interface releases an existing object URL which was previously created by calling Call this method when you've finished using an object URL to let the browser know not to keep the reference to the file any longer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/revokeObjectURL_static)
+ */
revokeObjectURL(url: string): void;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams) */
+/**
+ * The **`URLSearchParams`** interface defines utility methods to work with the query string of a URL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams)
+ */
interface URLSearchParams {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/size) */
+ /**
+ * The **`size`** read-only property of the URLSearchParams interface indicates the total number of search parameter entries.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/size)
+ */
readonly size: number;
/**
- * Appends a specified key/value pair as a new search parameter.
+ * The **`append()`** method of the URLSearchParams interface appends a specified key/value pair as a new search parameter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/append)
*/
append(name: string, value: string): void;
/**
- * Deletes the given search parameter, and its associated value, from the list of all search parameters.
+ * The **`delete()`** method of the URLSearchParams interface deletes specified parameters and their associated value(s) from the list of all search parameters.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/delete)
*/
delete(name: string, value?: string): void;
/**
- * Returns the first value associated to the given search parameter.
+ * The **`get()`** method of the URLSearchParams interface returns the first value associated to the given search parameter.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/get)
*/
get(name: string): string | null;
/**
- * Returns all the values association with a given search parameter.
+ * The **`getAll()`** method of the URLSearchParams interface returns all the values associated with a given search parameter as an array.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/getAll)
*/
getAll(name: string): string[];
/**
- * Returns a Boolean indicating if such a search parameter exists.
+ * The **`has()`** method of the URLSearchParams interface returns a boolean value that indicates whether the specified parameter is in the search parameters.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/has)
*/
has(name: string, value?: string): boolean;
/**
- * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
+ * The **`set()`** method of the URLSearchParams interface sets the value associated with a given search parameter to the given value.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/set)
*/
set(name: string, value: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/sort) */
+ /**
+ * The **`URLSearchParams.sort()`** method sorts all key/value pairs contained in this object in place and returns `undefined`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/sort)
+ */
sort(): void;
- /** Returns a string containing a query string suitable for use in a URL. Does not include the question mark. */
toString(): string;
forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
}
@@ -5738,19 +8898,43 @@
prototype: URLSearchParams;
new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace) */
+/**
+ * The **`VideoColorSpace`** interface of the WebCodecs API represents the color space of a video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace)
+ */
interface VideoColorSpace {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/fullRange) */
+ /**
+ * The **`fullRange`** read-only property of the VideoColorSpace interface returns `true` if full-range color values are used.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/fullRange)
+ */
readonly fullRange: boolean | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/matrix) */
+ /**
+ * The **`matrix`** read-only property of the VideoColorSpace interface returns the matrix coefficient of the video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/matrix)
+ */
readonly matrix: VideoMatrixCoefficients | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/primaries) */
+ /**
+ * The **`primaries`** read-only property of the VideoColorSpace interface returns the color gamut of the video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/primaries)
+ */
readonly primaries: VideoColorPrimaries | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/transfer) */
+ /**
+ * The **`transfer`** read-only property of the VideoColorSpace interface returns the opto-electronic transfer characteristics of the video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/transfer)
+ */
readonly transfer: VideoTransferCharacteristics | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/toJSON) */
+ /**
+ * The **`toJSON()`** method of the VideoColorSpace interface is a _serializer_ that returns a JSON representation of the `VideoColorSpace` object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoColorSpace/toJSON)
+ */
toJSON(): VideoColorSpaceInit;
}
declare var VideoColorSpace: {
@@ -5762,27 +8946,57 @@
"dequeue": Event;
}
/**
+ * The **`VideoDecoder`** interface of the WebCodecs API decodes chunks of video.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder)
*/
interface VideoDecoder extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/decodeQueueSize) */
+ /**
+ * The **`decodeQueueSize`** read-only property of the VideoDecoder interface returns the number of pending decode requests in the queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/decodeQueueSize)
+ */
readonly decodeQueueSize: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/dequeue_event) */
ondequeue: ((this: VideoDecoder, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/state) */
+ /**
+ * The **`state`** property of the VideoDecoder interface returns the current state of the underlying codec.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/state)
+ */
readonly state: CodecState;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/close) */
+ /**
+ * The **`close()`** method of the VideoDecoder interface ends all pending work and releases system resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/close)
+ */
close(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/configure) */
+ /**
+ * The **`configure()`** method of the VideoDecoder interface enqueues a control message to configure the video decoder for decoding chunks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/configure)
+ */
configure(config: VideoDecoderConfig): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/decode) */
+ /**
+ * The **`decode()`** method of the VideoDecoder interface enqueues a control message to decode a given chunk of video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/decode)
+ */
decode(chunk: EncodedVideoChunk): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/flush) */
+ /**
+ * The **`flush()`** method of the VideoDecoder interface returns a Promise that resolves once all pending messages in the queue have been completed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/flush)
+ */
flush(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/reset) */
+ /**
+ * The **`reset()`** method of the VideoDecoder interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/reset)
+ */
reset(): void;
addEventListener<K extends keyof VideoDecoderEventMap>(type: K, listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof VideoDecoderEventMap>(type: K, listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -5791,34 +9005,70 @@
declare var VideoDecoder: {
prototype: VideoDecoder;
new(init: VideoDecoderInit): VideoDecoder;
+ /**
+ * The **`isConfigSupported()`** static method of the VideoDecoder interface checks if the given config is supported (that is, if VideoDecoder objects can be successfully configured with the given config).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoDecoder/isConfigSupported_static)
+ */
isConfigSupported(config: VideoDecoderConfig): Promise<VideoDecoderSupport>;
};
interface VideoEncoderEventMap {
"dequeue": Event;
}
/**
+ * The **`VideoEncoder`** interface of the WebCodecs API encodes VideoFrame objects into EncodedVideoChunks.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder)
*/
interface VideoEncoder extends EventTarget {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/encodeQueueSize) */
+ /**
+ * The **`encodeQueueSize`** read-only property of the VideoEncoder interface returns the number of pending encode requests in the queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/encodeQueueSize)
+ */
readonly encodeQueueSize: number;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/dequeue_event) */
ondequeue: ((this: VideoEncoder, ev: Event) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/state) */
+ /**
+ * The **`state`** read-only property of the VideoEncoder interface returns the current state of the underlying codec.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/state)
+ */
readonly state: CodecState;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/close) */
+ /**
+ * The **`close()`** method of the VideoEncoder interface ends all pending work and releases system resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/close)
+ */
close(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/configure) */
+ /**
+ * The **`configure()`** method of the VideoEncoder interface changes the VideoEncoder.state of the encoder to 'configured' and asynchronously prepares the encoder to accept VideoEncoders for encoding with the specified parameters.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/configure)
+ */
configure(config: VideoEncoderConfig): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/encode) */
+ /**
+ * The **`encode()`** method of the VideoEncoder interface asynchronously encodes a VideoFrame.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/encode)
+ */
encode(frame: VideoFrame, options?: VideoEncoderEncodeOptions): void;
+ /**
+ * The **`flush()`** method of the VideoEncoder interface forces all pending encodes to complete.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/flush)
+ */
flush(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/reset) */
+ /**
+ * The **`reset()`** method of the VideoEncoder interface synchronously cancels all pending encodes and callbacks, frees all underlying resources and sets the VideoEncoder.state to 'unconfigured'.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/reset)
+ */
reset(): void;
addEventListener<K extends keyof VideoEncoderEventMap>(type: K, listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof VideoEncoderEventMap>(type: K, listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -5827,39 +9077,105 @@
declare var VideoEncoder: {
prototype: VideoEncoder;
new(init: VideoEncoderInit): VideoEncoder;
+ /**
+ * The **`isConfigSupported()`** static method of the VideoEncoder interface checks if VideoEncoder can be successfully configured with the given config.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoEncoder/isConfigSupported_static)
+ */
isConfigSupported(config: VideoEncoderConfig): Promise<VideoEncoderSupport>;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame) */
+/**
+ * The **`VideoFrame`** interface of the Web Codecs API represents a frame of a video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame)
+ */
interface VideoFrame {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedHeight) */
+ /**
+ * The **`codedHeight`** property of the VideoFrame interface returns the height of the VideoFrame in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedHeight)
+ */
readonly codedHeight: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedRect) */
+ /**
+ * The **`codedRect`** property of the VideoFrame interface returns a DOMRectReadOnly with the width and height matching VideoFrame.codedWidth and VideoFrame.codedHeight.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedRect)
+ */
readonly codedRect: DOMRectReadOnly | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedWidth) */
+ /**
+ * The **`codedWidth`** property of the VideoFrame interface returns the width of the `VideoFrame` in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/codedWidth)
+ */
readonly codedWidth: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/colorSpace) */
+ /**
+ * The **`colorSpace`** property of the VideoFrame interface returns a VideoColorSpace object representing the color space of the video.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/colorSpace)
+ */
readonly colorSpace: VideoColorSpace;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/displayHeight) */
+ /**
+ * The **`displayHeight`** property of the VideoFrame interface returns the height of the `VideoFrame` after applying aspect ratio adjustments.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/displayHeight)
+ */
readonly displayHeight: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/displayWidth) */
+ /**
+ * The **`displayWidth`** property of the VideoFrame interface returns the width of the `VideoFrame` after applying aspect ratio adjustments.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/displayWidth)
+ */
readonly displayWidth: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/duration) */
+ /**
+ * The **`duration`** property of the VideoFrame interface returns an integer indicating the duration of the video in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/duration)
+ */
readonly duration: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/format) */
+ /**
+ * The **`format`** property of the VideoFrame interface returns the pixel format of the `VideoFrame`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/format)
+ */
readonly format: VideoPixelFormat | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/timestamp) */
+ /**
+ * The **`timestamp`** property of the VideoFrame interface returns an integer indicating the timestamp of the video in microseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/timestamp)
+ */
readonly timestamp: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/visibleRect) */
+ /**
+ * The **`visibleRect`** property of the VideoFrame interface returns a DOMRectReadOnly describing the visible rectangle of pixels for this `VideoFrame`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/visibleRect)
+ */
readonly visibleRect: DOMRectReadOnly | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/allocationSize) */
+ /**
+ * The **`allocationSize()`** method of the VideoFrame interface returns the number of bytes required to hold the video as filtered by options passed into the method.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/allocationSize)
+ */
allocationSize(options?: VideoFrameCopyToOptions): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/clone) */
+ /**
+ * The **`clone()`** method of the VideoFrame interface creates a new `VideoFrame` object referencing the same media resource as the original.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/clone)
+ */
clone(): VideoFrame;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/close) */
+ /**
+ * The **`close()`** method of the VideoFrame interface clears all states and releases the reference to the media resource.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/close)
+ */
close(): void;
+ /**
+ * The **`copyTo()`** method of the VideoFrame interface copies the contents of the `VideoFrame` to an `ArrayBuffer`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/VideoFrame/copyTo)
+ */
copyTo(destination: AllowSharedBufferSource, options?: VideoFrameCopyToOptions): Promise<PlaneLayout[]>;
}
declare var VideoFrame: {
@@ -5867,18 +9183,30 @@
new(image: CanvasImageSource, init?: VideoFrameInit): VideoFrame;
new(data: AllowSharedBufferSource, init: VideoFrameBufferInit): VideoFrame;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_color_buffer_float) */
+/**
+ * The **`WEBGL_color_buffer_float`** extension is part of the WebGL API and adds the ability to render to 32-bit floating-point color buffers.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_color_buffer_float)
+ */
interface WEBGL_color_buffer_float {
readonly RGBA32F_EXT: 0x8814;
readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 0x8211;
readonly UNSIGNED_NORMALIZED_EXT: 0x8C17;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_astc) */
+/**
+ * The **`WEBGL_compressed_texture_astc`** extension is part of the WebGL API and exposes Adaptive Scalable Texture Compression (ASTC) compressed texture formats to WebGL.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_astc)
+ */
interface WEBGL_compressed_texture_astc {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_astc/getSupportedProfiles) */
+ /**
+ * The **`WEBGL_compressed_texture_astc.getSupportedProfiles()`** method returns an array of strings containing the names of the ASTC profiles supported by the implementation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_astc/getSupportedProfiles)
+ */
getSupportedProfiles(): string[];
readonly COMPRESSED_RGBA_ASTC_4x4_KHR: 0x93B0;
readonly COMPRESSED_RGBA_ASTC_5x4_KHR: 0x93B1;
readonly COMPRESSED_RGBA_ASTC_5x5_KHR: 0x93B2;
@@ -5908,9 +9236,13 @@
readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 0x93DC;
readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 0x93DD;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_etc) */
+/**
+ * The **`WEBGL_compressed_texture_etc`** extension is part of the WebGL API and exposes 10 ETC/EAC compressed texture formats.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_etc)
+ */
interface WEBGL_compressed_texture_etc {
readonly COMPRESSED_R11_EAC: 0x9270;
readonly COMPRESSED_SIGNED_R11_EAC: 0x9271;
readonly COMPRESSED_RG11_EAC: 0x9272;
@@ -5922,23 +9254,31 @@
readonly COMPRESSED_RGBA8_ETC2_EAC: 0x9278;
readonly COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 0x9279;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_etc1) */
+/**
+ * The **`WEBGL_compressed_texture_etc1`** extension is part of the WebGL API and exposes the ETC1 compressed texture format.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_etc1)
+ */
interface WEBGL_compressed_texture_etc1 {
readonly COMPRESSED_RGB_ETC1_WEBGL: 0x8D64;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_pvrtc) */
+/**
+ * The **`WEBGL_compressed_texture_pvrtc`** extension is part of the WebGL API and exposes four PVRTC compressed texture formats.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_pvrtc)
+ */
interface WEBGL_compressed_texture_pvrtc {
readonly COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 0x8C00;
readonly COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 0x8C01;
readonly COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 0x8C02;
readonly COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 0x8C03;
}
/**
- * The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats.
+ * The **`WEBGL_compressed_texture_s3tc`** extension is part of the WebGL API and exposes four S3TC compressed texture formats.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_s3tc)
*/
interface WEBGL_compressed_texture_s3tc {
@@ -5947,44 +9287,64 @@
readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: 0x83F2;
readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: 0x83F3;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_s3tc_srgb) */
+/**
+ * The **`WEBGL_compressed_texture_s3tc_srgb`** extension is part of the WebGL API and exposes four S3TC compressed texture formats for the sRGB colorspace.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_compressed_texture_s3tc_srgb)
+ */
interface WEBGL_compressed_texture_s3tc_srgb {
readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: 0x8C4C;
readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 0x8C4D;
readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 0x8C4E;
readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 0x8C4F;
}
/**
- * The WEBGL_debug_renderer_info extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes.
+ * The **`WEBGL_debug_renderer_info`** extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_debug_renderer_info)
*/
interface WEBGL_debug_renderer_info {
readonly UNMASKED_VENDOR_WEBGL: 0x9245;
readonly UNMASKED_RENDERER_WEBGL: 0x9246;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_debug_shaders) */
+/**
+ * The **`WEBGL_debug_shaders`** extension is part of the WebGL API and exposes a method to debug shaders from privileged contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_debug_shaders)
+ */
interface WEBGL_debug_shaders {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_debug_shaders/getTranslatedShaderSource) */
+ /**
+ * The **`WEBGL_debug_shaders.getTranslatedShaderSource()`** method is part of the WebGL API and allows you to debug a translated shader.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_debug_shaders/getTranslatedShaderSource)
+ */
getTranslatedShaderSource(shader: WebGLShader): string;
}
/**
- * The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures.
+ * The **`WEBGL_depth_texture`** extension is part of the WebGL API and defines 2D depth and depth-stencil textures.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_depth_texture)
*/
interface WEBGL_depth_texture {
readonly UNSIGNED_INT_24_8_WEBGL: 0x84FA;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_draw_buffers) */
+/**
+ * The **`WEBGL_draw_buffers`** extension is part of the WebGL API and enables a fragment shader to write to several textures, which is useful for deferred shading, for example.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_draw_buffers)
+ */
interface WEBGL_draw_buffers {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_draw_buffers/drawBuffersWEBGL) */
+ /**
+ * The **`WEBGL_draw_buffers.drawBuffersWEBGL()`** method is part of the WebGL API and allows you to define the draw buffers to which all fragment colors are written.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_draw_buffers/drawBuffersWEBGL)
+ */
drawBuffersWEBGL(buffers: GLenum[]): void;
readonly COLOR_ATTACHMENT0_WEBGL: 0x8CE0;
readonly COLOR_ATTACHMENT1_WEBGL: 0x8CE1;
readonly COLOR_ATTACHMENT2_WEBGL: 0x8CE2;
@@ -6020,29 +9380,65 @@
readonly MAX_COLOR_ATTACHMENTS_WEBGL: 0x8CDF;
readonly MAX_DRAW_BUFFERS_WEBGL: 0x8824;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context) */
+/**
+ * The **WEBGL_lose_context** extension is part of the WebGL API and exposes functions to simulate losing and restoring a WebGLRenderingContext.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context)
+ */
interface WEBGL_lose_context {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context/loseContext) */
+ /**
+ * The **WEBGL_lose_context.loseContext()** method is part of the WebGL API and allows you to simulate losing the context of a WebGLRenderingContext context.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context/loseContext)
+ */
loseContext(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context/restoreContext) */
+ /**
+ * The **WEBGL_lose_context.restoreContext()** method is part of the WebGL API and allows you to simulate restoring the context of a WebGLRenderingContext object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_lose_context/restoreContext)
+ */
restoreContext(): void;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw) */
+/**
+ * The **`WEBGL_multi_draw`** extension is part of the WebGL API and allows to render more than one primitive with a single function call.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw)
+ */
interface WEBGL_multi_draw {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawArraysInstancedWEBGL) */
- multiDrawArraysInstancedWEBGL(mode: GLenum, firstsList: Int32Array | GLint[], firstsOffset: number, countsList: Int32Array | GLsizei[], countsOffset: number, instanceCountsList: Int32Array | GLsizei[], instanceCountsOffset: number, drawcount: GLsizei): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawArraysWEBGL) */
- multiDrawArraysWEBGL(mode: GLenum, firstsList: Int32Array | GLint[], firstsOffset: number, countsList: Int32Array | GLsizei[], countsOffset: number, drawcount: GLsizei): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawElementsInstancedWEBGL) */
- multiDrawElementsInstancedWEBGL(mode: GLenum, countsList: Int32Array | GLsizei[], countsOffset: number, type: GLenum, offsetsList: Int32Array | GLsizei[], offsetsOffset: number, instanceCountsList: Int32Array | GLsizei[], instanceCountsOffset: number, drawcount: GLsizei): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawElementsWEBGL) */
- multiDrawElementsWEBGL(mode: GLenum, countsList: Int32Array | GLsizei[], countsOffset: number, type: GLenum, offsetsList: Int32Array | GLsizei[], offsetsOffset: number, drawcount: GLsizei): void;
+ /**
+ * The **`WEBGL_multi_draw.multiDrawArraysInstancedWEBGL()`** method of the WebGL API renders multiple primitives from array data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawArraysInstancedWEBGL)
+ */
+ multiDrawArraysInstancedWEBGL(mode: GLenum, firstsList: Int32Array<ArrayBufferLike> | GLint[], firstsOffset: number, countsList: Int32Array<ArrayBufferLike> | GLsizei[], countsOffset: number, instanceCountsList: Int32Array<ArrayBufferLike> | GLsizei[], instanceCountsOffset: number, drawcount: GLsizei): void;
+ /**
+ * The **`WEBGL_multi_draw.multiDrawArraysWEBGL()`** method of the WebGL API renders multiple primitives from array data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawArraysWEBGL)
+ */
+ multiDrawArraysWEBGL(mode: GLenum, firstsList: Int32Array<ArrayBufferLike> | GLint[], firstsOffset: number, countsList: Int32Array<ArrayBufferLike> | GLsizei[], countsOffset: number, drawcount: GLsizei): void;
+ /**
+ * The **`WEBGL_multi_draw.multiDrawElementsInstancedWEBGL()`** method of the WebGL API renders multiple primitives from array data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawElementsInstancedWEBGL)
+ */
+ multiDrawElementsInstancedWEBGL(mode: GLenum, countsList: Int32Array<ArrayBufferLike> | GLsizei[], countsOffset: number, type: GLenum, offsetsList: Int32Array<ArrayBufferLike> | GLsizei[], offsetsOffset: number, instanceCountsList: Int32Array<ArrayBufferLike> | GLsizei[], instanceCountsOffset: number, drawcount: GLsizei): void;
+ /**
+ * The **`WEBGL_multi_draw.multiDrawElementsWEBGL()`** method of the WebGL API renders multiple primitives from array data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WEBGL_multi_draw/multiDrawElementsWEBGL)
+ */
+ multiDrawElementsWEBGL(mode: GLenum, countsList: Int32Array<ArrayBufferLike> | GLsizei[], countsOffset: number, type: GLenum, offsetsList: Int32Array<ArrayBufferLike> | GLsizei[], offsetsOffset: number, drawcount: GLsizei): void;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext) */
+/**
+ * The **WebGL2RenderingContext** interface provides the OpenGL ES 3.0 rendering context for the drawing surface of an HTML canvas element.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext)
+ */
interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
}
declare var WebGL2RenderingContext: {
@@ -6637,24 +10033,24 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/clientWaitSync) */
clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/compressedTexImage3D) */
compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
- compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: number, srcLengthOverride?: GLuint): void;
+ compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset?: number, srcLengthOverride?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/compressedTexSubImage3D) */
compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
- compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: number, srcLengthOverride?: GLuint): void;
+ compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset?: number, srcLengthOverride?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/copyBufferSubData) */
copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/copyTexSubImage3D) */
copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createQuery) */
- createQuery(): WebGLQuery | null;
+ createQuery(): WebGLQuery;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createSampler) */
- createSampler(): WebGLSampler | null;
+ createSampler(): WebGLSampler;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createTransformFeedback) */
- createTransformFeedback(): WebGLTransformFeedback | null;
+ createTransformFeedback(): WebGLTransformFeedback;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createVertexArray) */
- createVertexArray(): WebGLVertexArrayObject | null;
+ createVertexArray(): WebGLVertexArrayObject;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteQuery) */
deleteQuery(query: WebGLQuery | null): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteSampler) */
deleteSampler(sampler: WebGLSampler | null): void;
@@ -6686,9 +10082,9 @@
getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/getActiveUniforms) */
getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/getBufferSubData) */
- getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: number, length?: GLuint): void;
+ getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView<ArrayBufferLike>, dstOffset?: number, length?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/getFragDataLocation) */
getFragDataLocation(program: WebGLProgram, name: string): GLint;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/getIndexedParameter) */
getIndexedParameter(target: GLenum, index: GLuint): any;
@@ -6736,18 +10132,18 @@
samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/texImage3D) */
texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
- texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
- texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: number): void;
+ texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView<ArrayBufferLike> | null): void;
+ texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/texStorage2D) */
texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/texStorage3D) */
texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/texSubImage3D) */
texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
- texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView | null, srcOffset?: number): void;
+ texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView<ArrayBufferLike> | null, srcOffset?: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/transformFeedbackVaryings) */
transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/uniform) */
uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
@@ -7057,37 +10453,37 @@
readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 0x9247;
}
interface WebGL2RenderingContextOverloads {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/bufferData) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/bufferData) */
bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
bufferData(target: GLenum, srcData: AllowSharedBufferSource | null, usage: GLenum): void;
- bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: number, length?: GLuint): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/bufferSubData) */
+ bufferData(target: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, usage: GLenum, srcOffset: number, length?: GLuint): void;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/bufferSubData) */
bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: AllowSharedBufferSource): void;
- bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: number, length?: GLuint): void;
+ bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset: number, length?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/compressedTexImage2D) */
compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
- compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: number, srcLengthOverride?: GLuint): void;
+ compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset?: number, srcLengthOverride?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/compressedTexSubImage2D) */
compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
- compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: number, srcLengthOverride?: GLuint): void;
+ compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset?: number, srcLengthOverride?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/readPixels) */
- readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
+ readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView<ArrayBufferLike> | null): void;
readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
- readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: number): void;
+ readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView<ArrayBufferLike>, dstOffset: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/texImage2D) */
- texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+ texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView<ArrayBufferLike> | null): void;
texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
- texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: number): void;
+ texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/texSubImage2D) */
- texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+ texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView<ArrayBufferLike> | null): void;
texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
- texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: number): void;
+ texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView<ArrayBufferLike>, srcOffset: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: number, srcLength?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: number, srcLength?: GLuint): void;
@@ -7102,27 +10498,39 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: number, srcLength?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: number, srcLength?: GLuint): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniformMatrix) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/uniformMatrix) */
uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: number, srcLength?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniformMatrix) */
uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: number, srcLength?: GLuint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniformMatrix) */
uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: number, srcLength?: GLuint): void;
}
/**
- * Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods.
+ * The **WebGLActiveInfo** interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo)
*/
interface WebGLActiveInfo {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/name) */
+ /**
+ * The read-only **`WebGLActiveInfo.name`** property represents the name of the requested data returned by calling the WebGLRenderingContext.getActiveAttrib() or WebGLRenderingContext.getActiveUniform() methods.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/name)
+ */
readonly name: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/size) */
+ /**
+ * The read-only **`WebGLActiveInfo.size`** property is a Number representing the size of the requested data returned by calling the WebGLRenderingContext.getActiveAttrib() or WebGLRenderingContext.getActiveUniform() methods.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/size)
+ */
readonly size: GLint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/type) */
+ /**
+ * The read-only **`WebGLActiveInfo.type`** property represents the type of the requested data returned by calling the WebGLRenderingContext.getActiveAttrib() or WebGLRenderingContext.getActiveUniform() methods.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLActiveInfo/type)
+ */
readonly type: GLenum;
}
declare var WebGLActiveInfo: {
@@ -7130,9 +10538,9 @@
new(): WebGLActiveInfo;
};
/**
- * Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.
+ * The **WebGLBuffer** interface is part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLBuffer)
*/
interface WebGLBuffer {
@@ -7143,14 +10551,18 @@
new(): WebGLBuffer;
};
/**
- * The WebContextEvent interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context.
+ * The **WebGLContextEvent** interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLContextEvent)
*/
interface WebGLContextEvent extends Event {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLContextEvent/statusMessage) */
+ /**
+ * The read-only **`WebGLContextEvent.statusMessage`** property contains additional event status information, or is an empty string if no additional information is available.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLContextEvent/statusMessage)
+ */
readonly statusMessage: string;
}
declare var WebGLContextEvent: {
@@ -7158,9 +10570,9 @@
new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
};
/**
- * Part of the WebGL API and represents a collection of buffers that serve as a rendering destination.
+ * The **WebGLFramebuffer** interface is part of the WebGL API and represents a collection of buffers that serve as a rendering destination.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLFramebuffer)
*/
interface WebGLFramebuffer {
@@ -7171,9 +10583,9 @@
new(): WebGLFramebuffer;
};
/**
- * The WebGLProgram is part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL).
+ * The **`WebGLProgram`** is part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL).
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLProgram)
*/
interface WebGLProgram {
@@ -7183,9 +10595,13 @@
prototype: WebGLProgram;
new(): WebGLProgram;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLQuery) */
+/**
+ * The **`WebGLQuery`** interface is part of the WebGL 2 API and provides ways to asynchronously query for information.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLQuery)
+ */
interface WebGLQuery {
}
declare var WebGLQuery: {
@@ -7193,9 +10609,9 @@
new(): WebGLQuery;
};
/**
- * Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation.
+ * The **WebGLRenderbuffer** interface is part of the WebGL API and represents a buffer that can contain an image, or that can be a source or target of a rendering operation.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderbuffer)
*/
interface WebGLRenderbuffer {
@@ -7206,9 +10622,9 @@
new(): WebGLRenderbuffer;
};
/**
- * Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element.
+ * The **`WebGLRenderingContext`** interface provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML canvas element.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext)
*/
interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
@@ -7516,13 +10932,16 @@
readonly BROWSER_DEFAULT_WEBGL: 0x9244;
};
interface WebGLRenderingContextBase {
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/drawingBufferColorSpace) */
drawingBufferColorSpace: PredefinedColorSpace;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/drawingBufferHeight) */
readonly drawingBufferHeight: GLsizei;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/drawingBufferWidth) */
readonly drawingBufferWidth: GLsizei;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/unpackColorSpace) */
+ unpackColorSpace: PredefinedColorSpace;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/activeTexture) */
activeTexture(texture: GLenum): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/attachShader) */
attachShader(program: WebGLProgram, shader: WebGLShader): void;
@@ -7564,19 +10983,19 @@
copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/copyTexSubImage2D) */
copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createBuffer) */
- createBuffer(): WebGLBuffer | null;
+ createBuffer(): WebGLBuffer;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createFramebuffer) */
- createFramebuffer(): WebGLFramebuffer | null;
+ createFramebuffer(): WebGLFramebuffer;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createProgram) */
- createProgram(): WebGLProgram | null;
+ createProgram(): WebGLProgram;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createRenderbuffer) */
- createRenderbuffer(): WebGLRenderbuffer | null;
+ createRenderbuffer(): WebGLRenderbuffer;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createShader) */
createShader(type: GLenum): WebGLShader | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createTexture) */
- createTexture(): WebGLTexture | null;
+ createTexture(): WebGLTexture;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/cullFace) */
cullFace(mode: GLenum): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/deleteBuffer) */
deleteBuffer(buffer: WebGLBuffer | null): void;
@@ -7719,8 +11138,9 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/isShader) */
isShader(shader: WebGLShader | null): GLboolean;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/isTexture) */
isTexture(texture: WebGLTexture | null): GLboolean;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/lineWidth) */
lineWidth(width: GLfloat): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/linkProgram) */
linkProgram(program: WebGLProgram): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/pixelStorei) */
@@ -8096,18 +11516,18 @@
bufferData(target: GLenum, data: AllowSharedBufferSource | null, usage: GLenum): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/bufferSubData) */
bufferSubData(target: GLenum, offset: GLintptr, data: AllowSharedBufferSource): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/compressedTexImage2D) */
- compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
+ compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView<ArrayBufferLike>): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/compressedTexSubImage2D) */
- compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
+ compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView<ArrayBufferLike>): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/readPixels) */
- readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+ readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView<ArrayBufferLike> | null): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/texImage2D) */
- texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+ texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView<ArrayBufferLike> | null): void;
texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/texSubImage2D) */
- texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+ texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView<ArrayBufferLike> | null): void;
texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniform) */
@@ -8131,9 +11551,13 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/uniformMatrix) */
uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLSampler) */
+/**
+ * The **`WebGLSampler`** interface is part of the WebGL 2 API and stores sampling parameters for WebGLTexture access inside of a shader.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLSampler)
+ */
interface WebGLSampler {
}
declare var WebGLSampler: {
@@ -8141,9 +11565,9 @@
new(): WebGLSampler;
};
/**
- * The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders.
+ * The **WebGLShader** is part of the WebGL API and can either be a vertex or a fragment shader.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShader)
*/
interface WebGLShader {
@@ -8154,27 +11578,43 @@
new(): WebGLShader;
};
/**
- * Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method.
+ * The **WebGLShaderPrecisionFormat** interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat)
*/
interface WebGLShaderPrecisionFormat {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/precision) */
+ /**
+ * The read-only **`WebGLShaderPrecisionFormat.precision`** property returns the number of bits of precision that can be represented.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/precision)
+ */
readonly precision: GLint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/rangeMax) */
+ /**
+ * The read-only **`WebGLShaderPrecisionFormat.rangeMax`** property returns the base 2 log of the absolute value of the maximum value that can be represented.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/rangeMax)
+ */
readonly rangeMax: GLint;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/rangeMin) */
+ /**
+ * The read-only **`WebGLShaderPrecisionFormat.rangeMin`** property returns the base 2 log of the absolute value of the minimum value that can be represented.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLShaderPrecisionFormat/rangeMin)
+ */
readonly rangeMin: GLint;
}
declare var WebGLShaderPrecisionFormat: {
prototype: WebGLShaderPrecisionFormat;
new(): WebGLShaderPrecisionFormat;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLSync) */
+/**
+ * The **`WebGLSync`** interface is part of the WebGL 2 API and is used to synchronize activities between the GPU and the application.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLSync)
+ */
interface WebGLSync {
}
declare var WebGLSync: {
@@ -8182,9 +11622,9 @@
new(): WebGLSync;
};
/**
- * Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.
+ * The **WebGLTexture** interface is part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLTexture)
*/
interface WebGLTexture {
@@ -8194,9 +11634,13 @@
prototype: WebGLTexture;
new(): WebGLTexture;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLTransformFeedback) */
+/**
+ * The **`WebGLTransformFeedback`** interface is part of the WebGL 2 API and enables transform feedback, which is the process of capturing primitives generated by vertex processing.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLTransformFeedback)
+ */
interface WebGLTransformFeedback {
}
declare var WebGLTransformFeedback: {
@@ -8204,9 +11648,9 @@
new(): WebGLTransformFeedback;
};
/**
- * Part of the WebGL API and represents the location of a uniform variable in a shader program.
+ * The **WebGLUniformLocation** interface is part of the WebGL API and represents the location of a uniform variable in a shader program.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLUniformLocation)
*/
interface WebGLUniformLocation {
@@ -8216,18 +11660,22 @@
prototype: WebGLUniformLocation;
new(): WebGLUniformLocation;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLVertexArrayObject) */
+/**
+ * The **`WebGLVertexArrayObject`** interface is part of the WebGL 2 API, represents vertex array objects (VAOs) pointing to vertex array data, and provides names for different sets of vertex data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLVertexArrayObject)
+ */
interface WebGLVertexArrayObject {
}
declare var WebGLVertexArrayObject: {
prototype: WebGLVertexArrayObject;
new(): WebGLVertexArrayObject;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLVertexArrayObjectOES) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLVertexArrayObject) */
interface WebGLVertexArrayObjectOES {
}
interface WebSocketEventMap {
@@ -8237,31 +11685,27 @@
"open": Event;
}
/**
- * Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
+ * The `WebSocket` object provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
*/
interface WebSocket extends EventTarget {
/**
- * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
+ * The **`WebSocket.binaryType`** property controls the type of binary data being received over the WebSocket connection.
*
- * Can be set, to change how binary data is returned. The default is "blob".
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/binaryType)
*/
binaryType: BinaryType;
/**
- * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
+ * The **`WebSocket.bufferedAmount`** read-only property returns the number of bytes of data that have been queued using calls to `send()` but not yet transmitted to the network.
*
- * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/bufferedAmount)
*/
readonly bufferedAmount: number;
/**
- * Returns the extensions selected by the server, if any.
+ * The **`WebSocket.extensions`** read-only property returns the extensions selected by the server.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/extensions)
*/
readonly extensions: string;
@@ -8273,33 +11717,33 @@
onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/open_event) */
onopen: ((this: WebSocket, ev: Event) => any) | null;
/**
- * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation.
+ * The **`WebSocket.protocol`** read-only property returns the name of the sub-protocol the server selected; this will be one of the strings specified in the `protocols` parameter when creating the WebSocket object, or the empty string if no connection is established.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/protocol)
*/
readonly protocol: string;
/**
- * Returns the state of the WebSocket object's connection. It can have the values described below.
+ * The **`WebSocket.readyState`** read-only property returns the current state of the WebSocket connection.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/readyState)
*/
readonly readyState: number;
/**
- * Returns the URL that was used to establish the WebSocket connection.
+ * The **`WebSocket.url`** read-only property returns the absolute URL of the WebSocket as resolved by the constructor.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/url)
*/
readonly url: string;
/**
- * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
+ * The **`WebSocket.close()`** method closes the already `CLOSED`, this method does nothing.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/close)
*/
close(code?: number, reason?: string): void;
/**
- * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+ * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
*/
send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
@@ -8322,28 +11766,61 @@
readonly CLOSED: 3;
};
/**
+ * The **`WebTransport`** interface of the WebTransport API provides functionality to enable a user agent to connect to an HTTP/3 server, initiate reliable and unreliable transport in either or both directions, and close the connection once it is no longer needed.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport)
*/
interface WebTransport {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/closed) */
+ /**
+ * The **`closed`** read-only property of the WebTransport interface returns a promise that resolves when the transport is closed.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/closed)
+ */
readonly closed: Promise<WebTransportCloseInfo>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/datagrams) */
+ /**
+ * The **`datagrams`** read-only property of the WebTransport interface returns a WebTransportDatagramDuplexStream instance that can be used to send and receive datagrams — unreliable data transmission.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/datagrams)
+ */
readonly datagrams: WebTransportDatagramDuplexStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/incomingBidirectionalStreams) */
+ /**
+ * The **`incomingBidirectionalStreams`** read-only property of the WebTransport interface represents one or more bidirectional streams opened by the server.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/incomingBidirectionalStreams)
+ */
readonly incomingBidirectionalStreams: ReadableStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/incomingUnidirectionalStreams) */
+ /**
+ * The **`incomingUnidirectionalStreams`** read-only property of the WebTransport interface represents one or more unidirectional streams opened by the server.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/incomingUnidirectionalStreams)
+ */
readonly incomingUnidirectionalStreams: ReadableStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/ready) */
- readonly ready: Promise<undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/close) */
+ /**
+ * The **`ready`** read-only property of the WebTransport interface returns a promise that resolves when the transport is ready to use.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/ready)
+ */
+ readonly ready: Promise<void>;
+ /**
+ * The **`close()`** method of the WebTransport interface closes an ongoing WebTransport session.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/close)
+ */
close(closeInfo?: WebTransportCloseInfo): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/createBidirectionalStream) */
+ /**
+ * The **`createBidirectionalStream()`** method of the WebTransport interface asynchronously opens and returns a bidirectional stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/createBidirectionalStream)
+ */
createBidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportBidirectionalStream>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/createUnidirectionalStream) */
+ /**
+ * The **`createUnidirectionalStream()`** method of the WebTransport interface asynchronously opens a unidirectional stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransport/createUnidirectionalStream)
+ */
createUnidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WritableStream>;
}
declare var WebTransport: {
@@ -8351,16 +11828,25 @@
new(url: string | URL, options?: WebTransportOptions): WebTransport;
};
/**
+ * The **`WebTransportBidirectionalStream`** interface of the WebTransport API represents a bidirectional stream created by a server or a client that can be used for reliable transport.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportBidirectionalStream)
*/
interface WebTransportBidirectionalStream {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportBidirectionalStream/readable) */
+ /**
+ * The **`readable`** read-only property of the WebTransportBidirectionalStream interface returns a WebTransportReceiveStream instance that can be used to reliably read incoming data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportBidirectionalStream/readable)
+ */
readonly readable: ReadableStream;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportBidirectionalStream/writable) */
+ /**
+ * The **`writable`** read-only property of the WebTransportBidirectionalStream interface returns a WebTransportSendStream instance that can be used to write outgoing data.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportBidirectionalStream/writable)
+ */
readonly writable: WritableStream;
}
declare var WebTransportBidirectionalStream: {
@@ -8368,24 +11854,49 @@
new(): WebTransportBidirectionalStream;
};
/**
+ * The **`WebTransportDatagramDuplexStream`** interface of the WebTransport API represents a duplex stream that can be used for unreliable transport of datagrams between client and server.
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream)
*/
interface WebTransportDatagramDuplexStream {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/incomingHighWaterMark) */
+ /**
+ * The **`incomingHighWaterMark`** property of the WebTransportDatagramDuplexStream interface gets or sets the high water mark for incoming chunks of data — this is the maximum size, in chunks, that the incoming ReadableStream's internal queue can reach before it is considered full.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/incomingHighWaterMark)
+ */
incomingHighWaterMark: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/incomingMaxAge) */
+ /**
+ * The **`incomingMaxAge`** property of the WebTransportDatagramDuplexStream interface gets or sets the maximum age for incoming datagrams, in milliseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/incomingMaxAge)
+ */
incomingMaxAge: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/maxDatagramSize) */
+ /**
+ * The **`maxDatagramSize`** read-only property of the WebTransportDatagramDuplexStream interface returns the maximum allowable size of outgoing datagrams, in bytes, that can be written to WebTransportDatagramDuplexStream.writable.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/maxDatagramSize)
+ */
readonly maxDatagramSize: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/outgoingHighWaterMark) */
+ /**
+ * The **`outgoingHighWaterMark`** property of the WebTransportDatagramDuplexStream interface gets or sets the high water mark for outgoing chunks of data — this is the maximum size, in chunks, that the outgoing WritableStream's internal queue can reach before it is considered full.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/outgoingHighWaterMark)
+ */
outgoingHighWaterMark: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/outgoingMaxAge) */
+ /**
+ * The **`outgoingMaxAge`** property of the WebTransportDatagramDuplexStream interface gets or sets the maximum age for outgoing datagrams, in milliseconds.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/outgoingMaxAge)
+ */
outgoingMaxAge: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/readable) */
+ /**
+ * The **`readable`** read-only property of the WebTransportDatagramDuplexStream interface returns a ReadableStream instance that can be used to unreliably read incoming datagrams from the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/readable)
+ */
readonly readable: ReadableStream;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportDatagramDuplexStream/writable) */
readonly writable: WritableStream;
}
@@ -8395,16 +11906,25 @@
new(): WebTransportDatagramDuplexStream;
};
/**
+ * The **`WebTransportError`** interface of the WebTransport API represents an error related to the API, which can arise from server errors, network connection problems, or client-initiated abort operations (for example, arising from a WritableStream.abort() call).
* Available only in secure contexts.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportError)
*/
interface WebTransportError extends DOMException {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportError/source) */
+ /**
+ * The **`source`** read-only property of the WebTransportError interface returns an enumerated value indicating the source of the error.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportError/source)
+ */
readonly source: WebTransportErrorSource;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportError/streamErrorCode) */
+ /**
+ * The **`streamErrorCode`** read-only property of the WebTransportError interface returns a number in the range 0-255 indicating the application protocol error code for this error, or `null` if one is not available.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebTransportError/streamErrorCode)
+ */
readonly streamErrorCode: number | null;
}
declare var WebTransportError: {
@@ -8412,20 +11932,36 @@
new(message?: string, options?: WebTransportErrorOptions): WebTransportError;
};
/**
- * This ServiceWorker API interface represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.
+ * The `WindowClient` interface of the ServiceWorker API represents the scope of a service worker client that is a document in a browsing context, controlled by an active worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient)
*/
interface WindowClient extends Client {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focused) */
+ /**
+ * The **`focused`** read-only property of the the current client has focus.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focused)
+ */
readonly focused: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/visibilityState) */
+ /**
+ * The **`visibilityState`** read-only property of the This value can be one of `'hidden'`, `'visible'`, or `'prerender'`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/visibilityState)
+ */
readonly visibilityState: DocumentVisibilityState;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focus) */
+ /**
+ * The **`focus()`** method of the WindowClient interface gives user input focus to the current client and returns a ```js-nolint focus() ``` None.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focus)
+ */
focus(): Promise<WindowClient>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/navigate) */
+ /**
+ * The **`navigate()`** method of the WindowClient interface loads a specified URL into a controlled client page then returns a ```js-nolint navigate(url) ``` - `url` - : The location to navigate to.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/navigate)
+ */
navigate(url: string | URL): Promise<WindowClient | null>;
}
declare var WindowClient: {
@@ -8436,72 +11972,66 @@
interface WindowOrWorkerGlobalScope {
/**
* Available only in secure contexts.
*
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/caches)
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/caches)
*/
readonly caches: CacheStorage;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/crossOriginIsolated) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/crossOriginIsolated) */
readonly crossOriginIsolated: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/crypto_property) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/crypto) */
readonly crypto: Crypto;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/indexedDB) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/indexedDB) */
readonly indexedDB: IDBFactory;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/isSecureContext) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/isSecureContext) */
readonly isSecureContext: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/origin) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/origin) */
readonly origin: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/performance_property) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/performance) */
readonly performance: Performance;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/atob) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/atob) */
atob(data: string): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/btoa) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/btoa) */
btoa(data: string): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearInterval) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearInterval) */
clearInterval(id: number | undefined): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearTimeout) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout) */
clearTimeout(id: number | undefined): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/createImageBitmap) */
createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */
fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/queueMicrotask) */
queueMicrotask(callback: VoidFunction): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/reportError) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/reportError) */
reportError(e: any): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setInterval) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */
setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setTimeout) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */
setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/structuredClone) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/structuredClone) */
structuredClone<T = any>(value: T, options?: StructuredSerializeOptions): T;
}
-interface WorkerEventMap extends AbstractWorkerEventMap {
- "message": MessageEvent;
- "messageerror": MessageEvent;
+interface WorkerEventMap extends AbstractWorkerEventMap, MessageEventTargetEventMap {
}
/**
- * This Web Workers API interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread.
+ * The **`Worker`** interface of the Web Workers API represents a background task that can be created via script, which can send messages back to its creator.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Worker)
*/
-interface Worker extends EventTarget, AbstractWorker {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Worker/message_event) */
- onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Worker/messageerror_event) */
- onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
+interface Worker extends EventTarget, AbstractWorker, MessageEventTarget<Worker> {
/**
- * Clones message and transmits it to worker's global environment. transfer can be passed as a list of objects that are to be transferred rather than cloned.
+ * The **`postMessage()`** method of the Worker interface sends a message to the worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Worker/postMessage)
*/
postMessage(message: any, transfer: Transferable[]): void;
postMessage(message: any, options?: StructuredSerializeOptions): void;
/**
- * Aborts worker's associated global environment.
+ * The **`terminate()`** method of the Worker interface immediately terminates the Worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Worker/terminate)
*/
terminate(): void;
@@ -8525,21 +12055,21 @@
"unhandledrejection": PromiseRejectionEvent;
}
/**
- * This Web Workers API interface is an interface representing the scope of any worker. Workers have no browsing context; this scope contains the information usually conveyed by Window objects — in this case event handlers, the console or the associated WorkerNavigator object. Each WorkerGlobalScope has its own event loop.
+ * The **`WorkerGlobalScope`** interface of the Web Workers API is an interface representing the scope of any worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope)
*/
interface WorkerGlobalScope extends EventTarget, FontFaceSource, WindowOrWorkerGlobalScope {
/**
- * Returns workerGlobal's WorkerLocation object.
+ * The **`location`** read-only property of the WorkerGlobalScope interface returns the WorkerLocation associated with the worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/location)
*/
readonly location: WorkerLocation;
/**
- * Returns workerGlobal's WorkerNavigator object.
+ * The **`navigator`** read-only property of the WorkerGlobalScope interface returns the WorkerNavigator associated with the worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/navigator)
*/
readonly navigator: WorkerNavigator;
@@ -8550,18 +12080,20 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/offline_event) */
onoffline: ((this: WorkerGlobalScope, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/online_event) */
ononline: ((this: WorkerGlobalScope, ev: Event) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/rejectionhandled_event) */
onrejectionhandled: ((this: WorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
+ /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/unhandledrejection_event) */
onunhandledrejection: ((this: WorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
/**
- * Returns workerGlobal.
+ * The **`self`** read-only property of the WorkerGlobalScope interface returns a reference to the `WorkerGlobalScope` itself.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/self)
*/
readonly self: WorkerGlobalScope & typeof globalThis;
/**
- * Fetches each URL in urls, executes them one-by-one in the order they are passed, and then returns (or throws if something went amiss).
+ * The **`importScripts()`** method of the WorkerGlobalScope interface synchronously imports one or more scripts into the worker's scope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/importScripts)
*/
importScripts(...urls: (string | URL)[]): void;
@@ -8576,31 +12108,67 @@
new(): WorkerGlobalScope;
};
/**
- * The absolute location of the script executed by the Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.location property obtained by calling self.location.
+ * The **`WorkerLocation`** interface defines the absolute location of the script executed by the Worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation)
*/
interface WorkerLocation {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/hash) */
+ /**
+ * The **`hash`** property of a WorkerLocation object returns the URL.hash part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/hash)
+ */
readonly hash: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/host) */
+ /**
+ * The **`host`** property of a WorkerLocation object returns the URL.host part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/host)
+ */
readonly host: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/hostname) */
+ /**
+ * The **`hostname`** property of a WorkerLocation object returns the URL.hostname part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/hostname)
+ */
readonly hostname: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/href) */
+ /**
+ * The **`href`** property of a WorkerLocation object returns a string containing the serialized URL for the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/href)
+ */
readonly href: string;
toString(): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/origin) */
+ /**
+ * The **`origin`** property of a WorkerLocation object returns the worker's URL.origin.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/origin)
+ */
readonly origin: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/pathname) */
+ /**
+ * The **`pathname`** property of a WorkerLocation object returns the URL.pathname part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/pathname)
+ */
readonly pathname: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/port) */
+ /**
+ * The **`port`** property of a WorkerLocation object returns the URL.port part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/port)
+ */
readonly port: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/protocol) */
+ /**
+ * The **`protocol`** property of a WorkerLocation object returns the URL.protocol part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/protocol)
+ */
readonly protocol: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/search) */
+ /**
+ * The **`search`** property of a WorkerLocation object returns the URL.search part of the worker's location.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerLocation/search)
+ */
readonly search: string;
}
declare var WorkerLocation: {
@@ -8608,37 +12176,68 @@
new(): WorkerLocation;
};
/**
- * A subset of the Navigator interface allowed to be accessed from a Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.navigator property obtained by calling window.self.navigator.
+ * The **`WorkerNavigator`** interface represents a subset of the Navigator interface allowed to be accessed from a Worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator)
*/
interface WorkerNavigator extends NavigatorBadge, NavigatorConcurrentHardware, NavigatorID, NavigatorLanguage, NavigatorLocks, NavigatorOnLine, NavigatorStorage {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator/mediaCapabilities) */
+ /**
+ * The read-only **`mediaCapabilities`** property of the WorkerNavigator interface references a MediaCapabilities object that can expose information about the decoding and encoding capabilities for a given format and output capabilities (as defined by the Media Capabilities API).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator/mediaCapabilities)
+ */
readonly mediaCapabilities: MediaCapabilities;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator/permissions) */
+ /**
+ * The **`permissions`** read-only property of the WorkerNavigator interface returns a Permissions object that can be used to query and update permission status of APIs covered by the Permissions API.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator/permissions)
+ */
readonly permissions: Permissions;
+ /**
+ * The **`serviceWorker`** read-only property of the WorkerNavigator interface returns the ServiceWorkerContainer object for the associated document, which provides access to registration, removal, upgrade, and communication with the ServiceWorker.
+ * Available only in secure contexts.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerNavigator/serviceWorker)
+ */
+ readonly serviceWorker: ServiceWorkerContainer;
}
declare var WorkerNavigator: {
prototype: WorkerNavigator;
new(): WorkerNavigator;
};
/**
- * 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.
+ * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream)
*/
interface WritableStream<W = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/locked) */
+ /**
+ * The **`locked`** read-only property of the WritableStream interface returns a boolean indicating whether the `WritableStream` is locked to a writer.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/locked)
+ */
readonly locked: boolean;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/abort) */
+ /**
+ * The **`abort()`** method of the WritableStream interface aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be immediately moved to an error state, with any queued writes discarded.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/abort)
+ */
abort(reason?: any): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/close) */
+ /**
+ * The **`close()`** method of the WritableStream interface closes the associated stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/close)
+ */
close(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter) */
+ /**
+ * The **`getWriter()`** method of the WritableStream interface returns a new instance of WritableStreamDefaultWriter and locks the stream to that instance.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter)
+ */
getWriter(): WritableStreamDefaultWriter<W>;
}
declare var WritableStream: {
@@ -8646,16 +12245,24 @@
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.
+ * The **`WritableStreamDefaultController`** interface of the Streams API represents a controller allowing control of a WritableStream's state.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController)
*/
interface WritableStreamDefaultController {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/signal) */
+ /**
+ * The read-only **`signal`** property of the WritableStreamDefaultController interface returns the AbortSignal associated with the controller.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/signal)
+ */
readonly signal: AbortSignal;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/error) */
+ /**
+ * The **`error()`** method of the with the associated stream to error.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/error)
+ */
error(e?: any): void;
}
declare var WritableStreamDefaultController: {
@@ -8663,26 +12270,54 @@
new(): 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.
+ * The **`WritableStreamDefaultWriter`** interface of the Streams API 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.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter)
*/
interface WritableStreamDefaultWriter<W = any> {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/closed) */
- readonly closed: Promise<undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/desiredSize) */
+ /**
+ * The **`closed`** read-only property of the the stream errors or the writer's lock is released.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/closed)
+ */
+ readonly closed: Promise<void>;
+ /**
+ * The **`desiredSize`** read-only property of the to fill the stream's internal queue.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/desiredSize)
+ */
readonly desiredSize: number | null;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/ready) */
- readonly ready: Promise<undefined>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/abort) */
+ /**
+ * The **`ready`** read-only property of the that resolves when the desired size of the stream's internal queue transitions from non-positive to positive, signaling that it is no longer applying backpressure.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/ready)
+ */
+ readonly ready: Promise<void>;
+ /**
+ * The **`abort()`** method of the the producer can no longer successfully write to the stream and it is to be immediately moved to an error state, with any queued writes discarded.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/abort)
+ */
abort(reason?: any): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/close) */
+ /**
+ * The **`close()`** method of the stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/close)
+ */
close(): Promise<void>;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/releaseLock) */
+ /**
+ * The **`releaseLock()`** method of the corresponding stream.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/releaseLock)
+ */
releaseLock(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/write) */
+ /**
+ * The **`write()`** method of the operation.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/write)
+ */
write(chunk?: W): Promise<void>;
}
declare var WritableStreamDefaultWriter: {
@@ -8694,123 +12329,115 @@
"readystatechange": Event;
}
/**
- * Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.
+ * `XMLHttpRequest` (XHR) objects are used to interact with servers.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest)
*/
interface XMLHttpRequest extends XMLHttpRequestEventTarget {
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readystatechange_event) */
onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
/**
- * Returns client's state.
+ * The **XMLHttpRequest.readyState** property returns the state an XMLHttpRequest client is in.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readyState)
*/
readonly readyState: number;
/**
- * Returns the response body.
+ * The XMLHttpRequest **`response`** property returns the response's body content as an ArrayBuffer, a Blob, a Document, a JavaScript Object, or a string, depending on the value of the request's XMLHttpRequest.responseType property.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/response)
*/
readonly response: any;
/**
- * Returns response as text.
+ * The read-only XMLHttpRequest property **`responseText`** returns the text received from a server following a request being sent.
*
- * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseText)
*/
readonly responseText: string;
/**
- * Returns the response type.
+ * The XMLHttpRequest property **`responseType`** is an enumerated string value specifying the type of data contained in the response.
*
- * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
- *
- * When set: setting to "document" is ignored if current global object is not a Window object.
- *
- * When set: throws an "InvalidStateError" DOMException if state is loading or done.
- *
- * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseType)
*/
responseType: XMLHttpRequestResponseType;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL) */
+ /**
+ * The read-only **`XMLHttpRequest.responseURL`** property returns the serialized URL of the response or the empty string if the URL is `null`.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL)
+ */
readonly responseURL: string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status) */
+ /**
+ * The read-only **`XMLHttpRequest.status`** property returns the numerical HTTP status code of the `XMLHttpRequest`'s response.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status)
+ */
readonly status: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText) */
+ /**
+ * The read-only **`XMLHttpRequest.statusText`** property returns a string containing the response's status message as returned by the HTTP server.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText)
+ */
readonly statusText: string;
/**
- * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and this's synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
+ * The **`XMLHttpRequest.timeout`** property is an `unsigned long` representing the number of milliseconds a request can take before automatically being terminated.
*
- * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/timeout)
*/
timeout: number;
/**
- * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
+ * The XMLHttpRequest `upload` property returns an XMLHttpRequestUpload object that can be observed to monitor an upload's progress.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/upload)
*/
readonly upload: XMLHttpRequestUpload;
/**
- * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
+ * The **`XMLHttpRequest.withCredentials`** property is a boolean value that indicates whether or not cross-site `Access-Control` requests should be made using credentials such as cookies, authentication headers or TLS client certificates.
*
- * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/withCredentials)
*/
withCredentials: boolean;
/**
- * Cancels any network activity.
+ * The **`XMLHttpRequest.abort()`** method aborts the request if it has already been sent.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/abort)
*/
abort(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/getAllResponseHeaders) */
+ /**
+ * The XMLHttpRequest method **`getAllResponseHeaders()`** returns all the response headers, separated by CRLF, as a string, or returns `null` if no response has been received.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/getAllResponseHeaders)
+ */
getAllResponseHeaders(): string;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/getResponseHeader) */
+ /**
+ * The XMLHttpRequest method **`getResponseHeader()`** returns the string containing the text of a particular header's value.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/getResponseHeader)
+ */
getResponseHeader(name: string): string | null;
/**
- * Sets the request method, request URL, and synchronous flag.
+ * The XMLHttpRequest method **`open()`** initializes a newly-created request, or re-initializes an existing one.
*
- * Throws a "SyntaxError" DOMException if either method is not a valid method or url cannot be parsed.
- *
- * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
- *
- * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/open)
*/
open(method: string, url: string | URL): void;
open(method: string, url: string | URL, async: boolean, username?: string | null, password?: string | null): void;
/**
- * Acts as if the `Content-Type` header value for a response is mime. (It does not change the header.)
+ * The XMLHttpRequest method **`overrideMimeType()`** specifies a MIME type other than the one provided by the server to be used instead when interpreting the data being transferred in a request.
*
- * Throws an "InvalidStateError" DOMException if state is loading or done.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/overrideMimeType)
*/
overrideMimeType(mime: string): void;
/**
- * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
+ * The XMLHttpRequest method **`send()`** sends the request to the server.
*
- * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/send)
*/
send(body?: XMLHttpRequestBodyInit | null): void;
/**
- * Combines a header in author request headers.
+ * The XMLHttpRequest method **`setRequestHeader()`** sets the value of an HTTP request header.
*
- * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
- *
- * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
- *
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/setRequestHeader)
*/
setRequestHeader(name: string, value: string): void;
readonly UNSENT: 0;
@@ -8843,9 +12470,13 @@
"progress": ProgressEvent<XMLHttpRequestEventTarget>;
"timeout": ProgressEvent<XMLHttpRequestEventTarget>;
}
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequestEventTarget) */
+/**
+ * `XMLHttpRequestEventTarget` is the interface that describes the event handlers shared on XMLHttpRequest and XMLHttpRequestUpload.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequestEventTarget)
+ */
interface XMLHttpRequestEventTarget extends EventTarget {
onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
@@ -8863,9 +12494,13 @@
prototype: XMLHttpRequestEventTarget;
new(): XMLHttpRequestEventTarget;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequestUpload) */
+/**
+ * The **`XMLHttpRequestUpload`** interface represents the upload process for a specific XMLHttpRequest.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/XMLHttpRequestUpload)
+ */
interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -8876,53 +12511,8 @@
prototype: XMLHttpRequestUpload;
new(): XMLHttpRequestUpload;
};
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
-interface Console {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert_static) */
- assert(condition?: boolean, ...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear_static) */
- clear(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */
- count(label?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */
- countReset(label?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */
- debug(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir_static) */
- dir(item?: any, options?: any): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml_static) */
- dirxml(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static) */
- error(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */
- group(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */
- groupCollapsed(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */
- groupEnd(): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */
- info(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static) */
- log(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table_static) */
- table(tabularData?: any, properties?: string[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */
- time(label?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */
- timeEnd(label?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */
- timeLog(label?: string, ...data: any[]): void;
- timeStamp(label?: string): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */
- trace(...data: any[]): void;
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static) */
- warn(...data: any[]): void;
-}
-
-declare var console: Console;
-
declare namespace WebAssembly {
interface CompileError extends Error {
}
@@ -8931,24 +12521,22 @@
new(message?: string): CompileError;
(message?: string): CompileError;
};
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Global) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Global) */
interface Global<T extends ValueType = ValueType> {
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Global/value) */
value: ValueTypeMap[T];
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Global/valueOf) */
valueOf(): ValueTypeMap[T];
}
var Global: {
prototype: Global;
new<T extends ValueType = ValueType>(descriptor: GlobalDescriptor<T>, v?: ValueTypeMap[T]): Global<T>;
};
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Instance) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Instance) */
interface Instance {
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Instance/exports) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Instance/exports) */
readonly exports: Exports;
}
var Instance: {
@@ -8964,33 +12552,33 @@
new(message?: string): LinkError;
(message?: string): LinkError;
};
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Memory) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Memory) */
interface Memory {
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Memory/buffer) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Memory/buffer) */
readonly buffer: ArrayBuffer;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Memory/grow) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Memory/grow) */
grow(delta: number): number;
}
var Memory: {
prototype: Memory;
new(descriptor: MemoryDescriptor): Memory;
};
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Module) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Module) */
interface Module {
}
var Module: {
prototype: Module;
new(bytes: BufferSource): Module;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Module/customSections_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Module/customSections_static) */
customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Module/exports_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Module/exports_static) */
exports(moduleObject: Module): ModuleExportDescriptor[];
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Module/imports_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Module/imports_static) */
imports(moduleObject: Module): ModuleImportDescriptor[];
};
interface RuntimeError extends Error {
@@ -9001,17 +12589,17 @@
new(message?: string): RuntimeError;
(message?: string): RuntimeError;
};
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Table) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Table) */
interface Table {
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Table/length) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Table/length) */
readonly length: number;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Table/get) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Table/get) */
get(index: number): any;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Table/grow) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Table/grow) */
grow(delta: number, value?: any): number;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/Table/set) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/Table/set) */
set(index: number, value?: any): void;
}
var Table: {
@@ -9069,31 +12657,165 @@
type ImportValue = ExportValue | number;
type Imports = Record<string, ModuleImports>;
type ModuleImports = Record<string, ImportValue>;
type ValueType = keyof ValueTypeMap;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/compile_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/compile_static) */
function compile(bytes: BufferSource): Promise<Module>;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/compileStreaming_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/compileStreaming_static) */
function compileStreaming(source: Response | PromiseLike<Response>): Promise<Module>;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/instantiate_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/instantiate_static) */
function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/instantiateStreaming_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/instantiateStreaming_static) */
function instantiateStreaming(source: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
- /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/JavaScript_interface/validate_static) */
+ /** [MDN Reference](https://developer.mozilla.org/docs/WebAssembly/Reference/JavaScript_interface/validate_static) */
function validate(bytes: BufferSource): boolean;
}
+/** The **`console`** object provides access to the debugging console (e.g., the Web console in Firefox). */
+/**
+ * The **`console`** object provides access to the debugging console (e.g., the Web console in Firefox).
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console)
+ */
+interface Console {
+ /**
+ * The **`console.assert()`** static method writes an error message to the console if the assertion is false.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert_static)
+ */
+ assert(condition?: boolean, ...data: any[]): void;
+ /**
+ * The **`console.clear()`** static method clears the console if possible.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear_static)
+ */
+ clear(): void;
+ /**
+ * The **`console.count()`** static method logs the number of times that this particular call to `count()` has been called.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static)
+ */
+ count(label?: string): void;
+ /**
+ * The **`console.countReset()`** static method resets counter used with console/count_static.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static)
+ */
+ countReset(label?: string): void;
+ /**
+ * The **`console.debug()`** static method outputs a message to the console at the 'debug' log level.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static)
+ */
+ debug(...data: any[]): void;
+ /**
+ * The **`console.dir()`** static method displays a list of the properties of the specified JavaScript object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir_static)
+ */
+ dir(item?: any, options?: any): void;
+ /**
+ * The **`console.dirxml()`** static method displays an interactive tree of the descendant elements of the specified XML/HTML element.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml_static)
+ */
+ dirxml(...data: any[]): void;
+ /**
+ * The **`console.error()`** static method outputs a message to the console at the 'error' log level.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
+ */
+ error(...data: any[]): void;
+ /**
+ * The **`console.group()`** static method creates a new inline group in the Web console log, causing any subsequent console messages to be indented by an additional level, until console/groupEnd_static is called.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static)
+ */
+ group(...data: any[]): void;
+ /**
+ * The **`console.groupCollapsed()`** static method creates a new inline group in the console.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static)
+ */
+ groupCollapsed(...data: any[]): void;
+ /**
+ * The **`console.groupEnd()`** static method exits the current inline group in the console.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static)
+ */
+ groupEnd(): void;
+ /**
+ * The **`console.info()`** static method outputs a message to the console at the 'info' log level.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static)
+ */
+ info(...data: any[]): void;
+ /**
+ * The **`console.log()`** static method outputs a message to the console.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
+ */
+ log(...data: any[]): void;
+ /**
+ * The **`console.table()`** static method displays tabular data as a table.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table_static)
+ */
+ table(tabularData?: any, properties?: string[]): void;
+ /**
+ * The **`console.time()`** static method starts a timer you can use to track how long an operation takes.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static)
+ */
+ time(label?: string): void;
+ /**
+ * The **`console.timeEnd()`** static method stops a timer that was previously started by calling console/time_static.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static)
+ */
+ timeEnd(label?: string): void;
+ /**
+ * The **`console.timeLog()`** static method logs the current value of a timer that was previously started by calling console/time_static.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static)
+ */
+ timeLog(label?: string, ...data: any[]): void;
+ timeStamp(label?: string): void;
+ /**
+ * The **`console.trace()`** static method outputs a stack trace to the console.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static)
+ */
+ trace(...data: any[]): void;
+ /**
+ * The **`console.warn()`** static method outputs a warning message to the console at the 'warning' log level.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static)
+ */
+ warn(...data: any[]): void;
+}
+
+declare var console: Console;
+
+interface AudioDataOutputCallback {
+ (output: AudioData): void;
+}
+
+interface EncodedAudioChunkOutputCallback {
+ (output: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void;
+}
+
interface EncodedVideoChunkOutputCallback {
(chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void;
}
interface FrameRequestCallback {
(time: DOMHighResTimeStamp): void;
}
-interface LockGrantedCallback {
- (lock: Lock | null): any;
+interface LockGrantedCallback<T> {
+ (lock: Lock | null): T;
}
interface OnErrorEventHandlerNonNull {
(event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
@@ -9163,46 +12885,42 @@
(error: DOMException): void;
}
/**
- * Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging.
+ * The **`name`** read-only property of the the Worker.Worker constructor can pass to get a reference to the DedicatedWorkerGlobalScope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/name)
*/
declare var name: string;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/message_event) */
-declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */
-declare var onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/rtctransform_event) */
-declare var onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
+declare var onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: RTCTransformEvent) => any) | null;
/**
- * Aborts dedicatedWorkerGlobal.
+ * The **`close()`** method of the DedicatedWorkerGlobalScope interface discards any tasks queued in the `DedicatedWorkerGlobalScope`'s event loop, effectively closing this particular scope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/close)
*/
declare function close(): void;
/**
- * Clones message and transmits it to the Worker object associated with dedicatedWorkerGlobal. transfer can be passed as a list of objects that are to be transferred rather than cloned.
+ * The **`postMessage()`** method of the DedicatedWorkerGlobalScope interface sends a message to the main thread that spawned it.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/postMessage)
*/
declare function postMessage(message: any, transfer: Transferable[]): void;
declare function postMessage(message: any, options?: StructuredSerializeOptions): 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.
+ * The **`dispatchEvent()`** method of the EventTarget sends an Event to the object, (synchronously) invoking the affected event listeners in the appropriate order.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent)
*/
declare function dispatchEvent(event: Event): boolean;
/**
- * Returns workerGlobal's WorkerLocation object.
+ * The **`location`** read-only property of the WorkerGlobalScope interface returns the WorkerLocation associated with the worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/location)
*/
declare var location: WorkerLocation;
/**
- * Returns workerGlobal's WorkerNavigator object.
+ * The **`navigator`** read-only property of the WorkerGlobalScope interface returns the WorkerNavigator associated with the worker.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/navigator)
*/
declare var navigator: WorkerNavigator;
@@ -9213,24 +12931,26 @@
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/offline_event) */
declare var onoffline: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/online_event) */
declare var ononline: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/rejectionhandled_event) */
declare var onrejectionhandled: ((this: DedicatedWorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/unhandledrejection_event) */
declare var onunhandledrejection: ((this: DedicatedWorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
/**
- * Returns workerGlobal.
+ * The **`self`** read-only property of the WorkerGlobalScope interface returns a reference to the `WorkerGlobalScope` itself.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/self)
*/
declare var self: WorkerGlobalScope & typeof globalThis;
/**
- * Fetches each URL in urls, executes them one-by-one in the order they are passed, and then returns (or throws if something went amiss).
+ * The **`importScripts()`** method of the WorkerGlobalScope interface synchronously imports one or more scripts into the worker's scope.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WorkerGlobalScope/importScripts)
*/
declare function importScripts(...urls: (string | URL)[]): 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.
+ * The **`dispatchEvent()`** method of the EventTarget sends an Event to the object, (synchronously) invoking the affected event listeners in the appropriate order.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent)
*/
declare function dispatchEvent(event: Event): boolean;
@@ -9238,71 +12958,75 @@
declare var fonts: FontFaceSet;
/**
* Available only in secure contexts.
*
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/caches)
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/caches)
*/
declare var caches: CacheStorage;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/crossOriginIsolated) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/crossOriginIsolated) */
declare var crossOriginIsolated: boolean;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/crypto_property) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/crypto) */
declare var crypto: Crypto;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/indexedDB) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/indexedDB) */
declare var indexedDB: IDBFactory;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/isSecureContext) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/isSecureContext) */
declare var isSecureContext: boolean;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/origin) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/origin) */
declare var origin: string;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/performance_property) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/performance) */
declare var performance: Performance;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/atob) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/atob) */
declare function atob(data: string): string;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/btoa) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/btoa) */
declare function btoa(data: string): string;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearInterval) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearInterval) */
declare function clearInterval(id: number | undefined): void;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearTimeout) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout) */
declare function clearTimeout(id: number | undefined): void;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/createImageBitmap) */
declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */
declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/queueMicrotask) */
declare function queueMicrotask(callback: VoidFunction): void;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/reportError) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/reportError) */
declare function reportError(e: any): void;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setInterval) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setTimeout) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/structuredClone) */
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/structuredClone) */
declare function structuredClone<T = any>(value: T, options?: StructuredSerializeOptions): T;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */
declare function cancelAnimationFrame(handle: number): void;
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */
declare function requestAnimationFrame(callback: FrameRequestCallback): number;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/message_event) */
+declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */
+declare var onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
declare function addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
declare function removeEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
type AlgorithmIdentifier = Algorithm | string;
-type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView;
-type BigInteger = Uint8Array;
-type BinaryData = ArrayBuffer | ArrayBufferView;
+type AllowSharedBufferSource = ArrayBufferLike | ArrayBufferView<ArrayBufferLike>;
+type BigInteger = Uint8Array<ArrayBuffer>;
type BlobPart = BufferSource | Blob | string;
type BodyInit = ReadableStream | XMLHttpRequestBodyInit;
-type BufferSource = ArrayBufferView | ArrayBuffer;
+type BufferSource = ArrayBufferView<ArrayBuffer> | ArrayBuffer;
type CSSKeywordish = string | CSSKeywordValue;
type CSSNumberish = number | CSSNumericValue;
type CSSPerspectiveValue = CSSNumericValue | CSSKeywordish;
type CSSUnparsedSegment = string | CSSVariableReferenceValue;
type CanvasImageSource = ImageBitmap | OffscreenCanvas | VideoFrame;
+type CookieList = CookieListItem[];
type DOMHighResTimeStamp = number;
type EpochTimeStamp = number;
type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
type FileSystemWriteChunkType = BufferSource | Blob | string | WriteParams;
-type Float32List = Float32Array | GLfloat[];
+type Float32List = Float32Array<ArrayBufferLike> | GLfloat[];
type FormDataEntryValue = File | string;
type GLbitfield = number;
type GLboolean = boolean;
type GLclampf = number;
@@ -9318,9 +13042,11 @@
type HashAlgorithmIdentifier = AlgorithmIdentifier;
type HeadersInit = [string, string][] | Record<string, string> | Headers;
type IDBValidKey = number | string | Date | BufferSource | IDBValidKey[];
type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
-type Int32List = Int32Array | GLint[];
+type ImageBufferSource = AllowSharedBufferSource | ReadableStream;
+type ImageDataArray = Uint8ClampedArray<ArrayBuffer>;
+type Int32List = Int32Array<ArrayBufferLike> | GLint[];
type MessageEventSource = MessagePort | ServiceWorker;
type NamedCurve = string;
type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
@@ -9332,14 +13058,16 @@
type ReportList = Report[];
type RequestInfo = Request | string;
type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas | VideoFrame;
type TimerHandler = string | Function;
-type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | ReadableStream | WritableStream | TransformStream | VideoFrame | ArrayBuffer;
-type Uint32List = Uint32Array | GLuint[];
+type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | MediaSourceHandle | ReadableStream | WritableStream | TransformStream | AudioData | VideoFrame | RTCDataChannel | ArrayBuffer;
+type Uint32List = Uint32Array<ArrayBufferLike> | GLuint[];
type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string;
type AlphaOption = "discard" | "keep";
+type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar";
type AvcBitstreamFormat = "annexb" | "avc";
type BinaryType = "arraybuffer" | "blob";
+type BitrateMode = "constant" | "variable";
type CSSMathOperator = "clamp" | "invert" | "max" | "min" | "negate" | "product" | "sum";
type CSSNumericBaseType = "angle" | "flex" | "frequency" | "length" | "percent" | "resolution" | "time";
type CanvasDirection = "inherit" | "ltr" | "rtl";
type CanvasFillRule = "evenodd" | "nonzero";
@@ -9355,9 +13083,11 @@
type CodecState = "closed" | "configured" | "unconfigured";
type ColorGamut = "p3" | "rec2020" | "srgb";
type ColorSpaceConversion = "default" | "none";
type CompressionFormat = "deflate" | "deflate-raw" | "gzip";
+type CookieSameSite = "lax" | "none" | "strict";
type DocumentVisibilityState = "hidden" | "visible";
+type EncodedAudioChunkType = "delta" | "key";
type EncodedVideoChunkType = "delta" | "key";
type EndingType = "native" | "transparent";
type FileSystemHandleKind = "directory" | "file";
type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap";
@@ -9379,16 +13109,19 @@
type LatencyMode = "quality" | "realtime";
type LockMode = "exclusive" | "shared";
type MediaDecodingType = "file" | "media-source" | "webrtc";
type MediaEncodingType = "record" | "webrtc";
+type MediaKeysRequirement = "not-allowed" | "optional" | "required";
type NotificationDirection = "auto" | "ltr" | "rtl";
type NotificationPermission = "default" | "denied" | "granted";
type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu";
-type PermissionName = "geolocation" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "xr-spatial-tracking";
+type OpusBitstreamFormat = "ogg" | "opus";
+type PermissionName = "camera" | "geolocation" | "microphone" | "midi" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "storage-access";
type PermissionState = "denied" | "granted" | "prompt";
type PredefinedColorSpace = "display-p3" | "srgb";
type PremultiplyAlpha = "default" | "none" | "premultiply";
type PushEncryptionKeyName = "auth" | "p256dh";
+type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
type RTCEncodedVideoFrameType = "delta" | "empty" | "key";
type ReadableStreamReaderMode = "byob";
type ReadableStreamType = "bytes";
type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";