/////////////////////////////

/// Worker APIs

/////////////////////////////

interface AddEventListenerOptions extends EventListenerOptions {

once?: boolean;

passive?: boolean;

}

interface AesCbcParams extends Algorithm {

iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface AesCtrParams extends Algorithm {

counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

length: number;

}

interface AesDerivedKeyParams extends Algorithm {

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;

tagLength?: number;

}

interface AesKeyAlgorithm extends KeyAlgorithm {

length: number;

}

interface AesKeyGenParams extends Algorithm {

length: number;

}

interface Algorithm {

name: string;

}

interface BlobPropertyBag {

type?: string;

}

interface CacheQueryOptions {

cacheName?: string;

ignoreMethod?: boolean;

ignoreSearch?: boolean;

ignoreVary?: boolean;

}

interface ClientQueryOptions {

includeUncontrolled?: boolean;

type?: ClientTypes;

}

interface CloseEventInit extends EventInit {

code?: number;

reason?: string;

wasClean?: boolean;

}

interface CryptoKeyPair {

privateKey?: CryptoKey;

publicKey?: CryptoKey;

}

interface CustomEventInit<T = any> extends EventInit {

detail?: T;

}

interface DOMMatrix2DInit {

a?: number;

b?: number;

c?: number;

d?: number;

e?: number;

f?: number;

m11?: number;

m12?: number;

m21?: number;

m22?: number;

m41?: number;

m42?: number;

}

interface DOMMatrixInit extends DOMMatrix2DInit {

is2D?: boolean;

m13?: number;

m14?: number;

m23?: number;

m24?: number;

m31?: number;

m32?: number;

m33?: number;

m34?: number;

m43?: number;

m44?: number;

}

interface DOMPointInit {

w?: number;

x?: number;

y?: number;

z?: number;

}

interface DOMQuadInit {

p1?: DOMPointInit;

p2?: DOMPointInit;

p3?: DOMPointInit;

p4?: DOMPointInit;

}

interface DOMRectInit {

height?: number;

width?: number;

x?: number;

y?: number;

}

interface EcKeyGenParams extends Algorithm {

namedCurve: NamedCurve;

}

interface EcKeyImportParams extends Algorithm {

namedCurve: NamedCurve;

}

interface EcdhKeyDeriveParams extends Algorithm {

public: CryptoKey;

}

interface EcdsaParams extends Algorithm {

hash: HashAlgorithmIdentifier;

}

interface ErrorEventInit extends EventInit {

colno?: number;

error?: any;

filename?: string;

lineno?: number;

message?: string;

}

interface EventInit {

bubbles?: boolean;

cancelable?: boolean;

composed?: boolean;

}

interface EventListenerOptions {

capture?: boolean;

}

interface ExtendableEventInit extends EventInit {

}

interface ExtendableMessageEventInit extends ExtendableEventInit {

data?: any;

lastEventId?: string;

origin?: string;

ports?: MessagePort[];

source?: Client | ServiceWorker | MessagePort | null;

}

interface FetchEventInit extends ExtendableEventInit {

clientId?: string;

preloadResponse?: Promise<any>;

request: Request;

resultingClientId?: string;

targetClientId?: string;

}

interface FilePropertyBag extends BlobPropertyBag {

lastModified?: number;

}

interface GetNotificationOptions {

tag?: string;

}

interface HmacImportParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface HmacKeyGenParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface IDBIndexParameters {

multiEntry?: boolean;

unique?: boolean;

}

interface IDBObjectStoreParameters {

autoIncrement?: boolean;

keyPath?: string | string[] | null;

}

interface IDBVersionChangeEventInit extends EventInit {

newVersion?: number | null;

oldVersion?: number;

}

interface JsonWebKey {

alg?: string;

crv?: string;

d?: string;

dp?: string;

dq?: string;

e?: string;

ext?: boolean;

k?: string;

key_ops?: string[];

kty?: string;

n?: string;

oth?: RsaOtherPrimesInfo[];

p?: string;

q?: string;

qi?: string;

use?: string;

x?: string;

y?: string;

}

interface KeyAlgorithm {

name: string;

}

interface MessageEventInit extends EventInit {

data?: any;

lastEventId?: string;

origin?: string;

ports?: MessagePort[];

source?: MessageEventSource | null;

}

interface NavigationPreloadState {

enabled?: boolean;

headerValue?: string;

}

interface NotificationAction {

action: string;

icon?: string;

title: string;

}

interface NotificationEventInit extends ExtendableEventInit {

action?: string;

notification: Notification;

}

interface NotificationOptions {

actions?: NotificationAction[];

badge?: string;

body?: string;

data?: any;

dir?: NotificationDirection;

icon?: string;

image?: string;

lang?: string;

renotify?: boolean;

requireInteraction?: boolean;

silent?: boolean;

tag?: string;

timestamp?: number;

vibrate?: VibratePattern;

}

interface Pbkdf2Params extends Algorithm {

hash: HashAlgorithmIdentifier;

iterations: number;

salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface PerformanceObserverInit {

buffered?: boolean;

entryTypes: string[];

}

interface ProgressEventInit extends EventInit {

lengthComputable?: boolean;

loaded?: number;

total?: number;

}

interface PromiseRejectionEventInit extends EventInit {

promise: Promise<any>;

reason?: any;

}

interface PushEventInit extends ExtendableEventInit {

data?: PushMessageDataInit;

}

interface PushSubscriptionChangeInit extends ExtendableEventInit {

newSubscription?: PushSubscription;

oldSubscription?: PushSubscription;

}

interface PushSubscriptionJSON {

endpoint?: string;

expirationTime?: number | null;

keys?: Record<string, string>;

}

interface PushSubscriptionOptionsInit {

applicationServerKey?: BufferSource | string | null;

userVisibleOnly?: boolean;

}

interface RegistrationOptions {

scope?: string;

type?: WorkerType;

updateViaCache?: ServiceWorkerUpdateViaCache;

}

interface RequestInit {

body?: BodyInit | null;

cache?: RequestCache;

credentials?: RequestCredentials;

headers?: HeadersInit;

integrity?: string;

keepalive?: boolean;

method?: string;

mode?: RequestMode;

redirect?: RequestRedirect;

referrer?: string;

referrerPolicy?: ReferrerPolicy;

signal?: AbortSignal | null;

window?: any;

}

interface ResponseInit {

headers?: HeadersInit;

status?: number;

statusText?: string;

}

interface RsaHashedImportParams extends Algorithm {

hash: HashAlgorithmIdentifier;

}

interface RsaHashedKeyGenParams extends RsaKeyGenParams {

hash: HashAlgorithmIdentifier;

}

interface RsaKeyGenParams extends Algorithm {

modulusLength: number;

publicExponent: BigInteger;

}

interface RsaOaepParams extends Algorithm {

label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface RsaOtherPrimesInfo {

d?: string;

r?: string;

t?: string;

}

interface RsaPssParams extends Algorithm {

saltLength: number;

}

interface StorageEstimate {

quota?: number;

usage?: number;

}

interface SyncEventInit extends ExtendableEventInit {

lastChance?: boolean;

tag: string;

}

interface TextDecodeOptions {

stream?: boolean;

}

interface TextDecoderOptions {

fatal?: boolean;

ignoreBOM?: boolean;

}

interface EventListener {

(evt: Event): void;

}

interface AbortController {

/**

* Returns the AbortSignal object associated with this object.

*/

readonly signal: AbortSignal;

/**

* Invoking this method will set this object's AbortSignal's aborted flag and

* signal to any observers that the associated activity is to be aborted.

*/

abort(): void;

}

declare var AbortController: {

prototype: AbortController;

new(): AbortController;

};

interface AbortSignalEventMap {

"abort": ProgressEvent;

}

interface AbortSignal extends EventTarget {

/**

* Returns true if this AbortSignal's AbortController has signaled to abort, and false

* otherwise.

*/

readonly aborted: boolean;

onabort: ((this: AbortSignal, ev: ProgressEvent) => any) | null;

addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

declare var AbortSignal: {

prototype: AbortSignal;

new(): AbortSignal;

};

interface AbstractWorkerEventMap {

"error": ErrorEvent;

}

interface AbstractWorker {

onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;

addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, 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: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

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 Blob {

readonly size: number;

readonly type: string;

slice(start?: number, end?: number, contentType?: string): Blob;

}

declare var Blob: {

prototype: Blob;

new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;

};

interface Body {

readonly body: ReadableStream | null;

readonly bodyUsed: boolean;

arrayBuffer(): Promise<ArrayBuffer>;

blob(): Promise<Blob>;

formData(): Promise<FormData>;

json(): Promise<any>;

text(): Promise<string>;

}

interface BroadcastChannelEventMap {

"message": MessageEvent;

"messageerror": MessageEvent;

}

interface BroadcastChannel extends EventTarget {

/**

* 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.

*/

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.

*/

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;

removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

declare var BroadcastChannel: {

prototype: BroadcastChannel;

new(name: string): BroadcastChannel;

};

interface BroadcastChannelEventMap {

message: MessageEvent;

messageerror: MessageEvent;

}

interface Cache {

add(request: RequestInfo): Promise<void>;

addAll(requests: RequestInfo[]): Promise<void>;

delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;

keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;

match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;

matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;

put(request: RequestInfo, response: Response): Promise<void>;

}

declare var Cache: {

prototype: Cache;

new(): Cache;

};

interface CacheStorage {

delete(cacheName: string): Promise<boolean>;

has(cacheName: string): Promise<boolean>;

keys(): Promise<string[]>;

match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;

open(cacheName: string): Promise<Cache>;

}

declare var CacheStorage: {

prototype: CacheStorage;

new(): CacheStorage;

};

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;

}

declare var CanvasGradient: {

prototype: CanvasGradient;

new(): CanvasGradient;

};

interface CanvasPath {

arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: 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;

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 CanvasPattern {

/**

* Sets the transformation matrix that will be used when rendering the pattern during a fill or

* stroke painting operation.

*/

setTransform(transform?: DOMMatrix2DInit): void;

}

declare var CanvasPattern: {

prototype: CanvasPattern;

new(): CanvasPattern;

};

interface Client {

readonly id: string;

readonly type: ClientTypes;

readonly url: string;

postMessage(message: any, transfer?: Transferable[]): void;

}

declare var Client: {

prototype: Client;

new(): Client;

};

interface Clients {

claim(): Promise<void>;

get(id: string): Promise<any>;

matchAll(options?: ClientQueryOptions): Promise<ReadonlyArray<Client>>;

openWindow(url: string): Promise<WindowClient | null>;

}

declare var Clients: {

prototype: Clients;

new(): Clients;

};

interface CloseEvent extends Event {

readonly code: number;

readonly reason: string;

readonly wasClean: boolean;

/** @deprecated */

initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;

}

declare var CloseEvent: {

prototype: CloseEvent;

new(type: string, eventInitDict?: CloseEventInit): CloseEvent;

};

interface ConcatParams extends Algorithm {

algorithmId: Uint8Array;

hash?: string | Algorithm;

partyUInfo: Uint8Array;

partyVInfo: Uint8Array;

privateInfo?: Uint8Array;

publicInfo?: Uint8Array;

}

interface Console {

memory: any;

assert(condition?: boolean, message?: string, ...data: any[]): void;

clear(): void;

count(label?: string): void;

debug(message?: any, ...optionalParams: any[]): void;

dir(value?: any, ...optionalParams: any[]): void;

dirxml(value: any): void;

error(message?: any, ...optionalParams: any[]): void;

exception(message?: string, ...optionalParams: any[]): void;

group(groupTitle?: string, ...optionalParams: any[]): void;

groupCollapsed(groupTitle?: string, ...optionalParams: any[]): void;

groupEnd(): void;

info(message?: any, ...optionalParams: any[]): void;

log(message?: any, ...optionalParams: any[]): void;

markTimeline(label?: string): void;

profile(reportName?: string): void;

profileEnd(reportName?: string): void;

table(...tabularData: any[]): void;

time(label?: string): void;

timeEnd(label?: string): void;

timeStamp(label?: string): void;

timeline(label?: string): void;

timelineEnd(label?: string): void;

trace(message?: any, ...optionalParams: any[]): void;

warn(message?: any, ...optionalParams: any[]): void;

}

declare var Console: {

prototype: Console;

new(): Console;

};

interface Crypto {

readonly subtle: SubtleCrypto;

getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;

}

declare var Crypto: {

prototype: Crypto;

new(): Crypto;

};

interface CryptoKey {

readonly algorithm: KeyAlgorithm;

readonly extractable: boolean;

readonly type: KeyType;

readonly usages: KeyUsage[];

}

declare var CryptoKey: {

prototype: CryptoKey;

new(): CryptoKey;

};

interface CustomEvent<T = any> extends Event {

/**

* 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;

}

declare var CustomEvent: {

prototype: CustomEvent;

new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;

};

interface DOMException {

readonly code: number;

readonly message: string;

readonly name: string;

readonly ABORT_ERR: number;

readonly DATA_CLONE_ERR: number;

readonly DOMSTRING_SIZE_ERR: number;

readonly HIERARCHY_REQUEST_ERR: number;

readonly INDEX_SIZE_ERR: number;

readonly INUSE_ATTRIBUTE_ERR: number;

readonly INVALID_ACCESS_ERR: number;

readonly INVALID_CHARACTER_ERR: number;

readonly INVALID_MODIFICATION_ERR: number;

readonly INVALID_NODE_TYPE_ERR: number;

readonly INVALID_STATE_ERR: number;

readonly NAMESPACE_ERR: number;

readonly NETWORK_ERR: number;

readonly NOT_FOUND_ERR: number;

readonly NOT_SUPPORTED_ERR: number;

readonly NO_DATA_ALLOWED_ERR: number;

readonly NO_MODIFICATION_ALLOWED_ERR: number;

readonly QUOTA_EXCEEDED_ERR: number;

readonly SECURITY_ERR: number;

readonly SYNTAX_ERR: number;

readonly TIMEOUT_ERR: number;

readonly TYPE_MISMATCH_ERR: number;

readonly URL_MISMATCH_ERR: number;

readonly VALIDATION_ERR: number;

readonly WRONG_DOCUMENT_ERR: number;

}

declare var DOMException: {

prototype: DOMException;

new(message?: string, name?: string): DOMException;

readonly ABORT_ERR: number;

readonly DATA_CLONE_ERR: number;

readonly DOMSTRING_SIZE_ERR: number;

readonly HIERARCHY_REQUEST_ERR: number;

readonly INDEX_SIZE_ERR: number;

readonly INUSE_ATTRIBUTE_ERR: number;

readonly INVALID_ACCESS_ERR: number;

readonly INVALID_CHARACTER_ERR: number;

readonly INVALID_MODIFICATION_ERR: number;

readonly INVALID_NODE_TYPE_ERR: number;

readonly INVALID_STATE_ERR: number;

readonly NAMESPACE_ERR: number;

readonly NETWORK_ERR: number;

readonly NOT_FOUND_ERR: number;

readonly NOT_SUPPORTED_ERR: number;

readonly NO_DATA_ALLOWED_ERR: number;

readonly NO_MODIFICATION_ALLOWED_ERR: number;

readonly QUOTA_EXCEEDED_ERR: number;

readonly SECURITY_ERR: number;

readonly SYNTAX_ERR: number;

readonly TIMEOUT_ERR: number;

readonly TYPE_MISMATCH_ERR: number;

readonly URL_MISMATCH_ERR: number;

readonly VALIDATION_ERR: number;

readonly WRONG_DOCUMENT_ERR: number;

};

interface DOMMatrix extends DOMMatrixReadOnly {

a: number;

b: number;

c: number;

d: number;

e: number;

f: number;

m11: number;

m12: number;

m13: number;

m14: number;

m21: number;

m22: number;

m23: number;

m24: number;

m31: number;

m32: number;

m33: number;

m34: number;

m41: number;

m42: number;

m43: number;

m44: number;

invertSelf(): DOMMatrix;

multiplySelf(other?: DOMMatrixInit): DOMMatrix;

preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;

rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;

rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;

rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;

scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

skewXSelf(sx?: number): DOMMatrix;

skewYSelf(sy?: number): DOMMatrix;

translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;

}

declare var DOMMatrix: {

prototype: DOMMatrix;

new(init?: string | number[]): DOMMatrix;

fromFloat32Array(array32: Float32Array): DOMMatrix;

fromFloat64Array(array64: Float64Array): DOMMatrix;

fromMatrix(other?: DOMMatrixInit): DOMMatrix;

};

interface DOMMatrixReadOnly {

readonly a: number;

readonly b: number;

readonly c: number;

readonly d: number;

readonly e: number;

readonly f: number;

readonly is2D: boolean;

readonly isIdentity: boolean;

readonly m11: number;

readonly m12: number;

readonly m13: number;

readonly m14: number;

readonly m21: number;

readonly m22: number;

readonly m23: number;

readonly m24: number;

readonly m31: number;

readonly m32: number;

readonly m33: number;

readonly m34: number;

readonly m41: number;

readonly m42: number;

readonly m43: number;

readonly m44: number;

flipX(): DOMMatrix;

flipY(): DOMMatrix;

inverse(): DOMMatrix;

multiply(other?: DOMMatrixInit): DOMMatrix;

rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;

rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;

rotateFromVector(x?: number, y?: number): DOMMatrix;

scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

skewX(sx?: number): DOMMatrix;

skewY(sy?: number): DOMMatrix;

toFloat32Array(): Float32Array;

toFloat64Array(): Float64Array;

toJSON(): any;

transformPoint(point?: DOMPointInit): DOMPoint;

translate(tx?: number, ty?: number, tz?: number): DOMMatrix;

}

declare var DOMMatrixReadOnly: {

prototype: DOMMatrixReadOnly;

new(init?: string | number[]): DOMMatrixReadOnly;

fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;

fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;

fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;

};

interface DOMPoint extends DOMPointReadOnly {

w: number;

x: number;

y: number;

z: number;

}

declare var DOMPoint: {

prototype: DOMPoint;

new(x?: number, y?: number, z?: number, w?: number): DOMPoint;

fromPoint(other?: DOMPointInit): DOMPoint;

};

interface DOMPointReadOnly {

readonly w: number;

readonly x: number;

readonly y: number;

readonly z: number;

matrixTransform(matrix?: DOMMatrixInit): DOMPoint;

toJSON(): any;

}

declare var DOMPointReadOnly: {

prototype: DOMPointReadOnly;

new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;

fromPoint(other?: DOMPointInit): DOMPointReadOnly;

};

interface DOMQuad {

readonly p1: DOMPoint;

readonly p2: DOMPoint;

readonly p3: DOMPoint;

readonly p4: DOMPoint;

getBounds(): DOMRect;

toJSON(): any;

}

declare var DOMQuad: {

prototype: DOMQuad;

new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;

fromQuad(other?: DOMQuadInit): DOMQuad;

fromRect(other?: DOMRectInit): DOMQuad;

};

interface DOMRect extends DOMRectReadOnly {

height: number;

width: number;

x: number;

y: number;

}

declare var DOMRect: {

prototype: DOMRect;

new(x?: number, y?: number, width?: number, height?: number): DOMRect;

fromRect(other?: DOMRectInit): DOMRect;

};

interface DOMRectReadOnly {

readonly bottom: number;

readonly height: number;

readonly left: number;

readonly right: number;

readonly top: number;

readonly width: number;

readonly x: number;

readonly y: number;

toJSON(): any;

}

declare var DOMRectReadOnly: {

prototype: DOMRectReadOnly;

new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;

fromRect(other?: DOMRectInit): DOMRectReadOnly;

};

interface DOMStringList {

/**

* Returns the number of strings in strings.

*/

readonly length: number;

/**

* Returns true if strings contains string, and false

* otherwise.

*/

contains(string: string): boolean;

/**

* Returns the string with index index from strings.

*/

item(index: number): string | null;

[index: number]: string;

}

declare var DOMStringList: {

prototype: DOMStringList;

new(): DOMStringList;

};

interface DedicatedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {

"message": MessageEvent;

}

interface DedicatedWorkerGlobalScope extends WorkerGlobalScope {

onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;

close(): void;

postMessage(message: any, transfer?: Transferable[]): 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;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

declare var DedicatedWorkerGlobalScope: {

prototype: DedicatedWorkerGlobalScope;

new(): DedicatedWorkerGlobalScope;

};

interface DhImportKeyParams extends Algorithm {

generator: Uint8Array;

prime: Uint8Array;

}

interface DhKeyAlgorithm extends KeyAlgorithm {

generator: Uint8Array;

prime: Uint8Array;

}

interface DhKeyDeriveParams extends Algorithm {

public: CryptoKey;

}

interface DhKeyGenParams extends Algorithm {

generator: Uint8Array;

prime: Uint8Array;

}

interface ErrorEvent extends Event {

readonly colno: number;

readonly error: any;

readonly filename: string;

readonly lineno: number;

readonly message: string;

}

declare var ErrorEvent: {

prototype: ErrorEvent;

new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;

};

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.