diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index a695016f9..476c1a8be 100755 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -1916,7 +1916,8 @@ interface ANGLE_instanced_arrays { } /** A controller object that allows you to abort one or more DOM requests as and when desired. */ -interface AbortController { +declare class AbortController { + constructor(); /** * Returns the AbortSignal object associated with this object. */ @@ -1927,17 +1928,12 @@ interface AbortController { abort(): void; } -declare var AbortController: { - prototype: AbortController; - new(): AbortController; -}; - interface AbortSignalEventMap { "abort": Event; } /** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */ -interface AbortSignal extends EventTarget { +declare class AbortSignal extends EventTarget { /** * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */ @@ -1949,12 +1945,7 @@ interface AbortSignal extends EventTarget { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var AbortSignal: { - prototype: AbortSignal; - new(): AbortSignal; -}; - -interface AbstractRange { +declare class AbstractRange { /** * Returns true if range is collapsed, and false otherwise. */ @@ -1977,11 +1968,6 @@ interface AbstractRange { readonly startOffset: number; } -declare var AbstractRange: { - prototype: AbstractRange; - new(): AbstractRange; -}; - interface AbstractWorkerEventMap { "error": ErrorEvent; } @@ -2003,7 +1989,8 @@ interface AesCmacParams extends Algorithm { } /** A node able to provide real-time frequency and time-domain analysis information. It is an AudioNode that passes the audio stream unchanged from the input to the output, but allows you to take the generated data, process it, and create audio visualizations. */ -interface AnalyserNode extends AudioNode { +declare class AnalyserNode extends AudioNode { + constructor(context: BaseAudioContext, options?: AnalyserOptions); fftSize: number; readonly frequencyBinCount: number; maxDecibels: number; @@ -2015,11 +2002,6 @@ interface AnalyserNode extends AudioNode { getFloatTimeDomainData(array: Float32Array): void; } -declare var AnalyserNode: { - prototype: AnalyserNode; - new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode; -}; - interface Animatable { animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation; getAnimations(): Animation[]; @@ -2030,7 +2012,8 @@ interface AnimationEventMap { "finish": AnimationPlaybackEvent; } -interface Animation extends EventTarget { +declare class Animation extends EventTarget { + constructor(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null); currentTime: number | null; effect: AnimationEffect | null; readonly finished: Promise; @@ -2055,58 +2038,35 @@ interface Animation extends EventTarget { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var Animation: { - prototype: Animation; - new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation; -}; - -interface AnimationEffect { +declare class AnimationEffect { getComputedTiming(): ComputedEffectTiming; getTiming(): EffectTiming; updateTiming(timing?: OptionalEffectTiming): void; } -declare var AnimationEffect: { - prototype: AnimationEffect; - new(): AnimationEffect; -}; - /** Events providing information related to animations. */ -interface AnimationEvent extends Event { +declare class AnimationEvent extends Event { + constructor(type: string, animationEventInitDict?: AnimationEventInit); readonly animationName: string; readonly elapsedTime: number; readonly pseudoElement: string; } -declare var AnimationEvent: { - prototype: AnimationEvent; - new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent; -}; - interface AnimationFrameProvider { cancelAnimationFrame(handle: number): void; requestAnimationFrame(callback: FrameRequestCallback): number; } -interface AnimationPlaybackEvent extends Event { +declare class AnimationPlaybackEvent extends Event { + constructor(type: string, eventInitDict?: AnimationPlaybackEventInit); readonly currentTime: number | null; readonly timelineTime: number | null; } -declare var AnimationPlaybackEvent: { - prototype: AnimationPlaybackEvent; - new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent; -}; - -interface AnimationTimeline { +declare class AnimationTimeline { readonly currentTime: number | null; } -declare var AnimationTimeline: { - prototype: AnimationTimeline; - new(): AnimationTimeline; -}; - interface ApplicationCacheEventMap { "cached": Event; "checking": Event; @@ -2118,7 +2078,7 @@ interface ApplicationCacheEventMap { "updateready": Event; } -interface ApplicationCache extends EventTarget { +declare class ApplicationCache extends EventTarget { /** @deprecated */ oncached: ((this: ApplicationCache, ev: Event) => any) | null; /** @deprecated */ @@ -2153,21 +2113,16 @@ interface ApplicationCache extends EventTarget { addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; removeEventListener(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void; removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; + static readonly CHECKING: number; + static readonly DOWNLOADING: number; + static readonly IDLE: number; + static readonly OBSOLETE: number; + static readonly UNCACHED: number; + static readonly UPDATEREADY: number; } -declare var ApplicationCache: { - prototype: ApplicationCache; - new(): ApplicationCache; - readonly CHECKING: number; - readonly DOWNLOADING: number; - readonly IDLE: number; - readonly OBSOLETE: number; - readonly UNCACHED: number; - readonly UPDATEREADY: number; -}; - /** A DOM element's attribute as an object. In most DOM methods, you will probably directly retrieve the attribute as a string (e.g., Element.getAttribute(), but certain functions (e.g., Element.getAttributeNode()) or means of iterating give Attr types. */ -interface Attr extends Node { +declare class Attr extends Node { readonly localName: string; readonly name: string; readonly namespaceURI: string | null; @@ -2178,13 +2133,9 @@ interface Attr extends Node { value: string; } -declare var Attr: { - prototype: Attr; - new(): Attr; -}; - /** A short audio asset residing in memory, created from an audio file using the AudioContext.decodeAudioData() method, or from raw data using AudioContext.createBuffer(). Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode. */ -interface AudioBuffer { +declare class AudioBuffer { + constructor(options: AudioBufferOptions); readonly duration: number; readonly length: number; readonly numberOfChannels: number; @@ -2194,13 +2145,9 @@ interface AudioBuffer { getChannelData(channel: number): Float32Array; } -declare var AudioBuffer: { - prototype: AudioBuffer; - new(options: AudioBufferOptions): AudioBuffer; -}; - /** An AudioScheduledSourceNode which represents an audio source consisting of in-memory audio data, stored in an AudioBuffer. It's especially useful for playing back audio which has particularly stringent timing accuracy requirements, such as for sounds that must match a specific rhythm and can be kept in memory rather than being played from disk or the network. */ -interface AudioBufferSourceNode extends AudioScheduledSourceNode { +declare class AudioBufferSourceNode extends AudioScheduledSourceNode { + constructor(context: BaseAudioContext, options?: AudioBufferSourceOptions); buffer: AudioBuffer | null; readonly detune: AudioParam; loop: boolean; @@ -2214,13 +2161,9 @@ interface AudioBufferSourceNode extends AudioScheduledSourceNode { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var AudioBufferSourceNode: { - prototype: AudioBufferSourceNode; - new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode; -}; - /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */ -interface AudioContext extends BaseAudioContext { +declare class AudioContext extends BaseAudioContext { + constructor(contextOptions?: AudioContextOptions); readonly baseLatency: number; readonly outputLatency: number; close(): Promise; @@ -2237,23 +2180,13 @@ interface AudioContext extends BaseAudioContext { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var AudioContext: { - prototype: AudioContext; - new(contextOptions?: AudioContextOptions): AudioContext; -}; - /** AudioDestinationNode has no output (as it is the output, no more AudioNode can be linked after it in the audio graph) and one input. The number of channels in the input must be between 0 and the maxChannelCount value or an exception is raised. */ -interface AudioDestinationNode extends AudioNode { +declare class AudioDestinationNode extends AudioNode { readonly maxChannelCount: number; } -declare var AudioDestinationNode: { - prototype: AudioDestinationNode; - new(): AudioDestinationNode; -}; - /** The position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to the AudioListener stored in the BaseAudioContext.listener attribute. */ -interface AudioListener { +declare class AudioListener { readonly forwardX: AudioParam; readonly forwardY: AudioParam; readonly forwardZ: AudioParam; @@ -2269,13 +2202,8 @@ interface AudioListener { setPosition(x: number, y: number, z: number): void; } -declare var AudioListener: { - prototype: AudioListener; - new(): AudioListener; -}; - /** A generic interface for representing an audio processing module. Examples include: */ -interface AudioNode extends EventTarget { +declare class AudioNode extends EventTarget { channelCount: number; channelCountMode: ChannelCountMode; channelInterpretation: ChannelInterpretation; @@ -2293,13 +2221,8 @@ interface AudioNode extends EventTarget { disconnect(destinationParam: AudioParam, output: number): void; } -declare var AudioNode: { - prototype: AudioNode; - new(): AudioNode; -}; - /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */ -interface AudioParam { +declare class AudioParam { automationRate: AutomationRate; readonly defaultValue: number; readonly maxValue: number; @@ -2314,37 +2237,23 @@ interface AudioParam { setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam; } -declare var AudioParam: { - prototype: AudioParam; - new(): AudioParam; -}; - -interface AudioParamMap { +declare class AudioParamMap { forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void; } -declare var AudioParamMap: { - prototype: AudioParamMap; - new(): AudioParamMap; -}; - /** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed. */ -interface AudioProcessingEvent extends Event { +declare class AudioProcessingEvent extends Event { + constructor(type: string, eventInitDict: AudioProcessingEventInit); readonly inputBuffer: AudioBuffer; readonly outputBuffer: AudioBuffer; readonly playbackTime: number; } -declare var AudioProcessingEvent: { - prototype: AudioProcessingEvent; - new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent; -}; - interface AudioScheduledSourceNodeEventMap { "ended": Event; } -interface AudioScheduledSourceNode extends AudioNode { +declare class AudioScheduledSourceNode extends AudioNode { onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null; start(when?: number): void; stop(when?: number): void; @@ -2354,24 +2263,15 @@ interface AudioScheduledSourceNode extends AudioNode { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var AudioScheduledSourceNode: { - prototype: AudioScheduledSourceNode; - new(): AudioScheduledSourceNode; -}; - -interface AudioWorklet extends Worklet { +declare class AudioWorklet extends Worklet { } -declare var AudioWorklet: { - prototype: AudioWorklet; - new(): AudioWorklet; -}; - interface AudioWorkletNodeEventMap { "processorerror": Event; } -interface AudioWorkletNode extends AudioNode { +declare class AudioWorkletNode extends AudioNode { + constructor(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions); onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null; readonly parameters: AudioParamMap; readonly port: MessagePort; @@ -2381,54 +2281,29 @@ interface AudioWorkletNode extends AudioNode { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var AudioWorkletNode: { - prototype: AudioWorkletNode; - new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode; -}; - -interface AuthenticatorAssertionResponse extends AuthenticatorResponse { +declare class AuthenticatorAssertionResponse extends AuthenticatorResponse { readonly authenticatorData: ArrayBuffer; readonly signature: ArrayBuffer; readonly userHandle: ArrayBuffer | null; } -declare var AuthenticatorAssertionResponse: { - prototype: AuthenticatorAssertionResponse; - new(): AuthenticatorAssertionResponse; -}; - -interface AuthenticatorAttestationResponse extends AuthenticatorResponse { +declare class AuthenticatorAttestationResponse extends AuthenticatorResponse { readonly attestationObject: ArrayBuffer; } -declare var AuthenticatorAttestationResponse: { - prototype: AuthenticatorAttestationResponse; - new(): AuthenticatorAttestationResponse; -}; - -interface AuthenticatorResponse { +declare class AuthenticatorResponse { readonly clientDataJSON: ArrayBuffer; } -declare var AuthenticatorResponse: { - prototype: AuthenticatorResponse; - new(): AuthenticatorResponse; -}; - -interface BarProp { +declare class BarProp { readonly visible: boolean; } -declare var BarProp: { - prototype: BarProp; - new(): BarProp; -}; - interface BaseAudioContextEventMap { "statechange": Event; } -interface BaseAudioContext extends EventTarget { +declare class BaseAudioContext extends EventTarget { readonly audioWorklet: AudioWorklet; readonly currentTime: number; readonly destination: AudioDestinationNode; @@ -2461,22 +2336,12 @@ interface BaseAudioContext extends EventTarget { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var BaseAudioContext: { - prototype: BaseAudioContext; - new(): BaseAudioContext; -}; - /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */ -interface BeforeUnloadEvent extends Event { +declare class BeforeUnloadEvent extends Event { returnValue: any; } -declare var BeforeUnloadEvent: { - prototype: BeforeUnloadEvent; - new(): BeforeUnloadEvent; -}; - -interface BhxBrowser { +declare class BhxBrowser { readonly lastError: DOMException; checkMatchesGlobExpression(pattern: string, value: string): boolean; checkMatchesUriExpression(pattern: string, value: string): boolean; @@ -2493,13 +2358,9 @@ interface BhxBrowser { webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void; } -declare var BhxBrowser: { - prototype: BhxBrowser; - new(): BhxBrowser; -}; - /** A simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. */ -interface BiquadFilterNode extends AudioNode { +declare class BiquadFilterNode extends AudioNode { + constructor(context: BaseAudioContext, options?: BiquadFilterOptions); readonly Q: AudioParam; readonly detune: AudioParam; readonly frequency: AudioParam; @@ -2508,13 +2369,9 @@ interface BiquadFilterNode extends AudioNode { getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void; } -declare var BiquadFilterNode: { - prototype: BiquadFilterNode; - new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode; -}; - /** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */ -interface Blob { +declare class Blob { + constructor(blobParts?: BlobPart[], options?: BlobPropertyBag); readonly size: number; readonly type: string; arrayBuffer(): Promise; @@ -2523,11 +2380,6 @@ interface Blob { text(): Promise; } -declare var Blob: { - prototype: Blob; - new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob; -}; - interface Body { readonly body: ReadableStream | null; readonly bodyUsed: boolean; @@ -2543,7 +2395,8 @@ interface BroadcastChannelEventMap { "messageerror": MessageEvent; } -interface BroadcastChannel extends EventTarget { +declare class BroadcastChannel extends EventTarget { + constructor(name: string); /** * Returns the channel name (as passed to the constructor). */ @@ -2564,86 +2417,48 @@ interface BroadcastChannel extends EventTarget { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var BroadcastChannel: { - prototype: BroadcastChannel; - new(name: string): BroadcastChannel; -}; - /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */ -interface ByteLengthQueuingStrategy extends QueuingStrategy { +interface ByteLengthQueuingStrategy extends QueuingStrategy {} +declare class ByteLengthQueuingStrategy { + constructor(options: { highWaterMark: number }); highWaterMark: number; size(chunk: ArrayBufferView): number; } -declare var ByteLengthQueuingStrategy: { - prototype: ByteLengthQueuingStrategy; - new(options: { highWaterMark: number }): ByteLengthQueuingStrategy; -}; - /** A CDATA section that can be used within XML to include extended portions of unescaped text. The symbols < and & don’t need escaping as they normally do when inside a CDATA section. */ -interface CDATASection extends Text { +declare class CDATASection extends Text { } -declare var CDATASection: { - prototype: CDATASection; - new(): CDATASection; -}; - /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */ -interface CSSConditionRule extends CSSGroupingRule { +declare class CSSConditionRule extends CSSGroupingRule { conditionText: string; } -declare var CSSConditionRule: { - prototype: CSSConditionRule; - new(): CSSConditionRule; -}; - -interface CSSFontFaceRule extends CSSRule { +declare class CSSFontFaceRule extends CSSRule { readonly style: CSSStyleDeclaration; } -declare var CSSFontFaceRule: { - prototype: CSSFontFaceRule; - new(): CSSFontFaceRule; -}; - /** Any CSS at-rule that contains other rules nested within it. */ -interface CSSGroupingRule extends CSSRule { +declare class CSSGroupingRule extends CSSRule { readonly cssRules: CSSRuleList; deleteRule(index: number): void; insertRule(rule: string, index?: number): number; } -declare var CSSGroupingRule: { - prototype: CSSGroupingRule; - new(): CSSGroupingRule; -}; - -interface CSSImportRule extends CSSRule { +declare class CSSImportRule extends CSSRule { readonly href: string; readonly media: MediaList; readonly styleSheet: CSSStyleSheet; } -declare var CSSImportRule: { - prototype: CSSImportRule; - new(): CSSImportRule; -}; - /** An object representing a set of style for a given keyframe. It corresponds to the contains of a single keyframe of a @keyframes at-rule. It implements the CSSRule interface with a type value of 8 (CSSRule.KEYFRAME_RULE). */ -interface CSSKeyframeRule extends CSSRule { +declare class CSSKeyframeRule extends CSSRule { keyText: string; readonly style: CSSStyleDeclaration; } -declare var CSSKeyframeRule: { - prototype: CSSKeyframeRule; - new(): CSSKeyframeRule; -}; - /** An object representing a complete set of keyframes for a CSS animation. It corresponds to the contains of a whole @keyframes at-rule. It implements the CSSRule interface with a type value of 7 (CSSRule.KEYFRAMES_RULE). */ -interface CSSKeyframesRule extends CSSRule { +declare class CSSKeyframesRule extends CSSRule { readonly cssRules: CSSRuleList; name: string; appendRule(rule: string): void; @@ -2651,45 +2466,25 @@ interface CSSKeyframesRule extends CSSRule { findRule(select: string): CSSKeyframeRule | null; } -declare var CSSKeyframesRule: { - prototype: CSSKeyframesRule; - new(): CSSKeyframesRule; -}; - /** A single CSS @media rule. It implements the CSSConditionRule interface, and therefore the CSSGroupingRule and the CSSRule interface with a type value of 4 (CSSRule.MEDIA_RULE). */ -interface CSSMediaRule extends CSSConditionRule { +declare class CSSMediaRule extends CSSConditionRule { readonly media: MediaList; } -declare var CSSMediaRule: { - prototype: CSSMediaRule; - new(): CSSMediaRule; -}; - /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */ -interface CSSNamespaceRule extends CSSRule { +declare class CSSNamespaceRule extends CSSRule { readonly namespaceURI: string; readonly prefix: string; } -declare var CSSNamespaceRule: { - prototype: CSSNamespaceRule; - new(): CSSNamespaceRule; -}; - /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */ -interface CSSPageRule extends CSSGroupingRule { +declare class CSSPageRule extends CSSGroupingRule { selectorText: string; readonly style: CSSStyleDeclaration; } -declare var CSSPageRule: { - prototype: CSSPageRule; - new(): CSSPageRule; -}; - /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */ -interface CSSRule { +declare class CSSRule { cssText: string; readonly parentRule: CSSRule | null; readonly parentStyleSheet: CSSStyleSheet | null; @@ -2704,37 +2499,27 @@ interface CSSRule { readonly PAGE_RULE: number; readonly STYLE_RULE: number; readonly SUPPORTS_RULE: number; + static readonly CHARSET_RULE: number; + static readonly FONT_FACE_RULE: number; + static readonly IMPORT_RULE: number; + static readonly KEYFRAMES_RULE: number; + static readonly KEYFRAME_RULE: number; + static readonly MEDIA_RULE: number; + static readonly NAMESPACE_RULE: number; + static readonly PAGE_RULE: number; + static readonly STYLE_RULE: number; + static readonly SUPPORTS_RULE: number; } -declare var CSSRule: { - prototype: CSSRule; - new(): CSSRule; - readonly CHARSET_RULE: number; - readonly FONT_FACE_RULE: number; - readonly IMPORT_RULE: number; - readonly KEYFRAMES_RULE: number; - readonly KEYFRAME_RULE: number; - readonly MEDIA_RULE: number; - readonly NAMESPACE_RULE: number; - readonly PAGE_RULE: number; - readonly STYLE_RULE: number; - readonly SUPPORTS_RULE: number; -}; - /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */ -interface CSSRuleList { +declare class CSSRuleList { readonly length: number; item(index: number): CSSRule | null; [index: number]: CSSRule; } -declare var CSSRuleList: { - prototype: CSSRuleList; - new(): CSSRuleList; -}; - /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */ -interface CSSStyleDeclaration { +declare class CSSStyleDeclaration { alignContent: string; alignItems: string; alignSelf: string; @@ -3196,24 +2981,14 @@ interface CSSStyleDeclaration { [index: number]: string; } -declare var CSSStyleDeclaration: { - prototype: CSSStyleDeclaration; - new(): CSSStyleDeclaration; -}; - /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */ -interface CSSStyleRule extends CSSRule { +declare class CSSStyleRule extends CSSRule { selectorText: string; readonly style: CSSStyleDeclaration; } -declare var CSSStyleRule: { - prototype: CSSStyleRule; - new(): CSSStyleRule; -}; - /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */ -interface CSSStyleSheet extends StyleSheet { +declare class CSSStyleSheet extends StyleSheet { readonly cssRules: CSSRuleList; readonly ownerRule: CSSRule | null; readonly rules: CSSRuleList; @@ -3223,22 +2998,12 @@ interface CSSStyleSheet extends StyleSheet { removeRule(index?: number): void; } -declare var CSSStyleSheet: { - prototype: CSSStyleSheet; - new(): CSSStyleSheet; -}; - /** An object representing a single CSS @supports at-rule. It implements the CSSConditionRule interface, and therefore the CSSRule and CSSGroupingRule interfaces with a type value of 12 (CSSRule.SUPPORTS_RULE). */ -interface CSSSupportsRule extends CSSConditionRule { +declare class CSSSupportsRule extends CSSConditionRule { } -declare var CSSSupportsRule: { - prototype: CSSSupportsRule; - new(): CSSSupportsRule; -}; - /** 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. */ -interface Cache { +declare class Cache { add(request: RequestInfo): Promise; addAll(requests: RequestInfo[]): Promise; delete(request: RequestInfo, options?: CacheQueryOptions): Promise; @@ -3248,13 +3013,8 @@ interface Cache { put(request: RequestInfo, response: Response): Promise; } -declare var Cache: { - prototype: Cache; - new(): Cache; -}; - /** The storage for Cache objects. */ -interface CacheStorage { +declare class CacheStorage { delete(cacheName: string): Promise; has(cacheName: string): Promise; keys(): Promise; @@ -3262,11 +3022,6 @@ interface CacheStorage { open(cacheName: string): Promise; } -declare var CacheStorage: { - prototype: CacheStorage; - new(): CacheStorage; -}; - interface CanvasCompositing { globalAlpha: number; globalCompositeOperation: string; @@ -3305,7 +3060,7 @@ interface CanvasFilters { } /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */ -interface CanvasGradient { +declare class 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. * @@ -3314,11 +3069,6 @@ interface CanvasGradient { addColorStop(offset: number, color: string): void; } -declare var CanvasGradient: { - prototype: CanvasGradient; - new(): CanvasGradient; -}; - interface CanvasImageData { createImageData(sw: number, sh: number): ImageData; createImageData(imagedata: ImageData): ImageData; @@ -3355,18 +3105,13 @@ interface CanvasPathDrawingStyles { } /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */ -interface CanvasPattern { +declare class 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 CanvasRect { clearRect(x: number, y: number, w: number, h: number): void; fillRect(x: number, y: number, w: number, h: number): void; @@ -3374,15 +3119,11 @@ interface CanvasRect { } /** The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a element. It is used for drawing shapes, text, images, and other objects. */ -interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface { +interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {} +declare class CanvasRenderingContext2D { readonly canvas: HTMLCanvasElement; } -declare var CanvasRenderingContext2D: { - prototype: CanvasRenderingContext2D; - new(): CanvasRenderingContext2D; -}; - interface CanvasShadowStyles { shadowBlur: number; shadowColor: string; @@ -3426,37 +3167,25 @@ interface CanvasUserInterface { scrollPathIntoView(path: Path2D): void; } -interface CaretPosition { +declare class CaretPosition { readonly offset: number; readonly offsetNode: Node; getClientRect(): DOMRect | null; } -declare var CaretPosition: { - prototype: CaretPosition; - new(): CaretPosition; -}; - /** The ChannelMergerNode interface, often used in conjunction with its opposite, ChannelSplitterNode, reunites different mono inputs into a single output. Each input is used to fill a channel of the output. This is useful for accessing each channels separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */ -interface ChannelMergerNode extends AudioNode { +declare class ChannelMergerNode extends AudioNode { + constructor(context: BaseAudioContext, options?: ChannelMergerOptions); } -declare var ChannelMergerNode: { - prototype: ChannelMergerNode; - new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode; -}; - /** The ChannelSplitterNode interface, often used in conjunction with its opposite, ChannelMergerNode, separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */ -interface ChannelSplitterNode extends AudioNode { +declare class ChannelSplitterNode extends AudioNode { + constructor(context: BaseAudioContext, options?: ChannelSplitterOptions); } -declare var ChannelSplitterNode: { - prototype: ChannelSplitterNode; - new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode; -}; - /** The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any object of type CharacterData: it is implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't abstract. */ -interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode { +interface CharacterData extends ChildNode, NonDocumentTypeChildNode {} +declare class CharacterData extends Node { data: string; readonly length: number; readonly ownerDocument: Document; @@ -3467,11 +3196,6 @@ interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode { substringData(offset: number, count: number): string; } -declare var CharacterData: { - prototype: CharacterData; - new(): CharacterData; -}; - interface ChildNode extends Node { /** * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes. @@ -3497,7 +3221,7 @@ interface ChildNode extends Node { replaceWith(...nodes: (Node | string)[]): void; } -interface ClientRect { +declare class ClientRect { bottom: number; readonly height: number; left: number; @@ -3506,44 +3230,26 @@ interface ClientRect { readonly width: number; } -declare var ClientRect: { - prototype: ClientRect; - new(): ClientRect; -}; - -interface ClientRectList { +declare class ClientRectList { readonly length: number; item(index: number): ClientRect; [index: number]: ClientRect; } -declare var ClientRectList: { - prototype: ClientRectList; - new(): ClientRectList; -}; - -interface Clipboard extends EventTarget { +declare class Clipboard extends EventTarget { readText(): Promise; writeText(data: string): Promise; } -declare var Clipboard: { - prototype: Clipboard; - new(): Clipboard; -}; - /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */ -interface ClipboardEvent extends Event { +declare class ClipboardEvent extends Event { + constructor(type: string, eventInitDict?: ClipboardEventInit); readonly clipboardData: DataTransfer | null; } -declare var ClipboardEvent: { - prototype: ClipboardEvent; - new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent; -}; - /** 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 { +declare class CloseEvent extends Event { + constructor(type: string, eventInitDict?: CloseEventInit); /** * Returns the WebSocket connection close code provided by the server. */ @@ -3558,30 +3264,17 @@ interface CloseEvent extends Event { readonly wasClean: boolean; } -declare var CloseEvent: { - prototype: CloseEvent; - new(type: string, eventInitDict?: CloseEventInit): CloseEvent; -}; - /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */ -interface Comment extends CharacterData { +declare class Comment extends CharacterData { + constructor(data?: string); } -declare var Comment: { - prototype: Comment; - new(data?: string): Comment; -}; - /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */ -interface CompositionEvent extends UIEvent { +declare class CompositionEvent extends UIEvent { + constructor(type: string, eventInitDict?: CompositionEventInit); readonly data: string; } -declare var CompositionEvent: { - prototype: CompositionEvent; - new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent; -}; - interface ConcatParams extends Algorithm { algorithmId: Uint8Array; hash?: string | Algorithm; @@ -3591,7 +3284,8 @@ interface ConcatParams extends Algorithm { publicInfo?: Uint8Array; } -interface ConstantSourceNode extends AudioScheduledSourceNode { +declare class ConstantSourceNode extends AudioScheduledSourceNode { + constructor(context: BaseAudioContext, options?: ConstantSourceOptions); readonly offset: AudioParam; addEventListener(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -3599,22 +3293,13 @@ interface ConstantSourceNode extends AudioScheduledSourceNode { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var ConstantSourceNode: { - prototype: ConstantSourceNode; - new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode; -}; - /** An AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. A ConvolverNode always has exactly one input and one output. */ -interface ConvolverNode extends AudioNode { +declare class ConvolverNode extends AudioNode { + constructor(context: BaseAudioContext, options?: ConvolverOptions); buffer: AudioBuffer | null; normalize: boolean; } -declare var ConvolverNode: { - prototype: ConvolverNode; - new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode; -}; - /** The position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated. */ interface Coordinates { readonly accuracy: number; @@ -3627,86 +3312,54 @@ interface Coordinates { } /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */ -interface CountQueuingStrategy extends QueuingStrategy { +interface CountQueuingStrategy extends QueuingStrategy {} +declare class CountQueuingStrategy { + constructor(options: { highWaterMark: number }); highWaterMark: number; size(chunk: any): 1; } -declare var CountQueuingStrategy: { - prototype: CountQueuingStrategy; - new(options: { highWaterMark: number }): CountQueuingStrategy; -}; - -interface Credential { +declare class Credential { readonly id: string; readonly type: string; } -declare var Credential: { - prototype: Credential; - new(): Credential; -}; - -interface CredentialsContainer { +declare class CredentialsContainer { create(options?: CredentialCreationOptions): Promise; get(options?: CredentialRequestOptions): Promise; preventSilentAccess(): Promise; store(credential: Credential): Promise; } -declare var CredentialsContainer: { - prototype: CredentialsContainer; - new(): CredentialsContainer; -}; - /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */ -interface Crypto { +declare class Crypto { readonly subtle: SubtleCrypto; getRandomValues(array: T): T; } -declare var Crypto: { - prototype: Crypto; - new(): Crypto; -}; - /** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */ -interface CryptoKey { +declare class CryptoKey { readonly algorithm: KeyAlgorithm; readonly extractable: boolean; readonly type: KeyType; readonly usages: KeyUsage[]; } -declare var CryptoKey: { - prototype: CryptoKey; - new(): CryptoKey; -}; - /** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */ -interface CryptoKeyPair { +declare class CryptoKeyPair { privateKey: CryptoKey; publicKey: CryptoKey; } -declare var CryptoKeyPair: { - prototype: CryptoKeyPair; - new(): CryptoKeyPair; -}; - -interface CustomElementRegistry { +declare class CustomElementRegistry { define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void; get(name: string): any; upgrade(root: Node): void; whenDefined(name: string): Promise; } -declare var CustomElementRegistry: { - prototype: CustomElementRegistry; - new(): CustomElementRegistry; -}; - -interface CustomEvent extends Event { +declare class CustomEvent extends Event { + constructor(typeArg: string, eventInitDict?: CustomEventInit); /** * Returns any custom data event was created with. Typically used for synthetic events. */ @@ -3714,24 +3367,15 @@ interface CustomEvent extends Event { initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void; } -declare var CustomEvent: { - prototype: CustomEvent; - new(typeArg: string, eventInitDict?: CustomEventInit): CustomEvent; -}; - /** An error object that contains an error name. */ -interface DOMError { +declare class DOMError { readonly name: string; toString(): string; } -declare var DOMError: { - prototype: DOMError; - new(): DOMError; -}; - /** 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 { +declare class DOMException { + constructor(message?: string, name?: string); readonly code: number; readonly message: string; readonly name: string; @@ -3760,40 +3404,35 @@ interface DOMException { readonly URL_MISMATCH_ERR: number; readonly VALIDATION_ERR: number; readonly WRONG_DOCUMENT_ERR: number; + static readonly ABORT_ERR: number; + static readonly DATA_CLONE_ERR: number; + static readonly DOMSTRING_SIZE_ERR: number; + static readonly HIERARCHY_REQUEST_ERR: number; + static readonly INDEX_SIZE_ERR: number; + static readonly INUSE_ATTRIBUTE_ERR: number; + static readonly INVALID_ACCESS_ERR: number; + static readonly INVALID_CHARACTER_ERR: number; + static readonly INVALID_MODIFICATION_ERR: number; + static readonly INVALID_NODE_TYPE_ERR: number; + static readonly INVALID_STATE_ERR: number; + static readonly NAMESPACE_ERR: number; + static readonly NETWORK_ERR: number; + static readonly NOT_FOUND_ERR: number; + static readonly NOT_SUPPORTED_ERR: number; + static readonly NO_DATA_ALLOWED_ERR: number; + static readonly NO_MODIFICATION_ALLOWED_ERR: number; + static readonly QUOTA_EXCEEDED_ERR: number; + static readonly SECURITY_ERR: number; + static readonly SYNTAX_ERR: number; + static readonly TIMEOUT_ERR: number; + static readonly TYPE_MISMATCH_ERR: number; + static readonly URL_MISMATCH_ERR: number; + static readonly VALIDATION_ERR: number; + static 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; -}; - /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */ -interface DOMImplementation { +declare class DOMImplementation { createDocument(namespaceURI: string | null, qualifiedName: string | null, doctype: DocumentType | null): Document; createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType; createHTMLDocument(title?: string): Document; @@ -3801,16 +3440,12 @@ interface DOMImplementation { hasFeature(...args: any[]): true; } -declare var DOMImplementation: { - prototype: DOMImplementation; - new(): DOMImplementation; -}; - interface DOML2DeprecatedColorProperty { color: string; } -interface DOMMatrix extends DOMMatrixReadOnly { +declare class DOMMatrix extends DOMMatrixReadOnly { + constructor(init?: string | number[]); a: number; b: number; c: number; @@ -3845,23 +3480,19 @@ interface DOMMatrix extends DOMMatrixReadOnly { skewXSelf(sx?: number): DOMMatrix; skewYSelf(sy?: number): DOMMatrix; translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix; + static fromFloat32Array(array32: Float32Array): DOMMatrix; + static fromFloat64Array(array64: Float64Array): DOMMatrix; + static fromMatrix(other?: DOMMatrixInit): DOMMatrix; } -declare var DOMMatrix: { - prototype: DOMMatrix; - new(init?: string | number[]): DOMMatrix; - fromFloat32Array(array32: Float32Array): DOMMatrix; - fromFloat64Array(array64: Float64Array): DOMMatrix; - fromMatrix(other?: DOMMatrixInit): DOMMatrix; -}; - type SVGMatrix = DOMMatrix; declare var SVGMatrix: typeof DOMMatrix; type WebKitCSSMatrix = DOMMatrix; declare var WebKitCSSMatrix: typeof DOMMatrix; -interface DOMMatrixReadOnly { +declare class DOMMatrixReadOnly { + constructor(init?: string | number[]); readonly a: number; readonly b: number; readonly c: number; @@ -3905,102 +3536,72 @@ interface DOMMatrixReadOnly { transformPoint(point?: DOMPointInit): DOMPoint; translate(tx?: number, ty?: number, tz?: number): DOMMatrix; toString(): string; + static fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly; + static fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly; + static fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly; } -declare var DOMMatrixReadOnly: { - prototype: DOMMatrixReadOnly; - new(init?: string | number[]): DOMMatrixReadOnly; - fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly; - fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly; - fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly; - toString(): string; -}; - /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */ -interface DOMParser { +declare class DOMParser { + constructor(); parseFromString(str: string, type: SupportedType): Document; } -declare var DOMParser: { - prototype: DOMParser; - new(): DOMParser; -}; - -interface DOMPoint extends DOMPointReadOnly { +declare class DOMPoint extends DOMPointReadOnly { + constructor(x?: number, y?: number, z?: number, w?: number); w: number; x: number; y: number; z: number; + static fromPoint(other?: DOMPointInit): DOMPoint; } -declare var DOMPoint: { - prototype: DOMPoint; - new(x?: number, y?: number, z?: number, w?: number): DOMPoint; - fromPoint(other?: DOMPointInit): DOMPoint; -}; - type SVGPoint = DOMPoint; declare var SVGPoint: typeof DOMPoint; -interface DOMPointReadOnly { +declare class DOMPointReadOnly { + constructor(x?: number, y?: number, z?: number, w?: number); readonly w: number; readonly x: number; readonly y: number; readonly z: number; matrixTransform(matrix?: DOMMatrixInit): DOMPoint; toJSON(): any; + static fromPoint(other?: DOMPointInit): DOMPointReadOnly; } -declare var DOMPointReadOnly: { - prototype: DOMPointReadOnly; - new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly; - fromPoint(other?: DOMPointInit): DOMPointReadOnly; -}; - -interface DOMQuad { +declare class DOMQuad { + constructor(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit); readonly p1: DOMPoint; readonly p2: DOMPoint; readonly p3: DOMPoint; readonly p4: DOMPoint; getBounds(): DOMRect; toJSON(): any; + static fromQuad(other?: DOMQuadInit): DOMQuad; + static fromRect(other?: DOMRectInit): DOMQuad; } -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 { +declare class DOMRect extends DOMRectReadOnly { + constructor(x?: number, y?: number, width?: number, height?: number); height: number; width: number; x: number; y: number; + static fromRect(other?: DOMRectInit): DOMRect; } -declare var DOMRect: { - prototype: DOMRect; - new(x?: number, y?: number, width?: number, height?: number): DOMRect; - fromRect(other?: DOMRectInit): DOMRect; -}; - type SVGRect = DOMRect; declare var SVGRect: typeof DOMRect; -interface DOMRectList { +declare class DOMRectList { readonly length: number; item(index: number): DOMRect | null; [index: number]: DOMRect; } -declare var DOMRectList: { - prototype: DOMRectList; - new(): DOMRectList; -}; - -interface DOMRectReadOnly { +declare class DOMRectReadOnly { + constructor(x?: number, y?: number, width?: number, height?: number); readonly bottom: number; readonly height: number; readonly left: number; @@ -4010,25 +3611,15 @@ interface DOMRectReadOnly { readonly x: number; readonly y: number; toJSON(): any; + static fromRect(other?: DOMRectInit): DOMRectReadOnly; } -declare var DOMRectReadOnly: { - prototype: DOMRectReadOnly; - new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly; - fromRect(other?: DOMRectInit): DOMRectReadOnly; -}; - -interface DOMSettableTokenList extends DOMTokenList { +declare class DOMSettableTokenList extends DOMTokenList { value: string; } -declare var DOMSettableTokenList: { - prototype: DOMSettableTokenList; - new(): DOMSettableTokenList; -}; - /** A type returned by some APIs which contains a list of DOMString (strings). */ -interface DOMStringList { +declare class DOMStringList { /** * Returns the number of strings in strings. */ @@ -4044,23 +3635,13 @@ interface DOMStringList { [index: number]: string; } -declare var DOMStringList: { - prototype: DOMStringList; - new(): DOMStringList; -}; - /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */ -interface DOMStringMap { +declare class DOMStringMap { [name: string]: string | undefined; } -declare var DOMStringMap: { - prototype: DOMStringMap; - new(): DOMStringMap; -}; - /** A set of space-separated tokens. Such a set is returned by Element.classList, HTMLLinkElement.relList, HTMLAnchorElement.relList, HTMLAreaElement.relList, HTMLIframeElement.sandbox, or HTMLOutputElement.htmlFor. It is indexed beginning with 0 as with JavaScript Array objects. DOMTokenList is always case-sensitive. */ -interface DOMTokenList { +declare class DOMTokenList { /** * Returns the number of tokens. */ @@ -4126,12 +3707,7 @@ interface DOMTokenList { [index: number]: string; } -declare var DOMTokenList: { - prototype: DOMTokenList; - new(): DOMTokenList; -}; - -interface DataCue extends TextTrackCue { +declare class DataCue extends TextTrackCue { data: ArrayBuffer; addEventListener(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -4139,13 +3715,9 @@ interface DataCue extends TextTrackCue { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var DataCue: { - prototype: DataCue; - new(): DataCue; -}; - /** Used to hold the data that is being dragged during a drag and drop operation. It may hold one or more data items, each of one or more data types. For more information about drag and drop, see HTML Drag and Drop API. */ -interface DataTransfer { +declare class DataTransfer { + constructor(); /** * Returns the kind of operation that is currently selected. If the kind of operation isn't one of those that is allowed by the effectAllowed attribute, then the operation will fail. * @@ -4192,13 +3764,8 @@ interface DataTransfer { setDragImage(image: Element, x: number, y: number): void; } -declare var DataTransfer: { - prototype: DataTransfer; - new(): DataTransfer; -}; - /** One drag data item. During a drag operation, each drag event has a dataTransfer property which contains a list of drag data items. Each item in the list is a DataTransferItem object. */ -interface DataTransferItem { +declare class DataTransferItem { /** * Returns the drag data item kind, one of: "string", "file". */ @@ -4218,13 +3785,8 @@ interface DataTransferItem { webkitGetAsEntry(): any; } -declare var DataTransferItem: { - prototype: DataTransferItem; - new(): DataTransferItem; -}; - /** A list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a dataTransfer property and that property is a DataTransferItemList. */ -interface DataTransferItemList { +declare class DataTransferItemList { /** * Returns the number of items in the drag data store. */ @@ -4246,12 +3808,7 @@ interface DataTransferItemList { [name: number]: DataTransferItem; } -declare var DataTransferItemList: { - prototype: DataTransferItemList; - new(): DataTransferItemList; -}; - -interface DeferredPermissionRequest { +declare class DeferredPermissionRequest { readonly id: number; readonly type: MSWebViewPermissionType; readonly uri: string; @@ -4259,57 +3816,35 @@ interface DeferredPermissionRequest { deny(): void; } -declare var DeferredPermissionRequest: { - prototype: DeferredPermissionRequest; - new(): DeferredPermissionRequest; -}; - /** A delay-line; an AudioNode audio-processing module that causes a delay between the arrival of an input data and its propagation to the output. */ -interface DelayNode extends AudioNode { +declare class DelayNode extends AudioNode { + constructor(context: BaseAudioContext, options?: DelayOptions); readonly delayTime: AudioParam; } -declare var DelayNode: { - prototype: DelayNode; - new(context: BaseAudioContext, options?: DelayOptions): DelayNode; -}; - /** Provides information about the amount of acceleration the device is experiencing along all three axes. */ -interface DeviceAcceleration { +declare class DeviceAcceleration { readonly x: number | null; readonly y: number | null; readonly z: number | null; } -declare var DeviceAcceleration: { - prototype: DeviceAcceleration; - new(): DeviceAcceleration; -}; - /** The DeviceLightEvent provides web developers with information from photo sensors or similiar detectors about ambient light levels near the device. For example this may be useful to adjust the screen's brightness based on the current ambient light level in order to save energy or provide better readability. */ -interface DeviceLightEvent extends Event { +declare class DeviceLightEvent extends Event { + constructor(typeArg: string, eventInitDict?: DeviceLightEventInit); readonly value: number; } -declare var DeviceLightEvent: { - prototype: DeviceLightEvent; - new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent; -}; - /** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */ -interface DeviceMotionEvent extends Event { +declare class DeviceMotionEvent extends Event { + constructor(type: string, eventInitDict?: DeviceMotionEventInit); readonly acceleration: DeviceMotionEventAcceleration | null; readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null; readonly interval: number; readonly rotationRate: DeviceMotionEventRotationRate | null; + static requestPermission(): Promise; } -declare var DeviceMotionEvent: { - prototype: DeviceMotionEvent; - new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent; - requestPermission(): Promise; -}; - interface DeviceMotionEventAcceleration { readonly x: number | null; readonly y: number | null; @@ -4323,31 +3858,22 @@ interface DeviceMotionEventRotationRate { } /** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */ -interface DeviceOrientationEvent extends Event { +declare class DeviceOrientationEvent extends Event { + constructor(type: string, eventInitDict?: DeviceOrientationEventInit); readonly absolute: boolean; readonly alpha: number | null; readonly beta: number | null; readonly gamma: number | null; + static requestPermission(): Promise; } -declare var DeviceOrientationEvent: { - prototype: DeviceOrientationEvent; - new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent; - requestPermission(): Promise; -}; - /** Provides information about the rate at which the device is rotating around all three axes. */ -interface DeviceRotationRate { +declare class DeviceRotationRate { readonly alpha: number | null; readonly beta: number | null; readonly gamma: number | null; } -declare var DeviceRotationRate: { - prototype: DeviceRotationRate; - new(): DeviceRotationRate; -}; - interface DhImportKeyParams extends Algorithm { generator: Uint8Array; prime: Uint8Array; @@ -4377,7 +3903,9 @@ interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndEleme } /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */ -interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase { +interface Document extends DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {} +declare class Document extends Node { + constructor(); /** * Sets or gets the URL for the current document. */ @@ -4853,11 +4381,6 @@ interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShad removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var Document: { - prototype: Document; - new(): Document; -}; - interface DocumentAndElementEventHandlersEventMap { "copy": ClipboardEvent; "cut": ClipboardEvent; @@ -4956,16 +4479,13 @@ interface DocumentEvent { } /** A minimal document object that has no parent. It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document. The key difference is that because the document fragment isn't part of the active document tree structure, changes made to the fragment don't affect the document, cause reflow, or incur any performance impact that can occur when changes are made. */ -interface DocumentFragment extends Node, NonElementParentNode, ParentNode { +interface DocumentFragment extends NonElementParentNode, ParentNode {} +declare class DocumentFragment extends Node { + constructor(); readonly ownerDocument: Document; getElementById(elementId: string): HTMLElement | null; } -declare var DocumentFragment: { - prototype: DocumentFragment; - new(): DocumentFragment; -}; - interface DocumentOrShadowRoot { readonly activeElement: Element | null; /** @@ -4985,42 +4505,31 @@ interface DocumentOrShadowRoot { getSelection(): Selection | null; } -interface DocumentTimeline extends AnimationTimeline { +declare class DocumentTimeline extends AnimationTimeline { + constructor(options?: DocumentTimelineOptions); } -declare var DocumentTimeline: { - prototype: DocumentTimeline; - new(options?: DocumentTimelineOptions): DocumentTimeline; -}; - /** A Node containing a doctype. */ -interface DocumentType extends Node, ChildNode { +interface DocumentType extends ChildNode {} +declare class DocumentType extends Node { readonly name: string; readonly ownerDocument: Document; readonly publicId: string; readonly systemId: string; } -declare var DocumentType: { - prototype: DocumentType; - new(): DocumentType; -}; - /** A DOM event that represents a drag and drop interaction. The user initiates a drag by placing a pointer device (such as a mouse) on the touch surface and then dragging the pointer to a new location (such as another DOM element). Applications are free to interpret a drag and drop interaction in an application-specific way. */ -interface DragEvent extends MouseEvent { +declare class DragEvent extends MouseEvent { + constructor(type: string, eventInitDict?: DragEventInit); /** * Returns the DataTransfer object for the event. */ readonly dataTransfer: DataTransfer | null; } -declare var DragEvent: { - prototype: DragEvent; - new(type: string, eventInitDict?: DragEventInit): DragEvent; -}; - /** Inherits properties from its parent, AudioNode. */ -interface DynamicsCompressorNode extends AudioNode { +declare class DynamicsCompressorNode extends AudioNode { + constructor(context: BaseAudioContext, options?: DynamicsCompressorOptions); readonly attack: AudioParam; readonly knee: AudioParam; readonly ratio: AudioParam; @@ -5029,11 +4538,6 @@ interface DynamicsCompressorNode extends AudioNode { readonly threshold: AudioParam; } -declare var DynamicsCompressorNode: { - prototype: DynamicsCompressorNode; - new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode; -}; - interface EXT_blend_minmax { readonly MAX_EXT: GLenum; readonly MIN_EXT: GLenum; @@ -5065,7 +4569,8 @@ interface ElementEventMap { } /** Element is the most general base class from which all objects in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from Element. */ -interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slotable { +interface Element extends Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slotable {} +declare class Element extends Node { readonly assignedSlot: HTMLSlotElement | null; readonly attributes: NamedNodeMap; /** @@ -5221,11 +4726,6 @@ interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTyp removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var Element: { - prototype: Element; - new(): Element; -}; - interface ElementCSSInlineStyle { readonly style: CSSStyleDeclaration; } @@ -5238,7 +4738,8 @@ interface ElementContentEditable { } /** Events providing information related to errors in scripts or in files. */ -interface ErrorEvent extends Event { +declare class ErrorEvent extends Event { + constructor(type: string, eventInitDict?: ErrorEventInit); readonly colno: number; readonly error: any; readonly filename: string; @@ -5246,13 +4747,9 @@ interface ErrorEvent extends Event { readonly message: string; } -declare var ErrorEvent: { - prototype: ErrorEvent; - new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent; -}; - /** An event which takes place in the DOM. */ -interface Event { +declare class Event { + constructor(type: string, eventInitDict?: EventInit); /** * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise. */ @@ -5318,17 +4815,12 @@ interface Event { readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number; readonly NONE: number; + static readonly AT_TARGET: number; + static readonly BUBBLING_PHASE: number; + static readonly CAPTURING_PHASE: number; + static readonly NONE: number; } -declare var Event: { - prototype: Event; - new(type: string, eventInitDict?: EventInit): Event; - readonly AT_TARGET: number; - readonly BUBBLING_PHASE: number; - readonly CAPTURING_PHASE: number; - readonly NONE: number; -}; - interface EventListenerObject { handleEvent(evt: Event): void; } @@ -5339,7 +4831,8 @@ interface EventSourceEventMap { "open": Event; } -interface EventSource extends EventTarget { +declare class EventSource extends EventTarget { + constructor(url: string, eventSourceInitDict?: EventSourceInit); onerror: ((this: EventSource, ev: Event) => any) | null; onmessage: ((this: EventSource, ev: MessageEvent) => any) | null; onopen: ((this: EventSource, ev: Event) => any) | null; @@ -5366,18 +4859,14 @@ interface EventSource extends EventTarget { addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; removeEventListener(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void; removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; + static readonly CLOSED: number; + static readonly CONNECTING: number; + static readonly OPEN: number; } -declare var EventSource: { - prototype: EventSource; - new(url: string, eventSourceInitDict?: EventSourceInit): EventSource; - readonly CLOSED: number; - readonly CONNECTING: number; - readonly OPEN: number; -}; - /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */ -interface EventTarget { +declare class EventTarget { + constructor(); /** * 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. * @@ -5402,12 +4891,7 @@ interface EventTarget { removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void; } -declare var EventTarget: { - prototype: EventTarget; - new(): EventTarget; -}; - -interface ExtensionScriptApis { +declare class ExtensionScriptApis { extensionIdToShortId(extensionId: string): number; fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void; genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void; @@ -5419,46 +4903,27 @@ interface ExtensionScriptApis { registerWebRuntimeCallbackHandler(handler: Function): any; } -declare var ExtensionScriptApis: { - prototype: ExtensionScriptApis; - new(): ExtensionScriptApis; -}; - -interface External { +declare class External { /** @deprecated */ AddSearchProvider(): void; /** @deprecated */ IsSearchProviderInstalled(): void; } -declare var External: { - prototype: External; - new(): External; -}; - /** Provides information about files and allows JavaScript in a web page to access their content. */ -interface File extends Blob { +declare class File extends Blob { + constructor(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag); readonly lastModified: number; readonly name: string; } -declare var File: { - prototype: File; - new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File; -}; - /** An object of this type is returned by the files property of the HTML element; this lets you access the list of files selected with the element. It's also used for a list of files dropped into web content when using the drag and drop API; see the DataTransfer object for details on this usage. */ -interface FileList { +declare class FileList { readonly length: number; item(index: number): File | null; [index: number]: File; } -declare var FileList: { - prototype: FileList; - new(): FileList; -}; - interface FileReaderEventMap { "abort": ProgressEvent; "error": ProgressEvent; @@ -5469,7 +4934,8 @@ interface FileReaderEventMap { } /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */ -interface FileReader extends EventTarget { +declare class FileReader extends EventTarget { + constructor(); readonly error: DOMException | null; onabort: ((this: FileReader, ev: ProgressEvent) => any) | null; onerror: ((this: FileReader, ev: ProgressEvent) => any) | null; @@ -5491,27 +4957,19 @@ interface FileReader extends EventTarget { addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; removeEventListener(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void; removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; + static readonly DONE: number; + static readonly EMPTY: number; + static readonly LOADING: number; } -declare var FileReader: { - prototype: FileReader; - new(): FileReader; - readonly DONE: number; - readonly EMPTY: number; - readonly LOADING: number; -}; - /** Focus-related events like focus, blur, focusin, or focusout. */ -interface FocusEvent extends UIEvent { +declare class FocusEvent extends UIEvent { + constructor(type: string, eventInitDict?: FocusEventInit); readonly relatedTarget: EventTarget | null; } -declare var FocusEvent: { - prototype: FocusEvent; - new(type: string, eventInitDict?: FocusEventInit): FocusEvent; -}; - -interface FocusNavigationEvent extends Event { +declare class FocusNavigationEvent extends Event { + constructor(type: string, eventInitDict?: FocusNavigationEventInit); readonly navigationReason: NavigationReason; readonly originHeight: number; readonly originLeft: number; @@ -5520,13 +4978,9 @@ interface FocusNavigationEvent extends Event { requestFocus(): void; } -declare var FocusNavigationEvent: { - prototype: FocusNavigationEvent; - new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent; -}; - /** 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 { +declare class FormData { + constructor(form?: HTMLFormElement); append(name: string, value: string | Blob, fileName?: string): void; delete(name: string): void; get(name: string): FormDataEntryValue | null; @@ -5536,23 +4990,14 @@ interface FormData { forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void; } -declare var FormData: { - prototype: FormData; - new(form?: HTMLFormElement): FormData; -}; - /** A change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels. */ -interface GainNode extends AudioNode { +declare class GainNode extends AudioNode { + constructor(context: BaseAudioContext, options?: GainOptions); readonly gain: AudioParam; } -declare var GainNode: { - prototype: GainNode; - new(context: BaseAudioContext, options?: GainOptions): GainNode; -}; - /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */ -interface Gamepad { +declare class Gamepad { readonly axes: ReadonlyArray; readonly buttons: ReadonlyArray; readonly connected: boolean; @@ -5565,46 +5010,27 @@ interface Gamepad { readonly timestamp: number; } -declare var Gamepad: { - prototype: Gamepad; - new(): Gamepad; -}; - /** An individual button of a gamepad or other controller, allowing access to the current state of different types of buttons available on the control device. */ -interface GamepadButton { +declare class GamepadButton { readonly pressed: boolean; readonly touched: boolean; readonly value: number; } -declare var GamepadButton: { - prototype: GamepadButton; - new(): GamepadButton; -}; - /** This Gamepad API interface contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected and Window.gamepaddisconnected are fired in response to. */ -interface GamepadEvent extends Event { +declare class GamepadEvent extends Event { + constructor(type: string, eventInitDict: GamepadEventInit); readonly gamepad: Gamepad; } -declare var GamepadEvent: { - prototype: GamepadEvent; - new(type: string, eventInitDict: GamepadEventInit): GamepadEvent; -}; - /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */ -interface GamepadHapticActuator { +declare class GamepadHapticActuator { readonly type: GamepadHapticActuatorType; pulse(value: number, duration: number): Promise; } -declare var GamepadHapticActuator: { - prototype: GamepadHapticActuator; - new(): GamepadHapticActuator; -}; - /** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */ -interface GamepadPose { +declare class GamepadPose { readonly angularAcceleration: Float32Array | null; readonly angularVelocity: Float32Array | null; readonly hasOrientation: boolean; @@ -5615,11 +5041,6 @@ interface GamepadPose { readonly position: Float32Array | null; } -declare var GamepadPose: { - prototype: GamepadPose; - new(): GamepadPose; -}; - interface GenericTransformStream { /** * Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable. @@ -6011,7 +5432,7 @@ interface GlobalEventHandlers { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -interface HTMLAllCollection { +declare class HTMLAllCollection { /** * Returns the number of elements in the collection. */ @@ -6031,13 +5452,10 @@ interface HTMLAllCollection { [index: number]: Element; } -declare var HTMLAllCollection: { - prototype: HTMLAllCollection; - new(): HTMLAllCollection; -}; - /** Hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface that they inherit from) for manipulating the layout and presentation of such elements. */ -interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils { +interface HTMLAnchorElement extends HTMLHyperlinkElementUtils {} +declare class HTMLAnchorElement extends HTMLElement { + constructor(); /** * Sets or retrieves the character set used to encode the object. */ @@ -6090,12 +5508,7 @@ interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var HTMLAnchorElement: { - prototype: HTMLAnchorElement; - new(): HTMLAnchorElement; -}; - -interface HTMLAppletElement extends HTMLElement { +declare class HTMLAppletElement extends HTMLElement { /** @deprecated */ align: string; /** @@ -6140,13 +5553,10 @@ interface HTMLAppletElement extends HTMLElement { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var HTMLAppletElement: { - prototype: HTMLAppletElement; - new(): HTMLAppletElement; -}; - /** Provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of elements. */ -interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils { +interface HTMLAreaElement extends HTMLHyperlinkElementUtils {} +declare class HTMLAreaElement extends HTMLElement { + constructor(); /** * Sets or retrieves a text alternative to the graphic. */ @@ -6179,26 +5589,18 @@ interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils { removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } -declare var HTMLAreaElement: { - prototype: HTMLAreaElement; - new(): HTMLAreaElement; -}; - /** Provides access to the properties of