interface AddEventListenerOptions extends EventListenerOptions {
once?: boolean;
passive?: boolean;
+ signal?: AbortSignal;
}
interface AesCbcParams extends Algorithm {
- iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ iv: BufferSource;
}
interface AesCtrParams extends Algorithm {
- counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ counter: BufferSource;
length: number;
}
}
interface AesGcmParams extends Algorithm {
- additionalData?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
- iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ additionalData?: BufferSource;
+ iv: BufferSource;
tagLength?: number;
}
name: string;
}
+interface AudioConfiguration {
+ bitrate?: number;
+ channels?: string;
+ contentType: string;
+ samplerate?: number;
+ spatialRendering?: boolean;
+}
+
interface BlobPropertyBag {
endings?: EndingType;
type?: string;
ignoreVary?: boolean;
}
-interface CanvasRenderingContext2DSettings {
- alpha?: boolean;
- desynchronized?: boolean;
-}
-
interface ClientQueryOptions {
includeUncontrolled?: boolean;
type?: ClientTypes;
y?: number;
}
-interface DevicePermissionDescriptor extends PermissionDescriptor {
- deviceId?: string;
- name: "camera" | "microphone" | "speaker";
-}
-
interface EcKeyGenParams extends Algorithm {
namedCurve: NamedCurve;
}
interface FetchEventInit extends ExtendableEventInit {
clientId?: string;
+ handled?: Promise<undefined>;
preloadResponse?: Promise<any>;
replacesClientId?: string;
request: Request;
lastModified?: number;
}
+interface FontFaceDescriptors {
+ display?: string;
+ featureSettings?: string;
+ stretch?: string;
+ style?: string;
+ unicodeRange?: string;
+ variant?: string;
+ weight?: string;
+}
+
+interface FontFaceSetLoadEventInit extends EventInit {
+ fontfaces?: FontFace[];
+}
+
interface GetNotificationOptions {
tag?: string;
}
interface HkdfParams extends Algorithm {
hash: HashAlgorithmIdentifier;
- info: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
- salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ info: BufferSource;
+ salt: BufferSource;
}
interface HmacImportParams extends Algorithm {
length?: number;
}
+interface IDBDatabaseInfo {
+ name?: string;
+ version?: number;
+}
+
interface IDBIndexParameters {
multiEntry?: boolean;
unique?: boolean;
alpha?: boolean;
}
-interface ImageEncodeOptions {
- quality?: number;
- type?: string;
+interface ImageDataSettings {
+ colorSpace?: PredefinedColorSpace;
}
interface ImportMeta {
name: string;
}
+interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {
+ configuration?: MediaDecodingConfiguration;
+}
+
+interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {
+ configuration?: MediaEncodingConfiguration;
+}
+
+interface MediaCapabilitiesInfo {
+ powerEfficient: boolean;
+ smooth: boolean;
+ supported: boolean;
+}
+
+interface MediaConfiguration {
+ audio?: AudioConfiguration;
+ video?: VideoConfiguration;
+}
+
+interface MediaDecodingConfiguration extends MediaConfiguration {
+ type: MediaDecodingType;
+}
+
+interface MediaEncodingConfiguration extends MediaConfiguration {
+ type: MediaEncodingType;
+}
+
interface MessageEventInit<T = any> extends EventInit {
data?: T;
lastEventId?: string;
source?: MessageEventSource | null;
}
-interface MidiPermissionDescriptor extends PermissionDescriptor {
- name: "midi";
- sysex?: boolean;
-}
-
interface MultiCacheQueryOptions extends CacheQueryOptions {
cacheName?: string;
}
-interface NavigationPreloadState {
- enabled?: boolean;
- headerValue?: string;
-}
-
interface NotificationAction {
action: string;
icon?: string;
requireInteraction?: boolean;
silent?: boolean;
tag?: string;
- timestamp?: number;
+ timestamp?: DOMTimeStamp;
vibrate?: VibratePattern;
}
interface Pbkdf2Params extends Algorithm {
hash: HashAlgorithmIdentifier;
iterations: number;
- salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ salt: BufferSource;
+}
+
+interface PerformanceMarkOptions {
+ detail?: any;
+ startTime?: DOMHighResTimeStamp;
+}
+
+interface PerformanceMeasureOptions {
+ detail?: any;
+ duration?: DOMHighResTimeStamp;
+ end?: string | DOMHighResTimeStamp;
+ start?: string | DOMHighResTimeStamp;
}
interface PerformanceObserverInit {
name: PermissionName;
}
-interface PostMessageOptions {
- transfer?: any[];
-}
-
interface ProgressEventInit extends EventInit {
lengthComputable?: boolean;
loaded?: number;
data?: PushMessageDataInit;
}
-interface PushPermissionDescriptor extends PermissionDescriptor {
- name: "push";
- userVisibleOnly?: boolean;
-}
-
-interface PushSubscriptionChangeEventInit extends ExtendableEventInit {
- newSubscription?: PushSubscription;
- oldSubscription?: PushSubscription;
-}
-
interface PushSubscriptionJSON {
endpoint?: string;
- expirationTime?: number | null;
+ expirationTime?: DOMTimeStamp | null;
keys?: Record<string, string>;
}
interface QueuingStrategyInit {
/**
* Creates a new ByteLengthQueuingStrategy with the provided high water mark.
- *
+ *
* Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
*/
highWaterMark: number;
readable: ReadableStream<R>;
/**
* Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
- *
+ *
* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
*/
writable: WritableStream<W>;
}
interface RequestInit {
- /**
- * A BodyInit object or null to set request's body.
- */
+ /** A BodyInit object or null to set request's body. */
body?: BodyInit | null;
- /**
- * A string indicating how the request will interact with the browser's cache to set request's cache.
- */
+ /** A string indicating how the request will interact with the browser's cache to set request's cache. */
cache?: RequestCache;
- /**
- * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
- */
+ /** A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. */
credentials?: RequestCredentials;
- /**
- * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
- */
+ /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */
headers?: HeadersInit;
- /**
- * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
- */
+ /** A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */
integrity?: string;
- /**
- * A boolean to set request's keepalive.
- */
+ /** A boolean to set request's keepalive. */
keepalive?: boolean;
- /**
- * A string to set request's method.
- */
+ /** A string to set request's method. */
method?: string;
- /**
- * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
- */
+ /** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */
mode?: RequestMode;
- /**
- * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
- */
+ /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
redirect?: RequestRedirect;
- /**
- * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
- */
+ /** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */
referrer?: string;
- /**
- * A referrer policy to set request's referrerPolicy.
- */
+ /** A referrer policy to set request's referrerPolicy. */
referrerPolicy?: ReferrerPolicy;
- /**
- * An AbortSignal to set request's signal.
- */
+ /** An AbortSignal to set request's signal. */
signal?: AbortSignal | null;
- /**
- * Can only be null. Used to disassociate request from any Window.
- */
- window?: any;
+ /** Can only be null. Used to disassociate request from any Window. */
+ window?: null;
}
interface ResponseInit {
}
interface RsaOaepParams extends Algorithm {
- label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
+ label?: BufferSource;
}
interface RsaOtherPrimesInfo {
saltLength: number;
}
+interface SecurityPolicyViolationEventInit extends EventInit {
+ blockedURI?: string;
+ columnNumber?: number;
+ disposition: SecurityPolicyViolationEventDisposition;
+ documentURI: string;
+ effectiveDirective: string;
+ lineNumber?: number;
+ originalPolicy: string;
+ referrer?: string;
+ sample?: string;
+ sourceFile?: string;
+ statusCode: number;
+ violatedDirective: string;
+}
+
interface StorageEstimate {
quota?: number;
usage?: number;
preventCancel?: boolean;
/**
* Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
- *
+ *
* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
- *
+ *
* Errors and closures of the source and destination streams propagate as follows:
- *
+ *
* An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
- *
+ *
* An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
- *
+ *
* When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
- *
+ *
* If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
- *
+ *
* The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
*/
preventClose?: boolean;
signal?: AbortSignal;
}
-interface SyncEventInit extends ExtendableEventInit {
- lastChance?: boolean;
- tag: string;
+interface StructuredSerializeOptions {
+ transfer?: any[];
}
interface TextDecodeOptions {
type?: undefined;
}
+interface VideoConfiguration {
+ bitrate: number;
+ colorGamut?: ColorGamut;
+ contentType: string;
+ framerate: number;
+ hdrMetadataType?: HdrMetadataType;
+ height: number;
+ scalabilityMode?: string;
+ transferFunction?: TransferFunction;
+ width: number;
+}
+
interface WebGLContextAttributes {
alpha?: boolean;
antialias?: boolean;
type?: WorkerType;
}
-interface EventListener {
- (evt: Event): void;
-}
-
/** 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. */
interface ANGLE_instanced_arrays {
drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
/** A controller object that allows you to abort one or more DOM requests as and when desired. */
interface AbortController {
- /**
- * Returns the AbortSignal object associated with this object.
- */
+ /** Returns the AbortSignal object associated with this object. */
readonly signal: AbortSignal;
- /**
- * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
- */
+ /** Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted. */
abort(): void;
}
/** 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. */
interface AbortSignal extends EventTarget {
- /**
- * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
- */
+ /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
readonly aborted: boolean;
onabort: ((this: AbortSignal, ev: Event) => any) | null;
addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
declare var AbortSignal: {
prototype: AbortSignal;
new(): AbortSignal;
+ // abort(): AbortSignal; - To be re-added in the future
};
interface AbstractWorkerEventMap {
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
-interface AesCfbParams extends Algorithm {
- iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
-}
-
-interface AesCmacParams extends Algorithm {
- length: number;
-}
-
interface AnimationFrameProvider {
cancelAnimationFrame(handle: number): void;
requestAnimationFrame(callback: FrameRequestCallback): number;
}
interface BroadcastChannel extends EventTarget {
- /**
- * Returns the channel name (as passed to the constructor).
- */
+ /** Returns the channel name (as passed to the constructor). */
readonly name: string;
onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
- /**
- * Closes the BroadcastChannel object, opening it up to garbage collection.
- */
+ /** Closes the BroadcastChannel object, opening it up to garbage collection. */
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.
- */
+ /** Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays. */
postMessage(message: any): void;
addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
};
-/** 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. */
+/**
+ * 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.
+ * Available only in secure contexts.
+ */
interface Cache {
add(request: RequestInfo): Promise<void>;
addAll(requests: RequestInfo[]): Promise<void>;
new(): Cache;
};
-/** The storage for Cache objects. */
+/**
+ * The storage for Cache objects.
+ * Available only in secure contexts.
+ */
interface CacheStorage {
delete(cacheName: string): Promise<boolean>;
has(cacheName: string): Promise<boolean>;
new(): CacheStorage;
};
-interface CanvasCompositing {
- globalAlpha: number;
- globalCompositeOperation: string;
-}
-
-interface CanvasDrawImage {
- drawImage(image: CanvasImageSource, dx: number, dy: number): void;
- drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
- drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
-}
-
-interface CanvasDrawPath {
- beginPath(): void;
- clip(fillRule?: CanvasFillRule): void;
- clip(path: Path2D, fillRule?: CanvasFillRule): void;
- fill(fillRule?: CanvasFillRule): void;
- fill(path: Path2D, fillRule?: CanvasFillRule): void;
- isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
- isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
- isPointInStroke(x: number, y: number): boolean;
- isPointInStroke(path: Path2D, x: number, y: number): boolean;
- stroke(): void;
- stroke(path: Path2D): void;
-}
-
-interface CanvasFillStrokeStyles {
- fillStyle: string | CanvasGradient | CanvasPattern;
- strokeStyle: string | CanvasGradient | CanvasPattern;
- createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
- createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
- createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
-}
-
-interface CanvasFilters {
- filter: string;
-}
-
/** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
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.
- *
+ *
* Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
*/
addColorStop(offset: number, color: string): void;
new(): CanvasGradient;
};
-interface CanvasImageData {
- createImageData(sw: number, sh: number): ImageData;
- createImageData(imagedata: ImageData): ImageData;
- getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
- 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 {
- imageSmoothingEnabled: boolean;
- imageSmoothingQuality: ImageSmoothingQuality;
-}
-
interface CanvasPath {
- arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+ arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
closePath(): void;
- ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+ ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
lineTo(x: number, y: number): void;
moveTo(x: number, y: number): void;
quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
rect(x: number, y: number, w: number, h: number): void;
}
-interface CanvasPathDrawingStyles {
- lineCap: CanvasLineCap;
- lineDashOffset: number;
- lineJoin: CanvasLineJoin;
- lineWidth: number;
- miterLimit: number;
- getLineDash(): number[];
- 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. */
interface CanvasPattern {
- /**
- * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
- */
+ /** Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation. */
setTransform(transform?: DOMMatrix2DInit): void;
}
new(): CanvasPattern;
};
-interface CanvasRect {
- clearRect(x: number, y: number, w: number, h: number): void;
- fillRect(x: number, y: number, w: number, h: number): void;
- strokeRect(x: number, y: number, w: number, h: number): void;
-}
-
-interface CanvasShadowStyles {
- shadowBlur: number;
- shadowColor: string;
- shadowOffsetX: number;
- shadowOffsetY: number;
-}
-
-interface CanvasState {
- restore(): void;
- save(): void;
-}
-
-interface CanvasText {
- fillText(text: string, x: number, y: number, maxWidth?: number): void;
- measureText(text: string): TextMetrics;
- strokeText(text: string, x: number, y: number, maxWidth?: number): void;
-}
-
-interface CanvasTextDrawingStyles {
- direction: CanvasDirection;
- font: string;
- textAlign: CanvasTextAlign;
- textBaseline: CanvasTextBaseline;
-}
-
-interface CanvasTransform {
- getTransform(): DOMMatrix;
- resetTransform(): void;
- rotate(angle: number): void;
- scale(x: number, y: number): void;
- setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
- setTransform(transform?: DOMMatrix2DInit): void;
- transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
- 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(). */
interface Client {
readonly frameType: FrameType;
readonly id: string;
readonly type: ClientTypes;
readonly url: string;
- postMessage(message: any, transfer?: Transferable[]): void;
+ postMessage(message: any, transfer: Transferable[]): void;
+ postMessage(message: any, options?: StructuredSerializeOptions): void;
}
declare var Client: {
claim(): Promise<void>;
get(id: string): Promise<Client | undefined>;
matchAll<T extends ClientQueryOptions>(options?: T): Promise<ReadonlyArray<T["type"] extends "window" ? WindowClient : Client>>;
- openWindow(url: string): Promise<WindowClient | null>;
+ openWindow(url: string | URL): Promise<WindowClient | null>;
}
declare var 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. */
interface CloseEvent extends Event {
- /**
- * Returns the WebSocket connection close code provided by the server.
- */
+ /** Returns the WebSocket connection close code provided by the server. */
readonly code: number;
- /**
- * Returns the WebSocket connection close reason provided by the server.
- */
+ /** Returns the WebSocket connection close reason provided by the server. */
readonly reason: string;
- /**
- * Returns true if the connection closed cleanly; false otherwise.
- */
+ /** Returns true if the connection closed cleanly; false otherwise. */
readonly wasClean: boolean;
}
new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
};
-interface ConcatParams extends Algorithm {
- algorithmId: Uint8Array;
- hash?: string | Algorithm;
- partyUInfo: Uint8Array;
- partyVInfo: Uint8Array;
- privateInfo?: Uint8Array;
- publicInfo?: Uint8Array;
-}
-
/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
interface CountQueuingStrategy extends QueuingStrategy {
readonly highWaterMark: number;
/** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
interface Crypto {
+ /** Available only in secure contexts. */
readonly subtle: SubtleCrypto;
- getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
+ getRandomValues<T extends ArrayBufferView | null>(array: T): T;
}
declare var Crypto: {
new(): Crypto;
};
-/** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
+/**
+ * The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.
+ * Available only in secure contexts.
+ */
interface CryptoKey {
readonly algorithm: KeyAlgorithm;
readonly extractable: boolean;
};
interface CustomEvent<T = any> extends Event {
- /**
- * Returns any custom data event was created with. Typically used for synthetic events.
- */
+ /** Returns any custom data event was created with. Typically used for synthetic events. */
readonly detail: T;
- initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
+ /** @deprecated */
+ initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
}
declare var CustomEvent: {
prototype: CustomEvent;
- new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
+ 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. */
-interface DOMException {
+interface DOMException extends Error {
readonly code: number;
readonly message: string;
readonly name: string;
/** A type returned by some APIs which contains a list of DOMString (strings). */
interface DOMStringList {
- /**
- * Returns the number of strings in strings.
- */
+ /** Returns the number of strings in strings. */
readonly length: number;
- /**
- * Returns true if strings contains string, and false otherwise.
- */
+ /** Returns true if strings contains string, and false otherwise. */
contains(string: string): boolean;
- /**
- * Returns the string with index index from strings.
- */
+ /** Returns the string with index index from strings. */
item(index: number): string | null;
[index: number]: string;
}
/** (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. */
interface DedicatedWorkerGlobalScope extends WorkerGlobalScope, AnimationFrameProvider {
- /**
- * Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging.
- */
+ /** Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging. */
readonly name: string;
onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
- /**
- * Aborts dedicatedWorkerGlobal.
- */
+ /** Aborts dedicatedWorkerGlobal. */
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.
- */
+ /** 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. */
postMessage(message: any, transfer: Transferable[]): void;
- postMessage(message: any, options?: PostMessageOptions): void;
+ postMessage(message: any, options?: StructuredSerializeOptions): void;
addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
new(): DedicatedWorkerGlobalScope;
};
-interface DhImportKeyParams extends Algorithm {
- generator: Uint8Array;
- prime: Uint8Array;
-}
-
-interface DhKeyAlgorithm extends KeyAlgorithm {
- generator: Uint8Array;
- prime: Uint8Array;
+interface EXT_blend_minmax {
+ readonly MAX_EXT: GLenum;
+ readonly MIN_EXT: GLenum;
}
-interface DhKeyDeriveParams extends Algorithm {
- public: CryptoKey;
+interface EXT_color_buffer_float {
}
-interface DhKeyGenParams extends Algorithm {
- generator: Uint8Array;
- prime: Uint8Array;
+interface EXT_color_buffer_half_float {
+ readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
+ readonly RGB16F_EXT: GLenum;
+ readonly RGBA16F_EXT: GLenum;
+ readonly UNSIGNED_NORMALIZED_EXT: GLenum;
}
-interface EXT_blend_minmax {
- readonly MAX_EXT: GLenum;
- readonly MIN_EXT: GLenum;
+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. */
interface EXT_shader_texture_lod {
}
+interface EXT_texture_compression_rgtc {
+ readonly COMPRESSED_RED_GREEN_RGTC2_EXT: GLenum;
+ readonly COMPRESSED_RED_RGTC1_EXT: GLenum;
+ readonly COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: GLenum;
+ readonly COMPRESSED_SIGNED_RED_RGTC1_EXT: GLenum;
+}
+
/** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
interface EXT_texture_filter_anisotropic {
readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
/** An event which takes place in the DOM. */
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.
- */
+ /** Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise. */
readonly bubbles: boolean;
cancelBubble: boolean;
- /**
- * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.
- */
+ /** Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method. */
readonly cancelable: boolean;
- /**
- * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
- */
+ /** Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise. */
readonly composed: boolean;
- /**
- * Returns the object whose event listener's callback is currently being invoked.
- */
+ /** Returns the object whose event listener's callback is currently being invoked. */
readonly currentTarget: EventTarget | null;
- /**
- * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
- */
+ /** Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise. */
readonly defaultPrevented: boolean;
- /**
- * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
- */
+ /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE. */
readonly eventPhase: number;
- /**
- * Returns true if event was dispatched by the user agent, and false otherwise.
- */
+ /** Returns true if event was dispatched by the user agent, and false otherwise. */
readonly isTrusted: boolean;
+ /** @deprecated */
returnValue: boolean;
/** @deprecated */
readonly srcElement: EventTarget | null;
- /**
- * Returns the object to which event is dispatched (its target).
- */
+ /** Returns the object to which event is dispatched (its target). */
readonly target: EventTarget | null;
- /**
- * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
- */
- readonly timeStamp: number;
- /**
- * Returns the type of event, e.g. "click", "hashchange", or "submit".
- */
+ /** Returns the event's timestamp as the number of milliseconds measured relative to the time origin. */
+ readonly timeStamp: DOMHighResTimeStamp;
+ /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
readonly type: string;
- /**
- * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
- */
+ /** Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget. */
composedPath(): EventTarget[];
+ /** @deprecated */
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
- /**
- * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
- */
+ /** If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled. */
preventDefault(): void;
- /**
- * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
- */
+ /** Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects. */
stopImmediatePropagation(): void;
- /**
- * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
- */
+ /** When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object. */
stopPropagation(): void;
readonly AT_TARGET: number;
readonly BUBBLING_PHASE: number;
readonly NONE: number;
};
+interface EventListener {
+ (evt: Event): void;
+}
+
interface EventListenerObject {
- handleEvent(evt: Event): void;
+ handleEvent(object: Event): void;
}
interface EventSourceEventMap {
onerror: ((this: EventSource, ev: Event) => any) | null;
onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
onopen: ((this: EventSource, ev: Event) => any) | null;
- /**
- * Returns the state of this EventSource object's connection. It can have the values described below.
- */
+ /** Returns the state of this EventSource object's connection. It can have the values described below. */
readonly readyState: number;
- /**
- * Returns the URL providing the event stream.
- */
+ /** Returns the URL providing the event stream. */
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.
- */
+ /** Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise. */
readonly withCredentials: boolean;
- /**
- * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
- */
+ /** Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED. */
close(): void;
readonly CLOSED: number;
readonly CONNECTING: number;
declare var EventSource: {
prototype: EventSource;
- new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
+ new(url: string | URL, eventSourceInitDict?: EventSourceInit): EventSource;
readonly CLOSED: number;
readonly CONNECTING: number;
readonly OPEN: number;
interface EventTarget {
/**
* Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
- *
+ *
* The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.
- *
+ *
* When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
- *
+ *
* When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.
- *
+ *
* When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
- *
+ *
+ * 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.
*/
- addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
- /**
- * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
- */
+ 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. */
dispatchEvent(event: Event): boolean;
- /**
- * Removes the event listener in target's event listener list with the same type, callback, and options.
- */
+ /** Removes the event listener in target's event listener list with the same type, callback, and options. */
removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
}
/** 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. */
interface FetchEvent extends ExtendableEvent {
readonly clientId: string;
- readonly preloadResponse: Promise<any>;
- readonly replacesClientId: string;
+ readonly handled: Promise<undefined>;
readonly request: Request;
readonly resultingClientId: string;
- respondWith(r: Response | Promise<Response>): void;
+ respondWith(r: Response | PromiseLike<Response>): void;
}
declare var FetchEvent: {
interface File extends Blob {
readonly lastModified: number;
readonly name: string;
+ readonly webkitRelativePath: string;
}
declare var File: {
/** Allows to read File or Blob objects in a synchronous way. */
interface FileReaderSync {
readAsArrayBuffer(blob: Blob): ArrayBuffer;
+ /** @deprecated */
readAsBinaryString(blob: Blob): string;
readAsDataURL(blob: Blob): string;
readAsText(blob: Blob, encoding?: string): string;
new(): FileReaderSync;
};
+interface FontFace {
+ ascentOverride: string;
+ descentOverride: string;
+ display: string;
+ family: string;
+ featureSettings: string;
+ lineGapOverride: string;
+ readonly loaded: Promise<FontFace>;
+ readonly status: FontFaceLoadStatus;
+ stretch: string;
+ style: string;
+ unicodeRange: string;
+ variant: string;
+ variationSettings: string;
+ weight: string;
+ load(): Promise<FontFace>;
+}
+
+declare var FontFace: {
+ prototype: FontFace;
+ new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace;
+};
+
+interface FontFaceSetEventMap {
+ "loading": Event;
+ "loadingdone": Event;
+ "loadingerror": Event;
+}
+
+interface FontFaceSet extends EventTarget {
+ onloading: ((this: FontFaceSet, ev: Event) => any) | null;
+ onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null;
+ onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null;
+ readonly ready: Promise<FontFaceSet>;
+ readonly status: FontFaceSetLoadStatus;
+ check(font: string, text?: string): boolean;
+ 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;
+ removeEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare var FontFaceSet: {
+ prototype: FontFaceSet;
+ new(initialFaces: FontFace[]): FontFaceSet;
+};
+
+interface FontFaceSetLoadEvent extends Event {
+ readonly fontfaces: ReadonlyArray<FontFace>;
+}
+
+declare var FontFaceSetLoadEvent: {
+ prototype: FontFaceSetLoadEvent;
+ new(type: string, eventInitDict?: FontFaceSetLoadEventInit): FontFaceSetLoadEvent;
+};
+
+interface FontFaceSource {
+ 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". */
interface FormData {
append(name: string, value: string | Blob, fileName?: string): void;
new(init?: HeadersInit): Headers;
};
-interface IDBArrayKey extends Array<IDBValidKey> {
-}
-
/** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
interface IDBCursor {
- /**
- * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
- */
+ /** Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor. */
readonly direction: IDBCursorDirection;
- /**
- * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
- */
+ /** Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished. */
readonly key: IDBValidKey;
- /**
- * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
- */
+ /** Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished. */
readonly primaryKey: IDBValidKey;
- /**
- * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
- */
+ readonly request: IDBRequest;
+ /** Returns the IDBObjectStore or IDBIndex the cursor was opened from. */
readonly source: IDBObjectStore | IDBIndex;
- /**
- * Advances the cursor through the next count records in range.
- */
+ /** Advances the cursor through the next count records in range. */
advance(count: number): void;
- /**
- * Advances the cursor to the next record in range.
- */
+ /** Advances the cursor to the next record in range. */
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.
- */
+ /** 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. */
continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
/**
* Delete the record pointed at by the cursor with a new value.
- *
+ *
* If successful, request's result will be undefined.
*/
delete(): IDBRequest<undefined>;
/**
* Updated the record pointed at by the cursor with a new value.
- *
+ *
* 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.
*/
update(value: any): IDBRequest<IDBValidKey>;
/** 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. */
interface IDBCursorWithValue extends IDBCursor {
- /**
- * Returns the cursor's current value.
- */
+ /** Returns the cursor's current value. */
readonly value: any;
}
/** 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. */
interface IDBDatabase extends EventTarget {
- /**
- * Returns the name of the database.
- */
+ /** Returns the name of the database. */
readonly name: string;
- /**
- * Returns a list of the names of object stores in the database.
- */
+ /** Returns a list of the names of object stores in the database. */
readonly objectStoreNames: DOMStringList;
onabort: ((this: IDBDatabase, ev: Event) => any) | null;
onclose: ((this: IDBDatabase, ev: Event) => any) | null;
onerror: ((this: IDBDatabase, ev: Event) => any) | null;
onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
- /**
- * Returns the version of the database.
- */
+ /** Returns the version of the database. */
readonly version: number;
- /**
- * Closes the connection once all running transactions have finished.
- */
+ /** Closes the connection once all running transactions have finished. */
close(): void;
/**
* Creates a new object store with the given name and options and returns a new IDBObjectStore.
- *
+ *
* Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
*/
createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
/**
* Deletes the object store with the given name.
- *
+ *
* Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
*/
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.
- */
+ /** 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. */
transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
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.
- *
+ *
* Throws a "DataError" DOMException if either input is not a valid key.
*/
cmp(first: any, second: any): number;
- /**
- * 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.
- */
+ 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. */
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.
- */
+ /** 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. */
open(name: string, version?: number): IDBOpenDBRequest;
}
interface IDBIndex {
readonly keyPath: string | string[];
readonly multiEntry: boolean;
- /**
- * Returns the name of the index.
- */
+ /** Returns the name of the index. */
name: string;
- /**
- * Returns the IDBObjectStore the index belongs to.
- */
+ /** Returns the IDBObjectStore the index belongs to. */
readonly objectStore: IDBObjectStore;
readonly unique: boolean;
/**
* Retrieves the number of records matching the given key or key range in query.
- *
+ *
* If successful, request's result will be the count.
*/
- count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
+ count(query?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
/**
* Retrieves the value of the first record matching the given key or key range in query.
- *
+ *
* If successful, request's result will be the value, or undefined if there was no matching record.
*/
- get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
+ 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).
- *
+ *
* If successful, request's result will be an Array of the values.
*/
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).
- *
+ *
* If successful, request's result will be an Array of the keys.
*/
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.
- *
+ *
* If successful, request's result will be the key, or undefined if there was no matching record.
*/
- getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
+ 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.
- *
+ *
* If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
*/
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.
- *
+ *
* If successful, request's result will be an IDBCursor, or null if there were no matching records.
*/
openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
/** 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: */
interface IDBKeyRange {
- /**
- * Returns lower bound, or undefined if none.
- */
+ /** Returns lower bound, or undefined if none. */
readonly lower: any;
- /**
- * Returns true if the lower open flag is set, and false otherwise.
- */
+ /** Returns true if the lower open flag is set, and false otherwise. */
readonly lowerOpen: boolean;
- /**
- * Returns upper bound, or undefined if none.
- */
+ /** Returns upper bound, or undefined if none. */
readonly upper: any;
- /**
- * Returns true if the upper open flag is set, and false otherwise.
- */
+ /** Returns true if the upper open flag is set, and false otherwise. */
readonly upperOpen: boolean;
- /**
- * Returns true if key is included in the range, and false otherwise.
- */
+ /** Returns true if key is included in the range, and false otherwise. */
includes(key: any): boolean;
}
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.
- */
+ /** 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. */
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.
- */
+ /** Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range. */
lowerBound(lower: any, open?: boolean): IDBKeyRange;
- /**
- * Returns a new IDBKeyRange spanning only key.
- */
+ /** Returns a new IDBKeyRange spanning only key. */
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.
- */
+ /** Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range. */
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.) */
interface IDBObjectStore {
- /**
- * Returns true if the store has a key generator, and false otherwise.
- */
+ /** Returns true if the store has a key generator, and false otherwise. */
readonly autoIncrement: boolean;
- /**
- * Returns a list of the names of indexes in the store.
- */
+ /** Returns a list of the names of indexes in the store. */
readonly indexNames: DOMStringList;
- /**
- * Returns the key path of the store, or null if none.
- */
+ /** Returns the key path of the store, or null if none. */
readonly keyPath: string | string[];
- /**
- * Returns the name of the store.
- */
+ /** Returns the name of the store. */
name: string;
- /**
- * Returns the associated transaction.
- */
+ /** Returns the associated transaction. */
readonly transaction: IDBTransaction;
/**
* Adds or updates a record in store with the given value and key.
- *
+ *
* 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.
*/
add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
/**
* Deletes all records in store.
- *
+ *
* If successful, request's result will be undefined.
*/
clear(): IDBRequest<undefined>;
/**
* Retrieves the number of records matching the given key or key range in query.
- *
+ *
* If successful, request's result will be the count.
*/
- count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
+ 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.
- *
+ *
* Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
*/
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.
- *
+ *
* If successful, request's result will be undefined.
*/
- delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
+ delete(query: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
/**
* Deletes the index in store with the given name.
- *
+ *
* Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
*/
deleteIndex(name: string): void;
/**
* Retrieves the value of the first record matching the given key or key range in query.
- *
+ *
* If successful, request's result will be the value, or undefined if there was no matching record.
*/
- get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
+ 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).
- *
+ *
* If successful, request's result will be an Array of the values.
*/
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).
- *
+ *
* If successful, request's result will be an Array of the keys.
*/
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.
- *
+ *
* If successful, request's result will be the key, or undefined if there was no matching record.
*/
getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
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.
- *
+ *
* If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
*/
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.
- *
+ *
* If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
*/
openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
/**
* Adds or updates a record in store with the given value and key.
- *
+ *
* 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.
*/
put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
/** 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. */
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.
- */
+ /** 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. */
readonly error: DOMException | null;
onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
- /**
- * Returns "pending" until a request is complete, then returns "done".
- */
+ /** Returns "pending" until a request is complete, then returns "done". */
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.
- */
+ /** When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending. */
readonly result: T;
- /**
- * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
- */
+ /** Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request. */
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.
- */
+ /** 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. */
readonly transaction: IDBTransaction | null;
addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
}
interface IDBTransaction extends EventTarget {
- /**
- * Returns the transaction's connection.
- */
+ /** Returns the transaction's connection. */
readonly db: IDBDatabase;
- /**
- * If the transaction was aborted, returns the error (a DOMException) providing the reason.
- */
- readonly error: DOMException;
- /**
- * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
- */
+ /** If the transaction was aborted, returns the error (a DOMException) providing the reason. */
+ readonly error: DOMException | null;
+ /** Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction. */
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.
- */
+ /** 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. */
readonly objectStoreNames: DOMStringList;
onabort: ((this: IDBTransaction, ev: Event) => any) | null;
oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
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.
- */
+ /** Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted. */
abort(): void;
- /**
- * Returns an IDBObjectStore in the transaction's scope.
- */
+ commit(): void;
+ /** Returns an IDBObjectStore in the transaction's scope. */
objectStore(name: string): IDBObjectStore;
addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
};
interface ImageBitmap {
- /**
- * Returns the intrinsic height of the image, in CSS pixels.
- */
+ /** Returns the intrinsic height of the image, in CSS pixels. */
readonly height: number;
- /**
- * Returns the intrinsic width of the image, in CSS pixels.
- */
+ /** Returns the intrinsic width of the image, in CSS pixels. */
readonly width: number;
- /**
- * Releases imageBitmap's underlying bitmap data.
- */
+ /** Releases imageBitmap's underlying bitmap data. */
close(): void;
}
};
interface ImageBitmapRenderingContext {
- /**
- * Returns the canvas element that the context is bound to.
- */
- readonly canvas: OffscreenCanvas;
- /**
- * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
- */
+ /** Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound. */
transferFromImageBitmap(bitmap: ImageBitmap | null): void;
}
/** 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(). */
interface ImageData {
- /**
- * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
- */
+ /** Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255. */
readonly data: Uint8ClampedArray;
- /**
- * Returns the actual dimensions of the data in the ImageData object, in pixels.
- */
+ /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
readonly height: number;
- /**
- * Returns the actual dimensions of the data in the ImageData object, in pixels.
- */
+ /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
readonly width: number;
}
declare var ImageData: {
prototype: ImageData;
- new(sw: number, sh: number): ImageData;
- new(data: Uint8ClampedArray, sw: number, sh?: number): ImageData;
+ new(sw: number, sh: number, settings?: ImageDataSettings): ImageData;
+ new(data: Uint8ClampedArray, sw: number, sh?: number, settings?: ImageDataSettings): ImageData;
+};
+
+interface KHR_parallel_shader_compile {
+ readonly COMPLETION_STATUS_KHR: GLenum;
+}
+
+interface MediaCapabilities {
+ decodingInfo(configuration: MediaDecodingConfiguration): Promise<MediaCapabilitiesDecodingInfo>;
+ encodingInfo(configuration: MediaEncodingConfiguration): Promise<MediaCapabilitiesEncodingInfo>;
+}
+
+declare var MediaCapabilities: {
+ prototype: MediaCapabilities;
+ 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. */
interface MessageChannel {
- /**
- * Returns the first MessagePort object.
- */
+ /** Returns the first MessagePort object. */
readonly port1: MessagePort;
- /**
- * Returns the second MessagePort object.
- */
+ /** Returns the second MessagePort object. */
readonly port2: MessagePort;
}
/** A message received by a target object. */
interface MessageEvent<T = any> extends Event {
- /**
- * Returns the data of the message.
- */
+ /** Returns the data of the message. */
readonly data: T;
- /**
- * Returns the last event ID string, for server-sent events.
- */
+ /** Returns the last event ID string, for server-sent events. */
readonly lastEventId: string;
- /**
- * Returns the origin of the message, for server-sent events and cross-document messaging.
- */
+ /** Returns the origin of the message, for server-sent events and cross-document messaging. */
readonly origin: string;
- /**
- * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
- */
+ /** Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging. */
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.
- */
+ /** Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects. */
readonly source: MessageEventSource | null;
+ /** @deprecated */
+ initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
}
declare var MessageEvent: {
interface MessagePort extends EventTarget {
onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
- /**
- * Disconnects the port, so that it is no longer active.
- */
+ /** Disconnects the port, so that it is no longer active. */
close(): void;
/**
* Posts a message through the channel. Objects listed in transfer are transferred, not just cloned, meaning that they are no longer usable on the sending side.
- *
+ *
* Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
*/
postMessage(message: any, transfer: Transferable[]): void;
- postMessage(message: any, options?: PostMessageOptions): void;
- /**
- * Begins dispatching messages received on the port.
- */
+ postMessage(message: any, options?: StructuredSerializeOptions): void;
+ /** Begins dispatching messages received on the port. */
start(): void;
addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
new(): MessagePort;
};
-interface NavigationPreloadManager {
- disable(): Promise<void>;
- enable(): Promise<void>;
- getState(): Promise<NavigationPreloadState>;
- setHeaderValue(value: string): Promise<void>;
-}
-
-declare var NavigationPreloadManager: {
- prototype: NavigationPreloadManager;
- new(): NavigationPreloadManager;
-};
-
interface NavigatorConcurrentHardware {
readonly hardwareConcurrency: number;
}
interface NavigatorID {
+ /** @deprecated */
readonly appCodeName: string;
+ /** @deprecated */
readonly appName: string;
+ /** @deprecated */
readonly appVersion: string;
+ /** @deprecated */
readonly platform: string;
+ /** @deprecated */
readonly product: string;
readonly userAgent: string;
}
readonly languages: ReadonlyArray<string>;
}
+interface NavigatorNetworkInformation {
+ readonly connection: NetworkInformation;
+}
+
interface NavigatorOnLine {
readonly onLine: boolean;
}
+/** Available only in secure contexts. */
interface NavigatorStorage {
readonly storage: StorageManager;
}
+interface NetworkInformation extends EventTarget {
+ readonly type: ConnectionType;
+}
+
+declare var NetworkInformation: {
+ prototype: NetworkInformation;
+ new(): NetworkInformation;
+};
+
interface NotificationEventMap {
"click": Event;
"close": Event;
/** This Notifications API interface is used to configure and display desktop notifications to the user. */
interface Notification extends EventTarget {
- readonly actions: ReadonlyArray<NotificationAction>;
- readonly badge: string;
readonly body: string;
readonly data: any;
readonly dir: NotificationDirection;
readonly icon: string;
- readonly image: string;
readonly lang: string;
onclick: ((this: Notification, ev: Event) => any) | null;
onclose: ((this: Notification, ev: Event) => any) | null;
onerror: ((this: Notification, ev: Event) => any) | null;
onshow: ((this: Notification, ev: Event) => any) | null;
- readonly renotify: boolean;
- readonly requireInteraction: boolean;
- readonly silent: boolean;
readonly tag: string;
- readonly timestamp: number;
readonly title: string;
- readonly vibrate: ReadonlyArray<number>;
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;
declare var Notification: {
prototype: Notification;
new(title: string, options?: NotificationOptions): Notification;
- readonly maxActions: number;
readonly permission: NotificationPermission;
};
interface OES_element_index_uint {
}
+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. */
interface OES_standard_derivatives {
readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
readonly VERTEX_ARRAY_BINDING_OES: GLenum;
}
-interface OffscreenCanvas extends EventTarget {
- /**
- * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
- *
- * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
- */
- height: number;
- /**
- * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
- *
- * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
- */
- width: number;
- /**
- * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
- *
- * 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.
- */
- 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.
- *
- * 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).
- */
- getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): OffscreenCanvasRenderingContext2D | null;
- getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
- getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
- getContext(contextId: "webgl2", options?: WebGLContextAttributes): 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.
- */
- transferToImageBitmap(): ImageBitmap;
+interface OVR_multiview2 {
+ framebufferTextureMultiviewOVR(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, baseViewIndex: GLint, numViews: GLsizei): void;
+ readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: GLenum;
+ readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: GLenum;
+ readonly FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR: GLenum;
+ readonly MAX_VIEWS_OVR: GLenum;
}
-declare var OffscreenCanvas: {
- prototype: OffscreenCanvas;
- new(width: number, height: number): OffscreenCanvas;
-};
-
-interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
- readonly canvas: OffscreenCanvas;
- commit(): void;
+/** @deprecated this is not available in most browsers */
+interface OffscreenCanvas extends EventTarget {
}
-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. */
interface Path2D extends CanvasPath {
- /**
- * Adds to the path the path given by the argument.
- */
+ /** Adds to the path the path given by the argument. */
addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
}
/** 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. */
interface Performance extends EventTarget {
onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
- readonly timeOrigin: number;
+ readonly timeOrigin: DOMHighResTimeStamp;
clearMarks(markName?: string): void;
clearMeasures(measureName?: string): void;
clearResourceTimings(): void;
getEntries(): PerformanceEntryList;
getEntriesByName(name: string, type?: string): PerformanceEntryList;
getEntriesByType(type: string): PerformanceEntryList;
- mark(markName: string): void;
- measure(measureName: string, startMark?: string, endMark?: string): void;
- now(): number;
+ mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
+ measure(measureName: string, startOrMeasureOptions?: string | PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
+ now(): DOMHighResTimeStamp;
setResourceTimingBufferSize(maxSize: number): void;
toJSON(): any;
addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
/** 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). */
interface PerformanceEntry {
- readonly duration: number;
+ readonly duration: DOMHighResTimeStamp;
readonly entryType: string;
readonly name: string;
- readonly startTime: number;
+ readonly startTime: DOMHighResTimeStamp;
toJSON(): any;
}
/** PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline. */
interface PerformanceMark extends PerformanceEntry {
+ readonly detail: any;
}
declare var PerformanceMark: {
prototype: PerformanceMark;
- new(): PerformanceMark;
+ 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. */
interface PerformanceMeasure extends PerformanceEntry {
+ readonly detail: any;
}
declare var PerformanceMeasure: {
/** 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. */
interface PerformanceResourceTiming extends PerformanceEntry {
- readonly connectEnd: number;
- readonly connectStart: number;
+ readonly connectEnd: DOMHighResTimeStamp;
+ readonly connectStart: DOMHighResTimeStamp;
readonly decodedBodySize: number;
- readonly domainLookupEnd: number;
- readonly domainLookupStart: number;
+ readonly domainLookupEnd: DOMHighResTimeStamp;
+ readonly domainLookupStart: DOMHighResTimeStamp;
readonly encodedBodySize: number;
- readonly fetchStart: number;
+ readonly fetchStart: DOMHighResTimeStamp;
readonly initiatorType: string;
readonly nextHopProtocol: string;
- readonly redirectEnd: number;
- readonly redirectStart: number;
- readonly requestStart: number;
- readonly responseEnd: number;
- readonly responseStart: number;
- readonly secureConnectionStart: number;
+ readonly redirectEnd: DOMHighResTimeStamp;
+ readonly redirectStart: DOMHighResTimeStamp;
+ readonly requestStart: DOMHighResTimeStamp;
+ readonly responseEnd: DOMHighResTimeStamp;
+ readonly responseStart: DOMHighResTimeStamp;
+ readonly secureConnectionStart: DOMHighResTimeStamp;
+ readonly serverTiming: ReadonlyArray<PerformanceServerTiming>;
readonly transferSize: number;
- readonly workerStart: number;
+ readonly workerStart: DOMHighResTimeStamp;
toJSON(): any;
}
new(): PerformanceResourceTiming;
};
+interface PerformanceServerTiming {
+ readonly description: string;
+ readonly duration: DOMHighResTimeStamp;
+ readonly name: string;
+ toJSON(): any;
+}
+
+declare var PerformanceServerTiming: {
+ prototype: PerformanceServerTiming;
+ new(): PerformanceServerTiming;
+};
+
interface PermissionStatusEventMap {
"change": Event;
}
};
interface Permissions {
- query(permissionDesc: PermissionDescriptor
| DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
+ query(permissionDesc: PermissionDescriptor): Promise<PermissionStatus>;
}
declare var Permissions: {
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. */
+/**
+ * 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.
+ * Available only in secure contexts.
+ */
interface PushEvent extends ExtendableEvent {
readonly data: PushMessageData | null;
}
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. */
+/**
+ * This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
+ * Available only in secure contexts.
+ */
interface PushManager {
getSubscription(): Promise<PushSubscription | null>;
permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
readonly supportedContentEncodings: ReadonlyArray<string>;
};
-/** This Push API interface provides methods which let you retrieve the push data sent by a server in various formats. */
+/**
+ * This Push API interface provides methods which let you retrieve the push data sent by a server in various formats.
+ * Available only in secure contexts.
+ */
interface PushMessageData {
arrayBuffer(): ArrayBuffer;
blob(): Blob;
new(): PushMessageData;
};
-/** This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service. */
+/**
+ * This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service.
+ * Available only in secure contexts.
+ */
interface PushSubscription {
readonly endpoint: string;
- readonly expirationTime: number | null;
readonly options: PushSubscriptionOptions;
getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
toJSON(): PushSubscriptionJSON;
new(): PushSubscription;
};
-interface PushSubscriptionChangeEvent extends ExtendableEvent {
- readonly newSubscription: PushSubscription | null;
- readonly oldSubscription: PushSubscription | null;
-}
-
-declare var PushSubscriptionChangeEvent: {
- prototype: PushSubscriptionChangeEvent;
- new(type: string, eventInitDict?: PushSubscriptionChangeEventInit): PushSubscriptionChangeEvent;
-};
-
+/** Available only in secure contexts. */
interface PushSubscriptionOptions {
readonly applicationServerKey: ArrayBuffer | null;
- readonly userVisibleOnly: boolean;
}
declare var PushSubscriptionOptions: {
cancel(reason?: any): Promise<void>;
getReader(): ReadableStreamDefaultReader<R>;
pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
- pipeTo(dest: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+ pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
tee(): [ReadableStream<R>, ReadableStream<R>];
}
interface ReadableStreamDefaultController<R = any> {
readonly desiredSize: number | null;
close(): void;
- enqueue(chunk: R): void;
+ enqueue(chunk?: R): void;
error(e?: any): void;
}
/** This Fetch API interface represents a resource 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.
- */
+ /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
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.
- */
+ /** 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. */
readonly credentials: RequestCredentials;
- /**
- * Returns the kind of resource requested by request, e.g., "document" or "script".
- */
+ /** Returns the kind of resource requested by request, e.g., "document" or "script". */
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.
- */
+ /** 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. */
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]
- */
+ /** 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] */
readonly integrity: string;
- /**
- * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
- */
- readonly isHistoryNavigation: boolean;
- /**
- * Returns a boolean indicating whether or not request is for a reload navigation.
- */
- readonly isReloadNavigation: boolean;
- /**
- * Returns a boolean indicating whether or not request can outlive the global in which it was created.
- */
+ /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
readonly keepalive: boolean;
- /**
- * Returns request's HTTP method, which is "GET" by default.
- */
+ /** Returns request's HTTP method, which is "GET" by default. */
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.
- */
+ /** 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. */
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.
- */
+ /** 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. */
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.
- */
+ /** 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. */
readonly referrer: string;
- /**
- * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
- */
+ /** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
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.
- */
+ /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
readonly signal: AbortSignal;
- /**
- * Returns the URL of request as a string.
- */
+ /** Returns the URL of request as a string. */
readonly url: string;
clone(): Request;
}
readonly redirected: boolean;
readonly status: number;
readonly statusText: string;
- readonly trailer: Promise<Headers>;
readonly type: ResponseType;
readonly url: string;
clone(): Response;
prototype: Response;
new(body?: BodyInit | null, init?: ResponseInit): Response;
error(): Response;
- redirect(url: string, status?: number): Response;
+ 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. */
+interface SecurityPolicyViolationEvent extends Event {
+ readonly blockedURI: string;
+ readonly columnNumber: number;
+ readonly disposition: SecurityPolicyViolationEventDisposition;
+ readonly documentURI: string;
+ readonly effectiveDirective: string;
+ readonly lineNumber: number;
+ readonly originalPolicy: string;
+ readonly referrer: string;
+ readonly sample: string;
+ readonly sourceFile: string;
+ readonly statusCode: number;
+ readonly violatedDirective: string;
+}
+
+declare var SecurityPolicyViolationEvent: {
+ prototype: SecurityPolicyViolationEvent;
+ new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
};
interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
"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. */
+/**
+ * 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.
+ * Available only in secure contexts.
+ */
interface ServiceWorker extends EventTarget, AbstractWorker {
onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
readonly scriptURL: string;
readonly state: ServiceWorkerState;
postMessage(message: any, transfer: Transferable[]): void;
- postMessage(message: any, options?: PostMessageOptions): 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;
removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
"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 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.
+ * Available only in secure contexts.
+ */
interface ServiceWorkerContainer extends EventTarget {
readonly controller: ServiceWorker | null;
oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
readonly ready: Promise<ServiceWorkerRegistration>;
- getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
+ getRegistration(clientURL?: string | URL): Promise<ServiceWorkerRegistration | undefined>;
getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
startMessages(): void;
"notificationclick": NotificationEvent;
"notificationclose": NotificationEvent;
"push": PushEvent;
- "pushsubscriptionchange": PushSubscriptionChangeEvent;
- "sync": SyncEvent;
}
/** This ServiceWorker API interface represents the global execution context of a service worker. */
onnotificationclick: ((this: ServiceWorkerGlobalScope, ev: NotificationEvent) => any) | null;
onnotificationclose: ((this: ServiceWorkerGlobalScope, ev: NotificationEvent) => any) | null;
onpush: ((this: ServiceWorkerGlobalScope, ev: PushEvent) => any) | null;
- onpushsubscriptionchange: ((this: ServiceWorkerGlobalScope, ev: PushSubscriptionChangeEvent) => any) | null;
- onsync: ((this: ServiceWorkerGlobalScope, ev: SyncEvent) => any) | null;
readonly registration: ServiceWorkerRegistration;
- readonly serviceWorker: ServiceWorker;
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;
"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. */
+/**
+ * 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.
+ * Available only in secure contexts.
+ */
interface ServiceWorkerRegistration extends EventTarget {
readonly active: ServiceWorker | null;
readonly installing: ServiceWorker | null;
- readonly navigationPreload: NavigationPreloadManager;
onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
readonly pushManager: PushManager;
readonly scope: string;
- readonly sync: SyncManager;
readonly updateViaCache: ServiceWorkerUpdateViaCache;
readonly waiting: ServiceWorker | null;
getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
new(): ServiceWorkerRegistration;
};
-interface SharedWorker extends EventTarget, AbstractWorker {
- /**
- * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
- */
- readonly port: MessagePort;
- addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
- addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
- removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
- removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-}
-
-declare var SharedWorker: {
- prototype: SharedWorker;
- new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
-};
-
interface SharedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
"connect": MessageEvent;
}
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.
- */
+ /** 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. */
readonly name: string;
onconnect: ((this: SharedWorkerGlobalScope, ev: MessageEvent) => any) | null;
- /**
- * Aborts sharedWorkerGlobal.
- */
+ /** Aborts sharedWorkerGlobal. */
close(): void;
addEventListener<K extends keyof SharedWorkerGlobalScopeEventMap>(type: K, listener: (this: SharedWorkerGlobalScope, ev: SharedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
new(): SharedWorkerGlobalScope;
};
+/** Available only in secure contexts. */
interface StorageManager {
estimate(): Promise<StorageEstimate>;
persisted(): Promise<boolean>;
new(): StorageManager;
};
-/** 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). */
+/**
+ * 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).
+ * Available only in secure contexts.
+ */
interface SubtleCrypto {
- decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
- deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams |
DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
- deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- digest(algorithm: AlgorithmIdentifier, data:
Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
- encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
+ decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
+ deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
+ deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+ digest(algorithm: AlgorithmIdentifier, data:
BufferSource): Promise<ArrayBuffer>;
+ encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
- exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): Promise<ArrayBuffer>;
- exportKey(format: string, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer>;
- generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+ exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
+ generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
- importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
- unwrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
- verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<boolean>;
- wrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams): Promise<ArrayBuffer>;
+ importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+ importKey(format: Exclude<KeyFormat, "jwk">, keyData: BufferSource, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+ sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+ 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>;
+ verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<boolean>;
+ wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
}
declare var SubtleCrypto: {
new(): SubtleCrypto;
};
-/** A sync action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. */
-interface SyncEvent extends ExtendableEvent {
- readonly lastChance: boolean;
- readonly tag: string;
-}
-
-declare var SyncEvent: {
- prototype: SyncEvent;
- new(type: string, init: SyncEventInit): SyncEvent;
-};
-
-/** This ServiceWorker API interface provides an interface for registering and listing sync registrations. */
-interface SyncManager {
- getTags(): Promise<string[]>;
- register(tag: string): Promise<void>;
-}
-
-declare var SyncManager: {
- prototype: SyncManager;
- new(): SyncManager;
-};
-
/** 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. */
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.
- *
+ *
* ```
* var string = "", decoder = new TextDecoder(encoding), buffer;
* while(buffer = next_chunk()) {
* }
* string += decoder.decode(); // end-of-queue
* ```
- *
+ *
* If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
*/
decode(input?: BufferSource, options?: TextDecodeOptions): string;
};
interface TextDecoderCommon {
- /**
- * Returns encoding's name, lowercased.
- */
+ /** Returns encoding's name, lowercased. */
readonly encoding: string;
- /**
- * Returns true if error mode is "fatal", otherwise false.
- */
+ /** Returns true if error mode is "fatal", otherwise false. */
readonly fatal: boolean;
- /**
- * Returns the value of ignore BOM.
- */
+ /** Returns the value of ignore BOM. */
readonly ignoreBOM: boolean;
}
/** 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. */
interface TextEncoder extends TextEncoderCommon {
- /**
- * Returns the result of running UTF-8's encoder.
- */
+ /** Returns the result of running UTF-8's encoder. */
encode(input?: string): Uint8Array;
- /**
- * 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.
- */
+ /** 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. */
encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
}
};
interface TextEncoderCommon {
- /**
- * Returns "utf-8".
- */
+ /** Returns "utf-8". */
readonly encoding: string;
}
/** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
interface TextMetrics {
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly actualBoundingBoxAscent: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly actualBoundingBoxDescent: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly actualBoundingBoxLeft: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly actualBoundingBoxRight: number;
- /**
- * Returns the measurement described below.
- */
- readonly alphabeticBaseline: number;
- /**
- * Returns the measurement described below.
- */
- readonly emHeightAscent: number;
- /**
- * Returns the measurement described below.
- */
- readonly emHeightDescent: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly fontBoundingBoxAscent: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly fontBoundingBoxDescent: number;
- /**
- * Returns the measurement described below.
- */
- readonly hangingBaseline: number;
- /**
- * Returns the measurement described below.
- */
- readonly ideographicBaseline: number;
- /**
- * Returns the measurement described below.
- */
+ /** Returns the measurement described below. */
readonly width: number;
}
interface TransformStreamDefaultController<O = any> {
readonly desiredSize: number | null;
- enqueue(chunk: O): void;
+ enqueue(chunk?: O): void;
error(reason?: any): void;
terminate(): void;
}
declare var URL: {
prototype: URL;
- new(url: string, base?: string | URL): URL;
- createObjectURL(object: any): string;
+ new(url: string | URL, base?: string | URL): URL;
+ createObjectURL(obj: Blob): string;
revokeObjectURL(url: string): void;
};
interface URLSearchParams {
- /**
- * Appends a specified key/value pair as a new search parameter.
- */
+ /** Appends a specified key/value pair as a new search parameter. */
append(name: string, value: string): void;
- /**
- * Deletes the given search parameter, and its associated value, from the list of all search parameters.
- */
+ /** Deletes the given search parameter, and its associated value, from the list of all search parameters. */
delete(name: string): void;
- /**
- * Returns the first value associated to the given search parameter.
- */
+ /** Returns the first value associated to the given search parameter. */
get(name: string): string | null;
- /**
- * Returns all the values association with a given search parameter.
- */
+ /** Returns all the values association with a given search parameter. */
getAll(name: string): string[];
- /**
- * Returns a Boolean indicating if such a search parameter exists.
- */
+ /** Returns a Boolean indicating if such a search parameter exists. */
has(name: string): boolean;
- /**
- * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
- */
+ /** Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. */
set(name: string, value: string): void;
sort(): void;
- /**
- * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
- */
+ /** 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;
}
readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
}
+interface WEBGL_compressed_texture_etc {
+ readonly COMPRESSED_R11_EAC: GLenum;
+ readonly COMPRESSED_RG11_EAC: GLenum;
+ readonly COMPRESSED_RGB8_ETC2: GLenum;
+ readonly COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum;
+ readonly COMPRESSED_RGBA8_ETC2_EAC: GLenum;
+ readonly COMPRESSED_SIGNED_R11_EAC: GLenum;
+ readonly COMPRESSED_SIGNED_RG11_EAC: GLenum;
+ readonly COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: GLenum;
+ readonly COMPRESSED_SRGB8_ETC2: GLenum;
+ readonly COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum;
+}
+
+interface WEBGL_compressed_texture_etc1 {
+ readonly COMPRESSED_RGB_ETC1_WEBGL: GLenum;
+}
+
+interface WEBGL_compressed_texture_pvrtc {
+ readonly COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: GLenum;
+ readonly COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: GLenum;
+ readonly COMPRESSED_RGB_PVRTC_2BPPV1_IMG: GLenum;
+ readonly COMPRESSED_RGB_PVRTC_4BPPV1_IMG: GLenum;
+}
+
/** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
interface WEBGL_compressed_texture_s3tc {
readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
declare var WebGL2RenderingContext: {
prototype: WebGL2RenderingContext;
new(): WebGL2RenderingContext;
- readonly ACTIVE_ATTRIBUTES: GLenum;
- readonly ACTIVE_TEXTURE: GLenum;
- readonly ACTIVE_UNIFORMS: GLenum;
- readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
- readonly ALIASED_POINT_SIZE_RANGE: GLenum;
- readonly ALPHA: GLenum;
- readonly ALPHA_BITS: GLenum;
- readonly ALWAYS: GLenum;
- readonly ARRAY_BUFFER: GLenum;
- readonly ARRAY_BUFFER_BINDING: GLenum;
- readonly ATTACHED_SHADERS: GLenum;
- readonly BACK: GLenum;
- readonly BLEND: GLenum;
- readonly BLEND_COLOR: GLenum;
- readonly BLEND_DST_ALPHA: GLenum;
- readonly BLEND_DST_RGB: GLenum;
- readonly BLEND_EQUATION: GLenum;
- readonly BLEND_EQUATION_ALPHA: GLenum;
- readonly BLEND_EQUATION_RGB: GLenum;
- readonly BLEND_SRC_ALPHA: GLenum;
- readonly BLEND_SRC_RGB: GLenum;
- readonly BLUE_BITS: GLenum;
- readonly BOOL: GLenum;
- readonly BOOL_VEC2: GLenum;
- readonly BOOL_VEC3: GLenum;
- readonly BOOL_VEC4: GLenum;
- readonly BROWSER_DEFAULT_WEBGL: GLenum;
- readonly BUFFER_SIZE: GLenum;
- readonly BUFFER_USAGE: GLenum;
- readonly BYTE: GLenum;
- readonly CCW: GLenum;
- readonly CLAMP_TO_EDGE: GLenum;
- readonly COLOR_ATTACHMENT0: GLenum;
- readonly COLOR_BUFFER_BIT: GLenum;
- readonly COLOR_CLEAR_VALUE: GLenum;
- readonly COLOR_WRITEMASK: GLenum;
- readonly COMPILE_STATUS: GLenum;
- readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
- readonly CONSTANT_ALPHA: GLenum;
- readonly CONSTANT_COLOR: GLenum;
- readonly CONTEXT_LOST_WEBGL: GLenum;
- readonly CULL_FACE: GLenum;
- readonly CULL_FACE_MODE: GLenum;
- readonly CURRENT_PROGRAM: GLenum;
- readonly CURRENT_VERTEX_ATTRIB: GLenum;
- readonly CW: GLenum;
- readonly DECR: GLenum;
- readonly DECR_WRAP: GLenum;
- readonly DELETE_STATUS: GLenum;
- readonly DEPTH_ATTACHMENT: GLenum;
- readonly DEPTH_BITS: GLenum;
- readonly DEPTH_BUFFER_BIT: GLenum;
- readonly DEPTH_CLEAR_VALUE: GLenum;
- readonly DEPTH_COMPONENT: GLenum;
- readonly DEPTH_COMPONENT16: GLenum;
- readonly DEPTH_FUNC: GLenum;
- readonly DEPTH_RANGE: GLenum;
- readonly DEPTH_STENCIL: GLenum;
- readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
- readonly DEPTH_TEST: GLenum;
- readonly DEPTH_WRITEMASK: GLenum;
- readonly DITHER: GLenum;
- readonly DONT_CARE: GLenum;
- readonly DST_ALPHA: GLenum;
- readonly DST_COLOR: GLenum;
- readonly DYNAMIC_DRAW: GLenum;
- readonly ELEMENT_ARRAY_BUFFER: GLenum;
- readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
- readonly EQUAL: GLenum;
- readonly FASTEST: GLenum;
- readonly FLOAT: GLenum;
- readonly FLOAT_MAT2: GLenum;
- readonly FLOAT_MAT3: GLenum;
- readonly FLOAT_MAT4: GLenum;
- readonly FLOAT_VEC2: GLenum;
- readonly FLOAT_VEC3: GLenum;
- readonly FLOAT_VEC4: GLenum;
- readonly FRAGMENT_SHADER: GLenum;
- readonly FRAMEBUFFER: GLenum;
- readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
- readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
- readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
- readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
- readonly FRAMEBUFFER_BINDING: GLenum;
- readonly FRAMEBUFFER_COMPLETE: GLenum;
- readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
- readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
- readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
- readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
- readonly FRONT: GLenum;
- readonly FRONT_AND_BACK: GLenum;
- readonly FRONT_FACE: GLenum;
- readonly FUNC_ADD: GLenum;
- readonly FUNC_REVERSE_SUBTRACT: GLenum;
- readonly FUNC_SUBTRACT: GLenum;
- readonly GENERATE_MIPMAP_HINT: GLenum;
- readonly GEQUAL: GLenum;
- readonly GREATER: GLenum;
- readonly GREEN_BITS: GLenum;
- readonly HIGH_FLOAT: GLenum;
- readonly HIGH_INT: GLenum;
- readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
- readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
- readonly INCR: GLenum;
- readonly INCR_WRAP: GLenum;
- readonly INT: GLenum;
- readonly INT_VEC2: GLenum;
- readonly INT_VEC3: GLenum;
- readonly INT_VEC4: GLenum;
- readonly INVALID_ENUM: GLenum;
- readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
- readonly INVALID_OPERATION: GLenum;
- readonly INVALID_VALUE: GLenum;
- readonly INVERT: GLenum;
- readonly KEEP: GLenum;
- readonly LEQUAL: GLenum;
- readonly LESS: GLenum;
- readonly LINEAR: GLenum;
- readonly LINEAR_MIPMAP_LINEAR: GLenum;
- readonly LINEAR_MIPMAP_NEAREST: GLenum;
- readonly LINES: GLenum;
- readonly LINE_LOOP: GLenum;
- readonly LINE_STRIP: GLenum;
- readonly LINE_WIDTH: GLenum;
- readonly LINK_STATUS: GLenum;
- readonly LOW_FLOAT: GLenum;
- readonly LOW_INT: GLenum;
- readonly LUMINANCE: GLenum;
- readonly LUMINANCE_ALPHA: GLenum;
- readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
- readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
- readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
- readonly MAX_RENDERBUFFER_SIZE: GLenum;
- readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
- readonly MAX_TEXTURE_SIZE: GLenum;
- readonly MAX_VARYING_VECTORS: GLenum;
- readonly MAX_VERTEX_ATTRIBS: GLenum;
- readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
- readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
- readonly MAX_VIEWPORT_DIMS: GLenum;
- readonly MEDIUM_FLOAT: GLenum;
- readonly MEDIUM_INT: GLenum;
- readonly MIRRORED_REPEAT: GLenum;
- readonly NEAREST: GLenum;
- readonly NEAREST_MIPMAP_LINEAR: GLenum;
- readonly NEAREST_MIPMAP_NEAREST: GLenum;
- readonly NEVER: GLenum;
- readonly NICEST: GLenum;
- readonly NONE: GLenum;
- readonly NOTEQUAL: GLenum;
- readonly NO_ERROR: GLenum;
- readonly ONE: GLenum;
- readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
- readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
- readonly ONE_MINUS_DST_ALPHA: GLenum;
- readonly ONE_MINUS_DST_COLOR: GLenum;
- readonly ONE_MINUS_SRC_ALPHA: GLenum;
- readonly ONE_MINUS_SRC_COLOR: GLenum;
- readonly OUT_OF_MEMORY: GLenum;
- readonly PACK_ALIGNMENT: GLenum;
- readonly POINTS: GLenum;
- readonly POLYGON_OFFSET_FACTOR: GLenum;
- readonly POLYGON_OFFSET_FILL: GLenum;
- readonly POLYGON_OFFSET_UNITS: GLenum;
- readonly RED_BITS: GLenum;
- readonly RENDERBUFFER: GLenum;
- readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
- readonly RENDERBUFFER_BINDING: GLenum;
- readonly RENDERBUFFER_BLUE_SIZE: GLenum;
- readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
- readonly RENDERBUFFER_GREEN_SIZE: GLenum;
- readonly RENDERBUFFER_HEIGHT: GLenum;
- readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
- readonly RENDERBUFFER_RED_SIZE: GLenum;
- readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
- readonly RENDERBUFFER_WIDTH: GLenum;
- readonly RENDERER: GLenum;
- readonly REPEAT: GLenum;
- readonly REPLACE: GLenum;
- readonly RGB: GLenum;
- readonly RGB565: GLenum;
- readonly RGB5_A1: GLenum;
- readonly RGBA: GLenum;
- readonly RGBA4: GLenum;
- readonly SAMPLER_2D: GLenum;
- readonly SAMPLER_CUBE: GLenum;
- readonly SAMPLES: GLenum;
- readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
- readonly SAMPLE_BUFFERS: GLenum;
- readonly SAMPLE_COVERAGE: GLenum;
- readonly SAMPLE_COVERAGE_INVERT: GLenum;
- readonly SAMPLE_COVERAGE_VALUE: GLenum;
- readonly SCISSOR_BOX: GLenum;
- readonly SCISSOR_TEST: GLenum;
- readonly SHADER_TYPE: GLenum;
- readonly SHADING_LANGUAGE_VERSION: GLenum;
- readonly SHORT: GLenum;
- readonly SRC_ALPHA: GLenum;
- readonly SRC_ALPHA_SATURATE: GLenum;
- readonly SRC_COLOR: GLenum;
- readonly STATIC_DRAW: GLenum;
- readonly STENCIL_ATTACHMENT: GLenum;
- readonly STENCIL_BACK_FAIL: GLenum;
- readonly STENCIL_BACK_FUNC: GLenum;
- readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
- readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
- readonly STENCIL_BACK_REF: GLenum;
- readonly STENCIL_BACK_VALUE_MASK: GLenum;
- readonly STENCIL_BACK_WRITEMASK: GLenum;
- readonly STENCIL_BITS: GLenum;
- readonly STENCIL_BUFFER_BIT: GLenum;
- readonly STENCIL_CLEAR_VALUE: GLenum;
- readonly STENCIL_FAIL: GLenum;
- readonly STENCIL_FUNC: GLenum;
- readonly STENCIL_INDEX8: GLenum;
- readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
- readonly STENCIL_PASS_DEPTH_PASS: GLenum;
- readonly STENCIL_REF: GLenum;
- readonly STENCIL_TEST: GLenum;
- readonly STENCIL_VALUE_MASK: GLenum;
- readonly STENCIL_WRITEMASK: GLenum;
- readonly STREAM_DRAW: GLenum;
- readonly SUBPIXEL_BITS: GLenum;
- readonly TEXTURE: GLenum;
- readonly TEXTURE0: GLenum;
- readonly TEXTURE1: GLenum;
- readonly TEXTURE10: GLenum;
- readonly TEXTURE11: GLenum;
- readonly TEXTURE12: GLenum;
- readonly TEXTURE13: GLenum;
- readonly TEXTURE14: GLenum;
- readonly TEXTURE15: GLenum;
- readonly TEXTURE16: GLenum;
- readonly TEXTURE17: GLenum;
- readonly TEXTURE18: GLenum;
- readonly TEXTURE19: GLenum;
- readonly TEXTURE2: GLenum;
- readonly TEXTURE20: GLenum;
- readonly TEXTURE21: GLenum;
- readonly TEXTURE22: GLenum;
- readonly TEXTURE23: GLenum;
- readonly TEXTURE24: GLenum;
- readonly TEXTURE25: GLenum;
- readonly TEXTURE26: GLenum;
- readonly TEXTURE27: GLenum;
- readonly TEXTURE28: GLenum;
- readonly TEXTURE29: GLenum;
- readonly TEXTURE3: GLenum;
- readonly TEXTURE30: GLenum;
- readonly TEXTURE31: GLenum;
- readonly TEXTURE4: GLenum;
- readonly TEXTURE5: GLenum;
- readonly TEXTURE6: GLenum;
- readonly TEXTURE7: GLenum;
- readonly TEXTURE8: GLenum;
- readonly TEXTURE9: GLenum;
- readonly TEXTURE_2D: GLenum;
- readonly TEXTURE_BINDING_2D: GLenum;
- readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
- readonly TEXTURE_CUBE_MAP: GLenum;
- readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
- readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
- readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
- readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
- readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
- readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
- readonly TEXTURE_MAG_FILTER: GLenum;
- readonly TEXTURE_MIN_FILTER: GLenum;
- readonly TEXTURE_WRAP_S: GLenum;
- readonly TEXTURE_WRAP_T: GLenum;
- readonly TRIANGLES: GLenum;
- readonly TRIANGLE_FAN: GLenum;
- readonly TRIANGLE_STRIP: GLenum;
- readonly UNPACK_ALIGNMENT: GLenum;
- readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
- readonly UNPACK_FLIP_Y_WEBGL: GLenum;
- readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
- readonly UNSIGNED_BYTE: GLenum;
- readonly UNSIGNED_INT: GLenum;
- readonly UNSIGNED_SHORT: GLenum;
- readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
- readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
- readonly UNSIGNED_SHORT_5_6_5: GLenum;
- readonly VALIDATE_STATUS: GLenum;
- readonly VENDOR: GLenum;
- readonly VERSION: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
- readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
- readonly VERTEX_SHADER: GLenum;
- readonly VIEWPORT: GLenum;
- readonly ZERO: GLenum;
readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
readonly ALREADY_SIGNALED: GLenum;
readonly ANY_SAMPLES_PASSED: GLenum;
readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
readonly WAIT_FAILED: GLenum;
+ readonly ACTIVE_ATTRIBUTES: GLenum;
+ readonly ACTIVE_TEXTURE: GLenum;
+ readonly ACTIVE_UNIFORMS: GLenum;
+ readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
+ readonly ALIASED_POINT_SIZE_RANGE: GLenum;
+ readonly ALPHA: GLenum;
+ readonly ALPHA_BITS: GLenum;
+ readonly ALWAYS: GLenum;
+ readonly ARRAY_BUFFER: GLenum;
+ readonly ARRAY_BUFFER_BINDING: GLenum;
+ readonly ATTACHED_SHADERS: GLenum;
+ readonly BACK: GLenum;
+ readonly BLEND: GLenum;
+ readonly BLEND_COLOR: GLenum;
+ readonly BLEND_DST_ALPHA: GLenum;
+ readonly BLEND_DST_RGB: GLenum;
+ readonly BLEND_EQUATION: GLenum;
+ readonly BLEND_EQUATION_ALPHA: GLenum;
+ readonly BLEND_EQUATION_RGB: GLenum;
+ readonly BLEND_SRC_ALPHA: GLenum;
+ readonly BLEND_SRC_RGB: GLenum;
+ readonly BLUE_BITS: GLenum;
+ readonly BOOL: GLenum;
+ readonly BOOL_VEC2: GLenum;
+ readonly BOOL_VEC3: GLenum;
+ readonly BOOL_VEC4: GLenum;
+ readonly BROWSER_DEFAULT_WEBGL: GLenum;
+ readonly BUFFER_SIZE: GLenum;
+ readonly BUFFER_USAGE: GLenum;
+ readonly BYTE: GLenum;
+ readonly CCW: GLenum;
+ readonly CLAMP_TO_EDGE: GLenum;
+ readonly COLOR_ATTACHMENT0: GLenum;
+ readonly COLOR_BUFFER_BIT: GLenum;
+ readonly COLOR_CLEAR_VALUE: GLenum;
+ readonly COLOR_WRITEMASK: GLenum;
+ readonly COMPILE_STATUS: GLenum;
+ readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
+ readonly CONSTANT_ALPHA: GLenum;
+ readonly CONSTANT_COLOR: GLenum;
+ readonly CONTEXT_LOST_WEBGL: GLenum;
+ readonly CULL_FACE: GLenum;
+ readonly CULL_FACE_MODE: GLenum;
+ readonly CURRENT_PROGRAM: GLenum;
+ readonly CURRENT_VERTEX_ATTRIB: GLenum;
+ readonly CW: GLenum;
+ readonly DECR: GLenum;
+ readonly DECR_WRAP: GLenum;
+ readonly DELETE_STATUS: GLenum;
+ readonly DEPTH_ATTACHMENT: GLenum;
+ readonly DEPTH_BITS: GLenum;
+ readonly DEPTH_BUFFER_BIT: GLenum;
+ readonly DEPTH_CLEAR_VALUE: GLenum;
+ readonly DEPTH_COMPONENT: GLenum;
+ readonly DEPTH_COMPONENT16: GLenum;
+ readonly DEPTH_FUNC: GLenum;
+ readonly DEPTH_RANGE: GLenum;
+ readonly DEPTH_STENCIL: GLenum;
+ readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
+ readonly DEPTH_TEST: GLenum;
+ readonly DEPTH_WRITEMASK: GLenum;
+ readonly DITHER: GLenum;
+ readonly DONT_CARE: GLenum;
+ readonly DST_ALPHA: GLenum;
+ readonly DST_COLOR: GLenum;
+ readonly DYNAMIC_DRAW: GLenum;
+ readonly ELEMENT_ARRAY_BUFFER: GLenum;
+ readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
+ readonly EQUAL: GLenum;
+ readonly FASTEST: GLenum;
+ readonly FLOAT: GLenum;
+ readonly FLOAT_MAT2: GLenum;
+ readonly FLOAT_MAT3: GLenum;
+ readonly FLOAT_MAT4: GLenum;
+ readonly FLOAT_VEC2: GLenum;
+ readonly FLOAT_VEC3: GLenum;
+ readonly FLOAT_VEC4: GLenum;
+ readonly FRAGMENT_SHADER: GLenum;
+ readonly FRAMEBUFFER: GLenum;
+ readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
+ readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
+ readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
+ readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
+ readonly FRAMEBUFFER_BINDING: GLenum;
+ readonly FRAMEBUFFER_COMPLETE: GLenum;
+ readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
+ readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
+ readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
+ readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
+ readonly FRONT: GLenum;
+ readonly FRONT_AND_BACK: GLenum;
+ readonly FRONT_FACE: GLenum;
+ readonly FUNC_ADD: GLenum;
+ readonly FUNC_REVERSE_SUBTRACT: GLenum;
+ readonly FUNC_SUBTRACT: GLenum;
+ readonly GENERATE_MIPMAP_HINT: GLenum;
+ readonly GEQUAL: GLenum;
+ readonly GREATER: GLenum;
+ readonly GREEN_BITS: GLenum;
+ readonly HIGH_FLOAT: GLenum;
+ readonly HIGH_INT: GLenum;
+ readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
+ readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
+ readonly INCR: GLenum;
+ readonly INCR_WRAP: GLenum;
+ readonly INT: GLenum;
+ readonly INT_VEC2: GLenum;
+ readonly INT_VEC3: GLenum;
+ readonly INT_VEC4: GLenum;
+ readonly INVALID_ENUM: GLenum;
+ readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
+ readonly INVALID_OPERATION: GLenum;
+ readonly INVALID_VALUE: GLenum;
+ readonly INVERT: GLenum;
+ readonly KEEP: GLenum;
+ readonly LEQUAL: GLenum;
+ readonly LESS: GLenum;
+ readonly LINEAR: GLenum;
+ readonly LINEAR_MIPMAP_LINEAR: GLenum;
+ readonly LINEAR_MIPMAP_NEAREST: GLenum;
+ readonly LINES: GLenum;
+ readonly LINE_LOOP: GLenum;
+ readonly LINE_STRIP: GLenum;
+ readonly LINE_WIDTH: GLenum;
+ readonly LINK_STATUS: GLenum;
+ readonly LOW_FLOAT: GLenum;
+ readonly LOW_INT: GLenum;
+ readonly LUMINANCE: GLenum;
+ readonly LUMINANCE_ALPHA: GLenum;
+ readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
+ readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
+ readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
+ readonly MAX_RENDERBUFFER_SIZE: GLenum;
+ readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
+ readonly MAX_TEXTURE_SIZE: GLenum;
+ readonly MAX_VARYING_VECTORS: GLenum;
+ readonly MAX_VERTEX_ATTRIBS: GLenum;
+ readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
+ readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
+ readonly MAX_VIEWPORT_DIMS: GLenum;
+ readonly MEDIUM_FLOAT: GLenum;
+ readonly MEDIUM_INT: GLenum;
+ readonly MIRRORED_REPEAT: GLenum;
+ readonly NEAREST: GLenum;
+ readonly NEAREST_MIPMAP_LINEAR: GLenum;
+ readonly NEAREST_MIPMAP_NEAREST: GLenum;
+ readonly NEVER: GLenum;
+ readonly NICEST: GLenum;
+ readonly NONE: GLenum;
+ readonly NOTEQUAL: GLenum;
+ readonly NO_ERROR: GLenum;
+ readonly ONE: GLenum;
+ readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
+ readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
+ readonly ONE_MINUS_DST_ALPHA: GLenum;
+ readonly ONE_MINUS_DST_COLOR: GLenum;
+ readonly ONE_MINUS_SRC_ALPHA: GLenum;
+ readonly ONE_MINUS_SRC_COLOR: GLenum;
+ readonly OUT_OF_MEMORY: GLenum;
+ readonly PACK_ALIGNMENT: GLenum;
+ readonly POINTS: GLenum;
+ readonly POLYGON_OFFSET_FACTOR: GLenum;
+ readonly POLYGON_OFFSET_FILL: GLenum;
+ readonly POLYGON_OFFSET_UNITS: GLenum;
+ readonly RED_BITS: GLenum;
+ readonly RENDERBUFFER: GLenum;
+ readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
+ readonly RENDERBUFFER_BINDING: GLenum;
+ readonly RENDERBUFFER_BLUE_SIZE: GLenum;
+ readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
+ readonly RENDERBUFFER_GREEN_SIZE: GLenum;
+ readonly RENDERBUFFER_HEIGHT: GLenum;
+ readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
+ readonly RENDERBUFFER_RED_SIZE: GLenum;
+ readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
+ readonly RENDERBUFFER_WIDTH: GLenum;
+ readonly RENDERER: GLenum;
+ readonly REPEAT: GLenum;
+ readonly REPLACE: GLenum;
+ readonly RGB: GLenum;
+ readonly RGB565: GLenum;
+ readonly RGB5_A1: GLenum;
+ readonly RGBA: GLenum;
+ readonly RGBA4: GLenum;
+ readonly SAMPLER_2D: GLenum;
+ readonly SAMPLER_CUBE: GLenum;
+ readonly SAMPLES: GLenum;
+ readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
+ readonly SAMPLE_BUFFERS: GLenum;
+ readonly SAMPLE_COVERAGE: GLenum;
+ readonly SAMPLE_COVERAGE_INVERT: GLenum;
+ readonly SAMPLE_COVERAGE_VALUE: GLenum;
+ readonly SCISSOR_BOX: GLenum;
+ readonly SCISSOR_TEST: GLenum;
+ readonly SHADER_TYPE: GLenum;
+ readonly SHADING_LANGUAGE_VERSION: GLenum;
+ readonly SHORT: GLenum;
+ readonly SRC_ALPHA: GLenum;
+ readonly SRC_ALPHA_SATURATE: GLenum;
+ readonly SRC_COLOR: GLenum;
+ readonly STATIC_DRAW: GLenum;
+ readonly STENCIL_ATTACHMENT: GLenum;
+ readonly STENCIL_BACK_FAIL: GLenum;
+ readonly STENCIL_BACK_FUNC: GLenum;
+ readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
+ readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
+ readonly STENCIL_BACK_REF: GLenum;
+ readonly STENCIL_BACK_VALUE_MASK: GLenum;
+ readonly STENCIL_BACK_WRITEMASK: GLenum;
+ readonly STENCIL_BITS: GLenum;
+ readonly STENCIL_BUFFER_BIT: GLenum;
+ readonly STENCIL_CLEAR_VALUE: GLenum;
+ readonly STENCIL_FAIL: GLenum;
+ readonly STENCIL_FUNC: GLenum;
+ readonly STENCIL_INDEX8: GLenum;
+ readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
+ readonly STENCIL_PASS_DEPTH_PASS: GLenum;
+ readonly STENCIL_REF: GLenum;
+ readonly STENCIL_TEST: GLenum;
+ readonly STENCIL_VALUE_MASK: GLenum;
+ readonly STENCIL_WRITEMASK: GLenum;
+ readonly STREAM_DRAW: GLenum;
+ readonly SUBPIXEL_BITS: GLenum;
+ readonly TEXTURE: GLenum;
+ readonly TEXTURE0: GLenum;
+ readonly TEXTURE1: GLenum;
+ readonly TEXTURE10: GLenum;
+ readonly TEXTURE11: GLenum;
+ readonly TEXTURE12: GLenum;
+ readonly TEXTURE13: GLenum;
+ readonly TEXTURE14: GLenum;
+ readonly TEXTURE15: GLenum;
+ readonly TEXTURE16: GLenum;
+ readonly TEXTURE17: GLenum;
+ readonly TEXTURE18: GLenum;
+ readonly TEXTURE19: GLenum;
+ readonly TEXTURE2: GLenum;
+ readonly TEXTURE20: GLenum;
+ readonly TEXTURE21: GLenum;
+ readonly TEXTURE22: GLenum;
+ readonly TEXTURE23: GLenum;
+ readonly TEXTURE24: GLenum;
+ readonly TEXTURE25: GLenum;
+ readonly TEXTURE26: GLenum;
+ readonly TEXTURE27: GLenum;
+ readonly TEXTURE28: GLenum;
+ readonly TEXTURE29: GLenum;
+ readonly TEXTURE3: GLenum;
+ readonly TEXTURE30: GLenum;
+ readonly TEXTURE31: GLenum;
+ readonly TEXTURE4: GLenum;
+ readonly TEXTURE5: GLenum;
+ readonly TEXTURE6: GLenum;
+ readonly TEXTURE7: GLenum;
+ readonly TEXTURE8: GLenum;
+ readonly TEXTURE9: GLenum;
+ readonly TEXTURE_2D: GLenum;
+ readonly TEXTURE_BINDING_2D: GLenum;
+ readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
+ readonly TEXTURE_CUBE_MAP: GLenum;
+ readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
+ readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
+ readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
+ readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
+ readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
+ readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
+ readonly TEXTURE_MAG_FILTER: GLenum;
+ readonly TEXTURE_MIN_FILTER: GLenum;
+ readonly TEXTURE_WRAP_S: GLenum;
+ readonly TEXTURE_WRAP_T: GLenum;
+ readonly TRIANGLES: GLenum;
+ readonly TRIANGLE_FAN: GLenum;
+ readonly TRIANGLE_STRIP: GLenum;
+ readonly UNPACK_ALIGNMENT: GLenum;
+ readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
+ readonly UNPACK_FLIP_Y_WEBGL: GLenum;
+ readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
+ readonly UNSIGNED_BYTE: GLenum;
+ readonly UNSIGNED_INT: GLenum;
+ readonly UNSIGNED_SHORT: GLenum;
+ readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
+ readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
+ readonly UNSIGNED_SHORT_5_6_5: GLenum;
+ readonly VALIDATE_STATUS: GLenum;
+ readonly VENDOR: GLenum;
+ readonly VERSION: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
+ readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
+ readonly VERTEX_SHADER: GLenum;
+ readonly VIEWPORT: GLenum;
+ readonly ZERO: GLenum;
};
interface WebGL2RenderingContextBase {
};
/** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
-interface WebGLBuffer extends WebGLObject {
+interface WebGLBuffer {
}
declare var WebGLBuffer: {
};
/** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
-interface WebGLFramebuffer extends WebGLObject {
+interface WebGLFramebuffer {
}
declare var WebGLFramebuffer: {
new(): WebGLFramebuffer;
};
-interface WebGLObject {
-}
-
-declare var WebGLObject: {
- prototype: WebGLObject;
- new(): WebGLObject;
-};
-
/** 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). */
-interface WebGLProgram extends WebGLObject {
+interface WebGLProgram {
}
declare var WebGLProgram: {
new(): WebGLProgram;
};
-interface WebGLQuery extends WebGLObject {
+interface WebGLQuery {
}
declare var 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. */
-interface WebGLRenderbuffer extends WebGLObject {
+interface WebGLRenderbuffer {
}
declare var WebGLRenderbuffer: {
};
interface WebGLRenderingContextBase {
- readonly canvas: OffscreenCanvas;
readonly drawingBufferHeight: GLsizei;
readonly drawingBufferWidth: GLsizei;
activeTexture(texture: GLenum): void;
getContextAttributes(): WebGLContextAttributes | null;
getError(): GLenum;
getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
+ getExtension(extensionName: "EXT_color_buffer_float"): EXT_color_buffer_float | null;
+ getExtension(extensionName: "EXT_color_buffer_half_float"): EXT_color_buffer_half_float | null;
+ getExtension(extensionName: "EXT_float_blend"): EXT_float_blend | null;
getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
+ getExtension(extensionName: "KHR_parallel_shader_compile"): KHR_parallel_shader_compile | null;
getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
+ getExtension(extensionName: "OVR_multiview2"): OVR_multiview2 | null;
getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
+ getExtension(extensionName: "WEBGL_compressed_texture_etc"): WEBGL_compressed_texture_etc | null;
+ getExtension(extensionName: "WEBGL_compressed_texture_etc1"): WEBGL_compressed_texture_etc1 | null;
+ getExtension(extensionName: "WEBGL_compressed_texture_pvrtc"): WEBGL_compressed_texture_pvrtc | null;
getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
- getExtension(extensionName: string): any;
+ getExtension(name: string): any;
getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
getParameter(pname: GLenum): any;
getProgramInfoLog(program: WebGLProgram): string | null;
uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
}
-interface WebGLSampler extends WebGLObject {
+interface WebGLSampler {
}
declare var 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. */
-interface WebGLShader extends WebGLObject {
+interface WebGLShader {
}
declare var WebGLShader: {
new(): WebGLShaderPrecisionFormat;
};
-interface WebGLSync extends WebGLObject {
+interface WebGLSync {
}
declare var WebGLSync: {
};
/** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
-interface WebGLTexture extends WebGLObject {
+interface WebGLTexture {
}
declare var WebGLTexture: {
new(): WebGLTexture;
};
-interface WebGLTransformFeedback extends WebGLObject {
+interface WebGLTransformFeedback {
}
declare var WebGLTransformFeedback: {
new(): WebGLUniformLocation;
};
-interface WebGLVertexArrayObject extends WebGLObject {
+interface WebGLVertexArrayObject {
}
declare var WebGLVertexArrayObject: {
new(): WebGLVertexArrayObject;
};
-interface WebGLVertexArrayObjectOES extends WebGLObject {
+interface WebGLVertexArrayObjectOES {
}
interface WebSocketEventMap {
interface WebSocket extends EventTarget {
/**
* Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
- *
+ *
* Can be set, to change how binary data is returned. The default is "blob".
*/
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.
- *
+ *
* 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.)
*/
readonly bufferedAmount: number;
- /**
- * Returns the extensions selected by the server, if any.
- */
+ /** Returns the extensions selected by the server, if any. */
readonly extensions: string;
onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
onerror: ((this: WebSocket, ev: Event) => any) | null;
onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
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.
- */
+ /** 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. */
readonly protocol: string;
- /**
- * Returns the state of the WebSocket object's connection. It can have the values described below.
- */
+ /** Returns the state of the WebSocket object's connection. It can have the values described below. */
readonly readyState: number;
- /**
- * Returns the URL that was used to establish the WebSocket connection.
- */
+ /** Returns the URL that was used to establish the WebSocket connection. */
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.
- */
+ /** Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason. */
close(code?: number, reason?: string): void;
- /**
- * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
- */
+ /** Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView. */
send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
readonly CLOSED: number;
readonly CLOSING: number;
declare var WebSocket: {
prototype: WebSocket;
- new(url: string, protocols?: string | string[]): WebSocket;
+ new(url: string | URL, protocols?: string | string[]): WebSocket;
readonly CLOSED: number;
readonly CLOSING: number;
readonly CONNECTING: number;
/** 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. */
interface WindowClient extends Client {
- readonly ancestorOrigins: ReadonlyArray<string>;
readonly focused: boolean;
readonly visibilityState: VisibilityState;
focus(): Promise<WindowClient>;
- navigate(url: string): Promise<WindowClient | null>;
+ navigate(url: string | URL): Promise<WindowClient | null>;
}
declare var WindowClient: {
};
interface WindowOrWorkerGlobalScope {
+ /** Available only in secure contexts. */
readonly caches: CacheStorage;
+ readonly crossOriginIsolated: boolean;
readonly crypto: Crypto;
readonly indexedDB: IDBFactory;
readonly isSecureContext: boolean;
interface Worker extends EventTarget, AbstractWorker {
onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
- /**
- * 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.
- */
+ /** 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. */
postMessage(message: any, transfer: Transferable[]): void;
- postMessage(message: any, options?: PostMessageOptions): void;
- /**
- * Aborts worker's associated global environment.
- */
+ postMessage(message: any, options?: StructuredSerializeOptions): void;
+ /** Aborts worker's associated global environment. */
terminate(): void;
addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
declare var Worker: {
prototype: Worker;
- new(stringUrl: string | URL, options?: WorkerOptions): Worker;
+ new(scriptURL: string | URL, options?: WorkerOptions): Worker;
};
interface WorkerGlobalScopeEventMap {
}
/** 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. */
-interface WorkerGlobalScope extends EventTarget, WindowOrWorkerGlobalScope {
- /**
- * Returns workerGlobal's WorkerLocation object.
- */
+interface WorkerGlobalScope extends EventTarget, FontFaceSource, WindowOrWorkerGlobalScope {
+ /** Returns workerGlobal's WorkerLocation object. */
readonly location: WorkerLocation;
+ /** Returns workerGlobal's WorkerNavigator object. */
readonly navigator: WorkerNavigator;
onerror: ((this: WorkerGlobalScope, ev: ErrorEvent) => any) | null;
onlanguagechange: ((this: WorkerGlobalScope, ev: Event) => any) | null;
ononline: ((this: WorkerGlobalScope, ev: Event) => any) | null;
onrejectionhandled: ((this: WorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
onunhandledrejection: ((this: WorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
- /**
- * Returns workerGlobal.
- */
+ /** Returns workerGlobal. */
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).
- */
- importScripts(...urls: string[]): void;
+ /** 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). */
+ importScripts(...urls: (string | URL)[]): void;
addEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
};
/** 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. */
-interface WorkerNavigator extends NavigatorConcurrentHardware, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorStorage {
- readonly permissions: Permissions;
- readonly serviceWorker: ServiceWorkerContainer;
+interface WorkerNavigator extends NavigatorConcurrentHardware, NavigatorID, NavigatorLanguage, NavigatorNetworkInformation, NavigatorOnLine, NavigatorStorage {
+ readonly mediaCapabilities: MediaCapabilities;
}
declare var WorkerNavigator: {
interface WritableStream<W = any> {
readonly locked: boolean;
abort(reason?: any): Promise<void>;
+ close(): Promise<void>;
getWriter(): WritableStreamDefaultWriter<W>;
}
abort(reason?: any): Promise<void>;
close(): Promise<void>;
releaseLock(): void;
- write(chunk: W): Promise<void>;
+ write(chunk?: W): Promise<void>;
}
declare var WritableStreamDefaultWriter: {
/** 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. */
interface XMLHttpRequest extends XMLHttpRequestEventTarget {
onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
- /**
- * Returns client's state.
- */
+ /** Returns client's state. */
readonly readyState: number;
- /**
- * Returns the response's body.
- */
+ /** Returns the response body. */
readonly response: any;
/**
- * Returns the text response.
- *
+ * Returns response as text.
+ *
* Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
*/
readonly responseText: string;
/**
* Returns the response type.
- *
+ *
* 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.
*/
responseType: XMLHttpRequestResponseType;
readonly status: number;
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 the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
- *
+ * 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).
+ *
* When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
*/
timeout: number;
- /**
- * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
- */
+ /** Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server. */
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.
- *
+ *
* When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
*/
withCredentials: boolean;
- /**
- * Cancels any network activity.
- */
+ /** Cancels any network activity. */
abort(): void;
getAllResponseHeaders(): string;
getResponseHeader(name: string): string | null;
/**
* Sets the request method, request URL, and synchronous flag.
- *
- * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
- *
+ *
+ * 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.
*/
- open(method: string, url: string): void;
- open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
+ 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 response is mime. (It does not actually change the header though.)
- *
+ * Acts as if the `Content-Type` header value for a response is mime. (It does not change the header.)
+ *
* Throws an "InvalidStateError" DOMException if state is loading or done.
*/
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.
- *
+ *
* Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
*/
- send(body?: BodyInit | null): void;
+ send(body?: XMLHttpRequestBodyInit | null): void;
/**
* Combines a header in author request headers.
- *
+ *
* 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.
*/
setRequestHeader(name: string, value: string): void;
new(): XMLHttpRequestUpload;
};
-declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
-
interface Console {
- memory: any;
assert(condition?: boolean, ...data: any[]): void;
clear(): void;
count(label?: string): void;
dir(item?: any, options?: any): void;
dirxml(...data: any[]): void;
error(...data: any[]): void;
- exception(message?: string, ...optionalParams: any[]): void;
group(...data: any[]): void;
groupCollapsed(...data: any[]): void;
groupEnd(): void;
declare var console: Console;
declare namespace WebAssembly {
+ interface CompileError extends Error {
+ }
+
+ var CompileError: {
+ prototype: CompileError;
+ new(message?: string): CompileError;
+ (message?: string): CompileError;
+ };
+
interface Global {
value: any;
valueOf(): any;
}
-
+
var Global: {
prototype: Global;
new(descriptor: GlobalDescriptor, v?: any): Global;
};
-
+
interface Instance {
readonly exports: Exports;
}
-
+
var Instance: {
prototype: Instance;
new(module: Module, importObject?: Imports): Instance;
};
-
+
+ interface LinkError extends Error {
+ }
+
+ var LinkError: {
+ prototype: LinkError;
+ new(message?: string): LinkError;
+ (message?: string): LinkError;
+ };
+
interface Memory {
readonly buffer: ArrayBuffer;
grow(delta: number): number;
}
-
+
var Memory: {
prototype: Memory;
new(descriptor: MemoryDescriptor): Memory;
};
-
+
interface Module {
}
-
+
var Module: {
prototype: Module;
new(bytes: BufferSource): Module;
exports(moduleObject: Module): ModuleExportDescriptor[];
imports(moduleObject: Module): ModuleImportDescriptor[];
};
-
+
+ interface RuntimeError extends Error {
+ }
+
+ var RuntimeError: {
+ prototype: RuntimeError;
+ new(message?: string): RuntimeError;
+ (message?: string): RuntimeError;
+ };
+
interface Table {
readonly length: number;
- get(index: number): Function | null;
- grow(delta: number): number;
- set(index: number, value: Function | null): void;
+ get(index: number): any;
+ grow(delta: number, value?: any): number;
+ set(index: number, value?: any): void;
}
-
+
var Table: {
prototype: Table;
- new(descriptor: TableDescriptor): Table;
+ new(descriptor: TableDescriptor, value?: any): Table;
};
-
+
interface GlobalDescriptor {
mutable?: boolean;
value: ValueType;
}
-
+
interface MemoryDescriptor {
initial: number;
maximum?: number;
+ shared?: boolean;
}
-
+
interface ModuleExportDescriptor {
kind: ImportExportKind;
name: string;
}
-
+
interface ModuleImportDescriptor {
kind: ImportExportKind;
module: string;
name: string;
}
-
+
interface TableDescriptor {
element: TableKind;
initial: number;
maximum?: number;
}
-
+
interface WebAssemblyInstantiatedSource {
instance: Instance;
module: Module;
}
-
+
type ImportExportKind = "function" | "global" | "memory" | "table";
- type TableKind = "anyfunc";
- type ValueType = "f32" | "f64" | "i32" | "i64";
+ type TableKind = "anyfunc" | "externref";
+ type ValueType = "anyfunc" | "externref" | "f32" | "f64" | "i32" | "i64";
type ExportValue = Function | Global | Memory | Table;
type Exports = Record<string, ExportValue>;
type ImportValue = ExportValue | number;
- type ModuleImports = Record<string, ImportValue>;
type Imports = Record<string, ModuleImports>;
+ type ModuleImports = Record<string, ImportValue>;
function compile(bytes: BufferSource): Promise<Module>;
- function compileStreaming(source: Response | Promise<Response>): Promise<Module>;
+ function compileStreaming(source: Response | PromiseLike<Response>): Promise<Module>;
function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
- function instantiateStreaming(response: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
+ function instantiateStreaming(source: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
function validate(bytes: BufferSource): boolean;
}
interface FrameRequestCallback {
- (time: number): void;
+ (time: DOMHighResTimeStamp): void;
}
interface OnErrorEventHandlerNonNull {
}
interface TransformerStartCallback<O> {
- (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+ (controller: TransformStreamDefaultController<O>): any;
}
interface TransformerTransformCallback<I, O> {
}
interface UnderlyingSinkAbortCallback {
- (reason: any): void | PromiseLike<void>;
+ (reason?: any): void | PromiseLike<void>;
}
interface UnderlyingSinkCloseCallback {
}
interface UnderlyingSinkStartCallback {
- (controller: WritableStreamDefaultController): void | PromiseLike<void>;
+ (controller: WritableStreamDefaultController): any;
}
interface UnderlyingSinkWriteCallback<W> {
}
interface UnderlyingSourceCancelCallback {
- (reason: any): void | PromiseLike<void>;
+ (reason?: any): void | PromiseLike<void>;
}
interface UnderlyingSourcePullCallback<R> {
}
interface UnderlyingSourceStartCallback<R> {
- (controller: ReadableStreamController<R>): void | PromiseLike<void>;
+ (controller: ReadableStreamController<R>): any;
}
interface VoidFunction {
(): void;
}
-/**
- * Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging.
- */
+/** Returns dedicatedWorkerGlobal's name, i.e. the value given to the Worker constructor. Primarily useful for debugging. */
declare var name: string;
declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
declare var onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
-/**
- * Aborts dedicatedWorkerGlobal.
- */
+/** Aborts dedicatedWorkerGlobal. */
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.
- */
+/** 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. */
declare function postMessage(message: any, transfer: Transferable[]): void;
-declare function postMessage(message: any, options?: PostMessageOptions): 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.
- */
+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. */
declare function dispatchEvent(event: Event): boolean;
-/**
- * Returns workerGlobal's WorkerLocation object.
- */
+/** Returns workerGlobal's WorkerLocation object. */
declare var location: WorkerLocation;
+/** Returns workerGlobal's WorkerNavigator object. */
declare var navigator: WorkerNavigator;
declare var onerror: ((this: DedicatedWorkerGlobalScope, ev: ErrorEvent) => any) | null;
declare var onlanguagechange: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
declare var ononline: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null;
declare var onrejectionhandled: ((this: DedicatedWorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
declare var onunhandledrejection: ((this: DedicatedWorkerGlobalScope, ev: PromiseRejectionEvent) => any) | null;
-/**
- * Returns workerGlobal.
- */
+/** Returns workerGlobal. */
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).
- */
-declare function importScripts(...urls: string[]): 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.
- */
+/** 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). */
+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. */
declare function dispatchEvent(event: Event): boolean;
+declare var fonts: FontFaceSet;
+/** Available only in secure contexts. */
declare var caches: CacheStorage;
+declare var crossOriginIsolated: boolean;
declare var crypto: Crypto;
declare var indexedDB: IDBFactory;
declare var isSecureContext: boolean;
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 HeadersInit = Headers | string[][] | Record<string, string>;
-type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
-type RequestInfo = Request | string;
+type AlgorithmIdentifier = Algorithm | string;
+type BigInteger = Uint8Array;
+type BinaryData = ArrayBuffer | ArrayBufferView;
type BlobPart = BufferSource | Blob | string;
-type DOMHighResTimeStamp = number;
+type BodyInit = ReadableStream | XMLHttpRequestBodyInit;
+type BufferSource = ArrayBufferView | ArrayBuffer;
type CanvasImageSource = ImageBitmap | OffscreenCanvas;
-type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
-type MessageEventSource = MessagePort | ServiceWorker;
-type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
-type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
-type TimerHandler = string | Function;
-type PerformanceEntryList = PerformanceEntry[];
-type PushMessageDataInit = BufferSource | string;
-type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
-type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
-type VibratePattern = number | number[];
-type AlgorithmIdentifier = string | Algorithm;
-type HashAlgorithmIdentifier = AlgorithmIdentifier;
-type BigInteger = Uint8Array;
-type NamedCurve = string;
-type GLenum = number;
-type GLboolean = boolean;
+type DOMHighResTimeStamp = number;
+type DOMTimeStamp = number;
+type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+type Float32List = Float32Array | GLfloat[];
+type FormDataEntryValue = File | string;
type GLbitfield = number;
+type GLboolean = boolean;
+type GLclampf = number;
+type GLenum = number;
+type GLfloat = number;
type GLint = number;
-type GLsizei = number;
+type GLint64 = number;
type GLintptr = number;
+type GLsizei = number;
type GLsizeiptr = number;
type GLuint = number;
-type GLfloat = number;
-type GLclampf = number;
-type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas;
-type Float32List = Float32Array | GLfloat[];
-type Int32List = Int32Array | GLint[];
-type GLint64 = number;
type GLuint64 = number;
-type Uint32List = Uint32Array | GLuint[];
-type BufferSource = ArrayBufferView | ArrayBuffer;
-type DOMTimeStamp = number;
-type FormDataEntryValue = File | string;
-type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
-type Transferable = ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas;
+type HashAlgorithmIdentifier = AlgorithmIdentifier;
+type HeadersInit = string[][] | Record<string, string> | Headers;
+type IDBValidKey = number | string | Date | BufferSource | IDBValidKey[];
+type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
+type Int32List = Int32Array | GLint[];
+type MessageEventSource = MessagePort | ServiceWorker;
+type NamedCurve = string;
+type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
+type PerformanceEntryList = PerformanceEntry[];
+type PushMessageDataInit = BufferSource | string;
+type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
+type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
+type RequestInfo = Request | string;
+type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas;
+type TimerHandler = string | Function;
+type Transferable = ArrayBuffer | MessagePort | ImageBitmap;
+type Uint32List = Uint32Array | GLuint[];
+type VibratePattern = number | number[];
+type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string;
type BinaryType = "arraybuffer" | "blob";
-type CanvasDirection = "inherit" | "ltr" | "rtl";
-type CanvasFillRule = "evenodd" | "nonzero";
-type CanvasLineCap = "butt" | "round" | "square";
-type CanvasLineJoin = "bevel" | "miter" | "round";
-type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
-type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
type ClientTypes = "all" | "sharedworker" | "window" | "worker";
+type ColorGamut = "p3" | "rec2020" | "srgb";
type ColorSpaceConversion = "default" | "none";
+type ConnectionType = "bluetooth" | "cellular" | "ethernet" | "mixed" | "none" | "other" | "unknown" | "wifi";
type EndingType = "native" | "transparent";
+type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded";
+type FontFaceSetLoadStatus = "loaded" | "loading";
type FrameType = "auxiliary" | "nested" | "none" | "top-level";
+type HdrMetadataType = "smpteSt2086" | "smpteSt2094-10" | "smpteSt2094-40";
type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
type IDBRequestReadyState = "done" | "pending";
type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
type ImageOrientation = "flipY" | "none";
-type ImageSmoothingQuality = "high" | "low" | "medium";
type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
type KeyType = "private" | "public" | "secret";
type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+type MediaDecodingType = "file" | "media-source" | "webrtc";
+type MediaEncodingType = "record" | "webrtc";
type NotificationDirection = "auto" | "ltr" | "rtl";
type NotificationPermission = "default" | "denied" | "granted";
-type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2";
-type PermissionName = "accelerometer" | "ambient-light-sensor" | "background-fetch" | "background-sync" | "bluetooth" | "camera" | "clipboard-read" | "clipboard-write" | "device-info" | "display-capture" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "midi" | "nfc" | "notifications" | "persistent-storage" | "push" | "speaker";
+type PermissionName = "geolocation" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "xr-spatial-tracking";
type PermissionState = "denied" | "granted" | "prompt";
+type PredefinedColorSpace = "display-p3" | "srgb";
type PremultiplyAlpha = "default" | "none" | "premultiply";
type PushEncryptionKeyName = "auth" | "p256dh";
type PushPermissionState = "denied" | "granted" | "prompt";
type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
type RequestCredentials = "include" | "omit" | "same-origin";
-type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
+type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
type RequestRedirect = "error" | "follow" | "manual";
type ResizeQuality = "high" | "low" | "medium" | "pixelated";
type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
+type SecurityPolicyViolationEventDisposition = "enforce" | "report";
type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
+type TransferFunction = "hlg" | "pq" | "srgb";
type VisibilityState = "hidden" | "visible";
type WebGLPowerPreference = "default" | "high-performance" | "low-power";
type WorkerType = "classic" | "module";
projects / dotfiles / .git / blobdiff