Operator that helps emulate an EventEmitter with EVT See https://stackblitz.com/edit/evt-honvv3?file=index.ts or https://docs.evt.land/extending_evt

https://docs.evt.land/api/ctx

Minimal interface that an object must implement to be a valid context argument ( for interop between mismatching EVT versions )

A controller object that allows you to abort one or more DOM requests as and when desired.

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.

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.

The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type.

Events providing information related to animations.

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.

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.

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.

An audio-processing graph built from audio modules linked together, each represented by an AudioNode.

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.

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.

A generic interface for representing an audio processing module. Examples include:

The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain).

The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed.

A single audio track from one of the HTML media elements, or .

Used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list.

The beforeunload event is fired when the window, the document and its resources are about to be unloaded.

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.

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.

This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.

Provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec.

The storage for Cache objects.

An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient().

An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method.

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.

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.

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.

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.

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.

Events providing information related to modification of the clipboard, that is cut, copy, and paste events.

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.

Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.

The DOM CompositionEvent represents events that occur due to the user indirectly entering text.

Provides access to the browser's debugging console (e.g. the Web Console in Firefox). The specifics of how it works varies from browser to browser, but there is a de facto set of features that are typically provided.

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.

The position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated.

This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.

Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.

The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.

The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm.

Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface.

A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule.

Any CSS at-rule that contains other rules nested within it.

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

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

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

An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE).

CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE).

A single CSS rule. There are several types of rules, listed in the Type constants section below.

A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects.

An object that is a CSS declaration block, and exposes style information and various style-related methods and properties.

CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE).

A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet.

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

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.

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.

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.

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.

Provides information about the amount of acceleration the device is experiencing along all three axes.

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.

The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation.

The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page.

Provides information about the rate at which the device is rotating around all three axes.

Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.

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.

A Node containing a doctype.

An error object that contains an error name.

An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API.

An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property.

Provides the ability to parse XML or HTML source code from a string into a DOM Document.

A type returned by some APIs which contains a list of DOMString (strings).

Used by the dataset HTML attribute to represent data for custom attributes added to elements.

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.

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.

Inherits properties from its parent, AudioNode.

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.

Events providing information related to errors in scripts or in files.

An event which takes place in the DOM.

EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them.

The EXT_frag_depth extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader.

The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF).

Provides information about files and allows JavaScript in a web page to access their content.

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.

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.

Focus-related events like focus, blur, focusin, or focusout.

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

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.

This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id.

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.

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.

This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware.

This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.)

An object able to programmatically obtain the position of the device. It gives Web content access to the location of the device. This allows a Web site or app to offer customized results based on the user's location.

Events that fire when the fragment identifier of the URL has changed.

This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.

Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in.

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.

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.

Provides access to the properties of elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface.

Contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface.

Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating elements.

A HTML line break element (). It inherits from HTMLElement.

Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Provides properties and methods for manipulating the layout and presentation of elements. The HTMLCanvasElement interface also inherits the properties and methods of the HTMLElement interface.

A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list.

Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate elements and their content.

Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list () elements.

The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object.

Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it.

Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of elements.

Implements the document object model (DOM) representation of the font element. The HTML Font Element defines the font size, font face and color of text.

A collection of HTML form control elements.

A element in the DOM; it allows access to and in some cases modification of aspects of the form, as well as access to its component elements.

Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating elements.

Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface.

The different heading elements. It inherits methods and properties from the HTMLElement interface.

Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface.

Provides special properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of inline frame elements.

Provides special properties and methods for manipulating elements.

Provides special properties and methods for manipulating the options, layout, and presentation of elements.

Gives access to properties specific to elements. It inherits methods and properties from the base HTMLElement interface.

The HTMLLegendElement is an interface allowing to access properties of the elements. It inherits properties and methods from the HTMLElement interface.

Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements.

Reference information for external resources and the relationship of those resources to a document and vice-versa. This object inherits all of the properties and methods of the HTMLElement interface.

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 map elements.

Provides methods to manipulate elements.

Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video.

Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface.

The HTML elements expose the HTMLMeterElement interface, which provides special properties and methods (beyond the HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of elements.

Provides special properties (beyond the regular methods and properties available through the HTMLElement interface they also have available to them by inheritance) for manipulating modification elements, that is and .

Provides special properties and methods (beyond those on the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of element, representing external resources.

Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements.

Provides special properties and methods (beyond the regular HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of elements.

HTMLOptionsCollection is an interface representing a collection of HTML option elements (in document order) and offers methods and properties for traversing the list as well as optionally altering its items. This type is returned solely by the "options" property of select.

Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of elements.

Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating elements.

Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating elements, representing a pair of a key and a value that acts as a parameter for an element.

A HTML element. It doesn't implement specific properties or methods.

Exposes specific properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating a block of preformatted text ().

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of elements.

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like and , but not the element.

HTML elements expose the HTMLScriptElement interface, which provides special properties and methods for manipulating the behavior and execution of elements (beyond the inherited HTMLElement interface).

A HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface.

Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating elements.

A element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

A element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle.

Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements.

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header or data cells, in an HTML document.

Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements.

Provides special properties and methods (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document.

Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of rows in an HTML table.

Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies, in an HTML table.

Enables access to the contents of an HTML element.

Provides special properties and methods for manipulating the layout and presentation of elements.

Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface.

The HTMLTrackElement

Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements.

An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement.

This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database.

This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property.

This IndexedDB API interface provides a connection to a database; you can use an IDBDatabase object to open a transaction on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database.

In the following code snippet, we make a request to open a database, and include handlers for the success and error cases. For a full working example, see our To-do Notifications app (view example live.)

IDBIndex interface of the IndexedDB API provides asynchronous access to an index in a database. An index is a kind of object store for looking up records in another object store, called the referenced object store. You use this interface to retrieve data.

A key range can be a single value or a range with upper and lower bounds or endpoints. If the key range has both upper and lower bounds, then it is bounded; if it has no bounds, it is unbounded. A bounded key range can either be open (the endpoints are excluded) or closed (the endpoints are included). To retrieve all keys within a certain range, you can use the following code constructs:

This example shows a variety of different uses of object stores, from updating the data structure with IDBObjectStore.createIndex inside an onupgradeneeded function, to adding a new item to our object store with IDBObjectStore.add. For a full working example, see our To-do Notifications app (view example live.)

Also inherits methods from its parents IDBRequest and EventTarget.

The request object does not initially contain any information about the result of the operation, but once information becomes available, an event is fired on the request, and the information becomes available through the properties of the IDBRequest instance.

This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function.

The IIRFilterNode interface of the Web Audio API is a AudioNode processor which implements a general infinite impulse response (IIR)  filter; this type of filter can be used to implement tone control devices and graphic equalizers as well. It lets the parameters of the filter response be specified, so that it can be tuned as needed.

The underlying pixel data of an area of a element. It is created using the ImageData() constructor or creator methods on the CanvasRenderingContext2D object associated with a canvas: createImageData() and getImageData(). It can also be used to set a part of the canvas by using putImageData().

provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or with a top-level document's viewport.

This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition.

KeyboardEvent objects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard.

The location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linked Location, accessible via Document.location and Window.location respectively.

The MediaDevicesInfo interface contains information that describes a single media input or output device.

Provides access to connected media input devices like cameras and microphones, as well as screen sharing. In essence, it lets you obtain access to any hardware source of media data.

A MediaElementSourceNode has no inputs and exactly one output, and is created using the AudioContext.createMediaElementSource method. The amount of channels in the output equals the number of channels of the audio referenced by the HTMLMediaElement used in the creation of the node, or is 1 if the HTMLMediaElement has no audio.

An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as or .

This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session.

This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback.

This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM).

This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs.

This EncryptedMediaExtensions API interface provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the Navigator.requestMediaKeySystemAccess method.

Stores information on a media query applied to a document, and handles sending notifications to listeners when the media query state change (i.e. when the media query test starts or stops evaluating to true).

This Media Source Extensions API interface represents a source of media data for an HTMLMediaElement object. A MediaSource object can be attached to a HTMLMediaElement to be played in the user agent.

A stream of media content. A stream consists of several tracks such as video or audio tracks. Each track is specified as an instance of MediaStreamTrack.

A type of AudioNode which operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs.

Events that occurs in relation to a MediaStream. Two events of this type can be thrown: addstream and removestream.

A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well.

Events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Stream API methods. These events are sent to the stream when these changes occur.

This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties.

A message received by a target object.

This Channel Messaging API interface represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other.

Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object.

Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes.

Events that occur due to the user interacting with a pointing device (such as a mouse). Common events using this interface include click, dblclick, mouseup, mousedown.

The MSGestureEvent is a proprietary interface specific to Internet Explorer and Microsoft Edge which represents events that occur due to touch gestures. Events using this interface include MSGestureStart, MSGestureEnd, MSGestureTap, MSGestureHold, MSGestureChange, and MSInertiaStart.

The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback.

Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes.

Provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature which was part of the DOM3 Events specification.

A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback.

A collection of Attr objects. Objects inside a NamedNodeMap are not in any particular order, unlike NodeList, although they may be accessed by an index as in an array.

The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities.

Node is an interface from which a number of DOM API object types inherit. It allows those types to be treated similarly; for example, inheriting the same set of methods, or being tested in the same way.

An object used to filter the nodes in a NodeIterator or TreeWalker. They don't know anything about the DOM or how to traverse nodes; they just know how to evaluate a single node against the provided filter.

An iterator over the members of a list of the nodes in a subtree of the DOM. The nodes will be returned in document order.

NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll().

This Notifications API interface is used to configure and display desktop notifications to the user.

The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements().

The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth.

The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures.

The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures.

The OES_texture_half_float extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components.

The OES_texture_half_float_linear extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures.

The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface.

An AudioContext interface representing an audio-processing graph built from linked together AudioNodes. In contrast with a standard AudioContext, an OfflineAudioContext doesn't render the audio to the device hardware; instead, it generates it, as fast as it can, and outputs the result to an AudioBuffer.

The OscillatorNode interface represents a periodic waveform, such as a sine wave. It is an AudioScheduledSourceNode audio-processing module that causes a specified frequency of a given wave to be created—in effect, a constant tone.

The PageTransitionEvent is fired when a document is being loaded or unloaded.

A PannerNode always has exactly one input and one output: the input can be mono or stereo but the output is always stereo (2 channels); you can't have panning effects without at least two audio channels!

This Canvas 2D API interface is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of the CanvasRenderingContext2D interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired.

This Payment Request API interface is used to store shipping or payment address information.

This Payment Request API interface is the primary access point into the API, and lets web content and apps accept payments from the end user.

This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action.

This Payment Request API interface is returned after a user selects a payment method and approves a payment request.

Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API.

Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the mark() method) at an explicit point in an application. Performance entries are also created in indirect ways such as loading a resource (such as an image).

PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline.

PerformanceMeasure is an abstract interface for PerformanceEntry objects with an entryType of "measure". Entries of this type are created by calling performance.measure() to add a named DOMHighResTimeStamp (the measure) between two marks to the browser's performance timeline.

The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done.

Provides methods and properties to store and retrieve metrics regarding the browser's document navigation events. For example, this interface can be used to determine how much time it takes to load or unload a document.

Enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources. An application can use the timing metrics to determine, for example, the length of time it takes to fetch a specific resource, such as an XMLHttpRequest, , image, or script.

A legacy interface kept for backwards compatibility and contains properties that offer performance timing information for various events which occur during the loading and use of the current page. You get a PerformanceTiming object describing your page using the window.performance.timing property.

PeriodicWave has no inputs or outputs; it is used to define custom oscillators when calling OscillatorNode.setPeriodicWave(). The PeriodicWave itself is created/returned by AudioContext.createPeriodicWave().

Provides information about a browser plugin.

Used to store a list of Plugin objects describing the available plugins; it's returned by the window.navigator.plugins property. The PluginArray is not a JavaScript array, but has the length property and supports accessing individual items using bracket notation (plugins[2]), as well as via item(index) and namedItem("name") methods.

The state of a DOM event produced by a pointer such as the geometry of the contact point, the device type that generated the event, the amount of pressure that was applied on the contact surface, etc.

PopStateEvent is an event handler for the popstate event on the window.

The position of the concerned device at a given time. The position, represented by a Coordinates object, comprehends the 2D position of the device, on a spheroid representing the Earth, but also its altitude and its speed.

The reason of an error occurring when using the geolocating device.

A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them.

Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an , , , or ).

This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications.

This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service.

A fragment of a document that can contain nodes and parts of text nodes.

This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object.

This Fetch API interface represents a resource request.

This Fetch API interface represents the response to a request.

Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event.

The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection.

Provides access to information about the ICE transport layer over which the data is being sent and received.

A WebRTC connection between the local computer and a remote peer. It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed.

Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate.

This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection.

Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer.

One end of a connection—or potential connection—and how it's configured. Each RTCSessionDescription consists of a description type indicating which part of the offer/answer negotiation process it describes and of the SDP descriptor of the session.

A screen, usually the one on which the current window is being rendered, and is obtained using window.screen.

Allows the generation, processing, or analyzing of audio using JavaScript.

Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated.

A Selection object represents the range of text selected by the user or the current position of the caret. To obtain a Selection object for examination or modification, call Window.getSelection().

This ServiceWorker API interface provides a reference to a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same service worker, each through a unique ServiceWorker object.

The ServiceWorkerContainer interface of the ServiceWorker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.

This ServiceWorker API interface contains information about an event sent to a ServiceWorkerContainer target. This extends the default message event to allow setting a ServiceWorker object as the source of a message. The event object is accessed via the handler function of a message event, when fired by a message received from a service worker.

This ServiceWorker API interface represents the service worker registration. You register a service worker to control one or more pages that share the same origin.

A chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object. This can be made up of one or several media segments.

A simple container list for multiple SourceBuffer objects.

This Web Speech API interface is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides.

This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service.

This Web Speech API interface represents a speech request. It contains the content the speech service should read and information about how to read it (e.g. language, pitch and volume.)

This Web Speech API interface represents a voice that the system supports. Every SpeechSynthesisVoice has its own relative speech service including information about language, name and URI.

The pan property takes a unitless value between -1 (full left pan) and 1 (full right pan). This interface was introduced as a much simpler way to apply a simple panning effect than having to use a full PannerNode.

This Web Storage API interface provides access to a particular domain's session or local storage. It allows, for example, the addition, modification, or deletion of stored data items.

A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document.

A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface.

A list of StyleSheet.

This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto).

Provides access to the properties of element, as well as methods to manipulate them.

Used to represent a value that can be an or value. An SVGAngle reflected through the animVal attribute is always read only.

Used for attributes of basic type which can be animated.

Used for attributes of type boolean which can be animated.

Used for attributes whose value must be a constant from a particular enumeration and which can be animated.

Used for attributes of basic type which can be animated.

Used for attributes of basic type which can be animated.

Used for attributes of type SVGLengthList which can be animated.

Used for attributes of basic type which can be animated.

The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated.

Used for attributes of type SVGPreserveAspectRatio which can be animated.

Used for attributes of basic SVGRect which can be animated.

The SVGAnimatedString interface represents string attributes which can be animated from each SVG declaration. You need to create SVG attribute before doing anything else, everything should be declared inside this.

Used for attributes which take a list of numbers and which can be animated.

An interface for the element. The circle element is defined by the cx and cy attributes that denote the coordinates of the centre of the circle.

Provides access to the properties of elements, as well as methods to manipulate them.

A base interface used by the component transfer function interfaces.

Corresponds to the element.

Corresponds to the element.

All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface.

Provides access to the properties of elements.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Corresponds to the element.

Provides access to the properties of elements, as well as methods to manipulate them.

Provides access to the properties of elements, as well as methods to manipulate them.

Corresponds to the element.

The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement.

SVG elements whose primary purpose is to directly render graphics into a group.

Corresponds to the element.

Correspond to the basic data type.

The SVGLengthList defines a list of SVGLength objects.

Corresponds to the element.

Provides access to the properties of elements, as well as methods to manipulate them.

Provides access to the properties of elements, as well as methods to manipulate them.

Corresponds to the element.

Corresponds to the basic data type.

The SVGNumberList defines a list of SVGNumber objects.

Corresponds to the element.

Corresponds to the element.

Provides access to the properties of elements, as well as methods to manipulate them.

Provides access to the properties of elements, as well as methods to manipulate them.

Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements.

Corresponds to the element.

Provides access to the properties of elements, as well as methods to manipulate them.

Corresponds to the SVG element.

Corresponds to the element.

The SVGStringList defines a list of DOMString objects.

Corresponds to the SVG element.

Provides access to the properties of elements, as well as methods to manipulate them. This interface contains also various miscellaneous commonly-used utility methods, such as matrix operations and the ability to control the time of redraw on visual rendering devices.

Corresponds to the element.

Corresponds to the element.

Implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, SVGTRefElement, SVGAltGlyphElement and SVGTextPathElement.

Corresponds to the elements.

Corresponds to the element.

Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement.

Corresponds to the element.

SVGTransform is the interface for one of the component transformations within an SVGTransformList; thus, an SVGTransform object corresponds to a single component (e.g., scale(…) or matrix(…)) within a transform attribute.

The SVGTransformList defines a list of SVGTransform objects.

A element.

A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes.

Corresponds to the element.

Provides access to the properties of elements, as well as methods to manipulate them.

Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute.

This ServiceWorker API interface provides an interface for registering and listing sync registrations.

The textual content of Element or Attr. If an element has no markup within its content, it has a single child implementing Text that contains the element's text. However, if the element contains markup, it is parsed into information items and Text nodes that form its children.

A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc. A decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays.

TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays.

The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method.

This interface also inherits properties from EventTarget.

TextTrackCues represent a string of text that will be displayed for some duration of time on a TextTrack. This includes the start and end times that the cue will be displayed. A TextTrackCue cannot be used directly, instead one of the derived types (e.g. VTTCue) must be used.

Used to represent a set of time ranges, primarily for the purpose of tracking which portions of media have been buffered when loading it for use by the and  elements.

A single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad.

An event sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth.

A list of contact points on a touch surface. For example, if the user has three fingers on the touch surface (such as a screen or trackpad), the corresponding TouchList object would have one Touch object for each finger, for a total of three entries.

The TrackEvent interface, part of the HTML DOM specification, is used for events which represent changes to the set of available tracks on an HTML media element; these events are addtrack and removetrack.

Events providing information related to transitions.

The nodes of a document subtree and a position within them.

Simple user interface events.

The URL interface represents an object providing static methods used for creating object URLs.

The validity states that an element can be in, with respect to constraint validation. Together, they help explain why an element's value fails to validate, if it's not valid.

Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video.

A single video track from a element.

Used to represent a list of the video tracks contained within a element, with each track represented by a separate VideoTrack object in the list.

This WebVR API interface represents any VR device supported by this API. It includes generic information such as device IDs and descriptions, as well as methods for starting to present a VR scene, retrieving eye parameters and display capabilities, and other important functionality.

This WebVR API interface describes the capabilities of a VRDisplay — its features can be used to perform VR device capability tests, for example can it return position information.

This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions).

This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information.

This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point.

This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData().

This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.)

A WaveShaperNode always has exactly one input and one output.

The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats.

The WEBGL_debug_renderer_info extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes.

The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures.

Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods.

Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.

The WebContextEvent interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context.

Part of the WebGL API and represents a collection of buffers that serve as a rendering destination.

The WebGLProgram is part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL).

Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation.

Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML element.

The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders.

Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method.

Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.

Part of the WebGL API and represents the location of a uniform variable in a shader program.

Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.

Events that occur due to the user moving a mouse wheel or similar input device.

A window containing a DOM document; the document property points to the DOM document loaded in that window.

This Web Workers API interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread.

This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing.

This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate.

This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink.

An XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents.

Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.

Provides the serializeToString() method to construct an XML string representing a DOM tree.

The XPathEvaluator interface allows to compile and evaluate XPath expressions.

This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree.

The results generated by evaluating an XPath expression within the context of a given node.

An XSLTProcessor applies an XSLT stylesheet transformation to an XML document to produce a new XML document as output. It has methods to load the XSLT stylesheet, to manipulate xsl:param parameter values, and to apply the transformation to documents.