Module <internal>

The AbstractRange abstract interface is the base class upon which all DOM range types are defined.

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

The Animation interface of the Web Animations API represents a single animation player and provides playback controls and a timeline for an animation node or source.

The AnimationEffect interface of the Web Animations API is an interface representing animation effects.

The AnimationEvent interface represents events providing information related to animations.

The AnimationPlaybackEvent interface of the Web Animations API represents animation events.

The AnimationTimeline interface of the Web Animations API represents the timeline of an animation.

The Attr interface represents one of an element's attributes as an object.

The AudioBuffer interface represents a short audio asset residing in memory, created from an audio file using the BaseAudioContext/decodeAudioData method, or from raw data using BaseAudioContext/createBuffer.

The AudioData interface of the WebCodecs API represents an audio sample.

The AudioProcessingEvent interface of the Web Audio API represents events that occur when a ScriptProcessorNode input buffer is ready to be processed.

The BarProp interface of the Document Object Model represents the web browser user interface elements that are exposed to scripts in web pages.

The BeforeUnloadEvent interface represents the event object for the Window/beforeunload_event event, which is fired when the current window, contained document, and associated resources are about to be unloaded.

The BlobEvent interface of the MediaStream Recording API represents events associated with a Blob.

The CacheStorage interface represents the storage for Cache objects. Available only in secure contexts.

The CanvasGradient interface represents an opaque object describing a gradient.

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

The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a canvas element.

The CaretPosition interface represents the caret position, an indicator for the text insertion point.

The CDATASection interface represents a CDATA section that can be used within XML to include extended portions of unescaped text.

The CharacterData abstract interface represents a Node object that contains characters.

The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus letting those object types to be used similarly and often interchangeably.

The ClipboardEvent interface of the Clipboard API represents events providing information related to modification of the clipboard, that is Element/cut_event, Element/copy_event, and Element/paste_event events.

The Comment interface represents 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.

The ContentVisibilityAutoStateChangeEvent interface is the event object for the element/contentvisibilityautostatechange_event event, which fires on any element with content-visibility set on it when it starts or stops being relevant to the user and skipping its contents.

The CookieChangeEvent interface of the Cookie Store API is the event type of the CookieStore/change_event event fired at a CookieStore when any cookies are created or deleted. Available only in secure contexts.

The CookieStore interface of the Cookie Store API provides methods for getting and setting cookies asynchronously from either a page or a service worker. Available only in secure contexts.

The CSSMathSum interface of the CSS Typed Object Model API represents the result obtained by calling CSSNumericValue.add, CSSNumericValue.sub, or CSSNumericValue.toSum on CSSNumericValue.

The CSSMathValue interface of the CSS Typed Object Model API a base class for classes representing complex numeric values.

The CSSNumericValue interface of the CSS Typed Object Model API represents operations that all numeric values can perform.

The CSSRule interface represents a single CSS rule.

The CSSStyleSheet interface represents a single CSS stylesheet, and lets you inspect and modify the list of rules contained in the stylesheet.

The CSSStyleValue interface of the CSS Typed Object Model API is the base class of all CSS values accessible through the Typed OM API.

The CSSUnitValue interface of the CSS Typed Object Model API represents values that contain a single unit type.

The CustomElementRegistry interface provides methods for registering custom elements and querying registered elements.

The DataTransfer object is used to hold any data transferred between contexts, such as a drag and drop operation, or clipboard read/write.

The DeviceMotionEvent interface of the Device Orientation Events provides web developers with information about the speed of changes for the device's position and orientation. Available only in secure contexts.

The DeviceMotionEventAcceleration interface of the Device Orientation Events provides information about the amount of acceleration the device is experiencing along all three axes. Available only in secure contexts.

A DeviceMotionEventRotationRate interface of the Device Orientation Events provides information about the rate at which the device is rotating around all three axes. Available only in secure contexts.

The DeviceOrientationEvent interface of the Device Orientation Events provides web developers with information from the physical orientation of the device running the web page. Available only in secure contexts.

The Document interface represents any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.

The DocumentFragment interface represents a minimal document object that has no parent.

The DocumentTimeline interface of the Web Animations API represents animation timelines, including the default document timeline (accessed via Document.timeline).

The DocumentType interface represents a Node containing a doctype.

The DOMImplementation interface represents an object providing methods which are not dependent on any particular document.

The DOMMatrix interface represents 4×4 matrices, suitable for 2D and 3D operations including rotation and translation.

The DOMMatrixReadOnly interface represents a read-only 4×4 matrix, suitable for 2D and 3D operations.

A DOMPoint object represents a 2D or 3D point in a coordinate system; it includes values for the coordinates in up to three dimensions, as well as an optional perspective value.

The DOMPointReadOnly interface specifies the coordinate and perspective fields used by DOMPoint to define a 2D or 3D point in a coordinate system.

A DOMRect describes the size and position of a rectangle.

The DOMRectReadOnly interface specifies the standard properties (also used by DOMRect) to define a rectangle whose properties are immutable.

The DOMStringMap interface is used for the HTMLElement.dataset attribute, to represent data for custom attributes added to elements.

The DragEvent interface is a DOM event that represents a drag and drop interaction.

Element is the most general base class from which all element objects (i.e., objects that represent elements) in a Document inherit.

The ElementInternals interface of the Document Object Model gives web developers a way to allow custom elements to fully participate in HTML forms.

The ErrorEvent interface represents events providing information related to errors in scripts or in files.

The EXT_blend_minmax extension is part of the WebGL API and extends blending capabilities by adding two new blend equations: the minimum or maximum color components of the source and destination colors.

The EXT_color_buffer_float extension is part of WebGL and adds the ability to render a variety of floating point formats.

The EXT_color_buffer_half_float extension is part of the WebGL API and adds the ability to render to 16-bit floating-point color buffers.

The WebGL API's EXT_float_blend extension allows blending and draw buffers with 32-bit floating-point components.

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_shader_texture_lod extension is part of the WebGL API and adds additional texture functions to the OpenGL ES Shading Language which provide the shader writer with explicit control of LOD (Level of detail).

The EXT_sRGB extension is part of the WebGL API and adds sRGB support to textures and framebuffer objects.

The EXT_texture_compression_bptc extension is part of the WebGL API and exposes 4 BPTC compressed texture formats.

The EXT_texture_compression_rgtc extension is part of the WebGL API and exposes 4 RGTC compressed texture formats.

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

The File and Directory Entries API interface FileSystem is used to represent a file system.

The FileSystemDirectoryEntry interface of the File and Directory Entries API represents a directory in a file system.

The FileSystemDirectoryReader interface of the File and Directory Entries API lets you access the FileSystemFileEntry-based objects (generally FileSystemFileEntry or FileSystemDirectoryEntry) representing each entry in a directory.

The FileSystemEntry interface of the File and Directory Entries API represents a single entry in a file system.

The FocusEvent interface represents focus-related events, including Element/focus_event, Element/blur_event, Element/focusin_event, and Element/focusout_event.

The FontFace interface of the CSS Font Loading API represents a single usable font face.

The FontFaceSetLoadEvent interface of the CSS Font Loading API represents events fired at a FontFaceSet after it starts loading font faces.

The FormDataEvent interface represents a formdata event — such an event is fired on an HTMLFormElement object after the entry list representing the form's data is constructed.

The FragmentDirective interface is an object exposed to allow code to check whether or not a browser supports text fragments.

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

The GamepadButton interface defines 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.

The GamepadEvent interface of the Gamepad API contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected_event and Window.gamepaddisconnected_event are fired in response to.

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

The HashChangeEvent interface represents events that fire when the fragment identifier of the URL has changed.

The History interface of the History API allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in.

The HTMLAnchorElement interface represents 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.

The HTMLAreaElement 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 area elements.

The HTMLAudioElement interface provides access to the properties of audio elements, as well as methods to manipulate them.

The HTMLBaseElement interface contains the base URI for a document.

The HTMLBodyElement interface provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating body elements.

The HTMLBRElement interface represents an HTML line break element (br).

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

The HTMLCanvasElement interface provides properties and methods for manipulating the layout and presentation of canvas elements.

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

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

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

The HTMLDialogElement interface provides methods to manipulate dialog elements.

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

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

The HTMLElement interface represents any HTML element.

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

The HTMLFieldSetElement interface 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 fieldset elements.

Implements the document object model (DOM) representation of the font element.

The HTMLFrameSetElement interface provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating frameset elements.

The HTMLHeadElement interface contains the descriptive information, or metadata, for a document.

The HTMLHeadingElement interface represents the different heading elements, <h1> through <h6>.

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

The HTMLHtmlElement interface serves as the root node for a given HTML document.

The HTMLIFrameElement 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.

The HTMLImageElement interface represents an HTML img element, providing the properties and methods used to manipulate image elements.

The HTMLInputElement interface provides special properties and methods for manipulating the options, layout, and presentation of input elements.

The HTMLLabelElement interface gives access to properties specific to label elements.

The HTMLLegendElement is an interface allowing to access properties of the legend elements.

The HTMLLIElement 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.

The HTMLLinkElement interface represents reference information for external resources and the relationship of those resources to a document and vice versa (corresponds to <link> element; not to be confused with <a>, which is represented by HTMLAnchorElement).

The HTMLMapElement 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.

The HTMLMarqueeElement interface provides methods to manipulate marquee elements.

The HTMLMediaElement interface adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video.

The HTMLMenuElement interface provides additional properties (beyond those inherited from the HTMLElement interface) for manipulating a menu element.

The HTMLMetaElement interface contains descriptive metadata about a document provided in HTML as <meta> elements.

The HTML meter 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 meter elements.

The HTMLModElement interface 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 del and ins.

The HTMLObjectElement interface 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 object element, representing external resources.

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

The HTMLOptGroupElement interface 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 optgroup elements.

The HTMLOptionElement interface represents option elements and inherits all properties and methods of the HTMLElement interface.

The HTMLOutputElement interface provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of output elements.

The HTMLParagraphElement interface provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating p elements.

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

The HTMLPictureElement interface represents a picture HTML element.

The HTMLPreElement interface 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 (pre).

The HTMLProgressElement interface 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 progress elements.

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

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

The HTMLSlotElement interface of the Shadow DOM API enables access to the name and assigned nodes of an HTML slot element.

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

The HTMLSpanElement interface represents a span element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

The HTMLStyleElement interface represents a style element.

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

The HTMLTableCellElement interface 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 cells (th) or data cells (td), in an HTML document.

The HTMLTableColElement interface provides properties for manipulating single or grouped table column elements.

The HTMLTableElement interface 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.

The HTMLTableRowElement interface 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.

The HTMLTableSectionElement interface 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 (thead, tfoot, and tbody, respectively) in an HTML table.

The HTMLTemplateElement interface enables access to the contents of an HTML template element.

The HTMLTextAreaElement interface provides properties and methods for manipulating the layout and presentation of textarea elements.

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

The HTMLTitleElement interface is implemented by a document's title.

The HTMLTrackElement interface represents an HTML track element within the DOM.

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

The HTMLUnknownElement interface represents an invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

Implemented by the video element, the HTMLVideoElement interface provides special properties and methods for manipulating video objects.

The IDBCursor interface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database.

The IDBCursorWithValue interface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database.

The IDBFactory interface of the IndexedDB API lets applications asynchronously access the indexed databases.

IDBIndex interface of the IndexedDB API provides asynchronous access to an index in a database.

The IDBKeyRange interface of the IndexedDB API represents a continuous interval over some data type that is used for keys.

The IDBOpenDBRequest interface of the IndexedDB API provides access to the results of requests to open or delete databases (performed using IDBFactory.open and IDBFactory.deleteDatabase), using specific event handler attributes.

The IDBRequest interface of the IndexedDB API provides access to results of asynchronous requests to databases and database objects using event handler attributes.

The IDBTransaction interface of the IndexedDB API provides a static, asynchronous transaction on a database using event handler attributes.

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

The IdleDeadline interface is used as the data type of the input parameter to idle callbacks established by calling Window.requestIdleCallback().

The ImageBitmap interface represents a bitmap image which can be drawn to a canvas without undue latency.

The ImageBitmapRenderingContext interface is a canvas rendering context that provides the functionality to replace the canvas's contents with the given ImageBitmap.

The ImageData interface represents the underlying pixel data of an area of a canvas element.

The InputEvent interface represents an event notifying the user of editable content changes.

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 KHR_parallel_shader_compile extension is part of the WebGL API and enables a non-blocking poll operation, so that compile/link status availability (COMPLETION_STATUS_KHR) can be queried without potentially incurring stalls.

The Location interface represents the location (URL) of the object it is linked to.

The MathMLElement interface represents any MathML element.

The MediaEncryptedEvent interface of the Encrypted Media Extensions API contains the information associated with an HTMLMediaElement/encrypted_event event sent to a HTMLMediaElement when some initialization data is encountered in the media.

The MediaError interface represents an error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as audio or video.

The MediaKeyMessageEvent interface of the Encrypted Media Extensions API contains the content and related data when the content decryption module generates a message for the session. Available only in secure contexts.

The MediaKeys interface of Encrypted Media Extensions API represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback. Available only in secure contexts.

The MediaKeySession interface of the Encrypted Media Extensions API represents a context for message exchange with a content decryption module (CDM). Available only in secure contexts.

A MediaQueryList object stores information on a media query applied to a document, with support for both immediate and event-driven matching against the state of the document.

The MediaQueryListEvent object stores information on the changes that have happened to a MediaQueryList object — instances are available as the event object on a function referenced by a MediaQueryList.change_event event.

The MediaSource interface of the Media Source Extensions API represents a source of media data for an HTMLMediaElement object.

The MediaSourceHandle interface of the Media Source Extensions API is a proxy for a MediaSource that can be transferred from a dedicated worker back to the main thread and attached to a media element via its HTMLMediaElement.srcObject property.

The MediaStream interface of the Media Capture and Streams API represents a stream of media content.

The MediaStreamTrack interface of the Media Capture and Streams API represents a single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well.

The MediaStreamTrackEvent interface of the Media Capture and Streams API represents events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Capture and Streams API methods.

The MIDIConnectionEvent interface of the Web MIDI API is the event passed to the MIDIAccess.statechange_event event of the MIDIAccess interface and the MIDIPort.statechange_event event of the MIDIPort interface. Available only in secure contexts.

The MIDIMessageEvent interface of the Web MIDI API represents the event passed to the MIDIInput.midimessage_event event of the MIDIInput interface. Available only in secure contexts.

The MIDIPort interface of the Web MIDI API represents a MIDI input or output port. Available only in secure contexts.

The MouseEvent interface represents events that occur due to the user interacting with a pointing device (such as a mouse).

The NavigationActivation interface of the Navigation API represents a recent cross-document navigation.

The NavigationHistoryEntry interface of the Navigation API represents a single navigation history entry.

The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus letting those object types to be used similarly and often interchangeably.

The NodeIterator interface represents an iterator to traverse nodes of a DOM subtree in document order.

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_fbo_render_mipmap extension is part of the WebGL API and makes it possible to attach any level of a texture to a framebuffer object.

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 OES_vertex_array_object extension is part of the WebGL API and provides vertex array objects (VAOs) which encapsulate vertex array states.

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

When using the canvas element or the Canvas API, rendering, animation, and user interaction usually happen on the main execution thread of a web application.

The OffscreenCanvasRenderingContext2D interface is a CanvasRenderingContext2D rendering context for drawing to the bitmap of an OffscreenCanvas object.

The OVR_multiview2 extension is part of the WebGL API and adds support for rendering into multiple views simultaneously.

The PageRevealEvent event object is made available inside handler functions for the Window.pagereveal_event event.

The PageSwapEvent event object is made available inside handler functions for the Window.pageswap_event event.

The PageTransitionEvent event object is available inside handler functions for the pageshow and pagehide events, fired when a document is being loaded or unloaded.

The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus letting those object types to be used similarly and often interchangeably.

The Path2D interface of the Canvas 2D API is used to declare a path that can then be used on a CanvasRenderingContext2D object.

The PaymentMethodChangeEvent interface of the Payment Request API describes the PaymentRequest/paymentmethodchange_event event which is fired by some payment handlers when the user switches payment instruments (e.g., a user selects a 'store' card to make a purchase while using Apple Pay). Available only in secure contexts.

The PaymentRequestUpdateEvent interface is used for events sent to a PaymentRequest instance when changes are made to shipping-related information for a pending PaymentRequest. Available only in secure contexts.

The Performance interface provides access to performance-related information for the current page.

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

The PerformanceTiming interface is 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.

The PictureInPictureEvent interface represents picture-in-picture-related events, including HTMLVideoElement/enterpictureinpicture_event, HTMLVideoElement/leavepictureinpicture_event and PictureInPictureWindow/resize_event.

The PictureInPictureWindow interface represents an object able to programmatically obtain the width and height and resize event of the floating video window.

The PointerEvent interface represents 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 interface for the Window/popstate_event event.

The ProcessingInstruction interface represents a processing instruction; that is, a Node which embeds an instruction targeting a specific application but that can be ignored by any other applications which don't recognize the instruction.

The ProgressEvent interface represents events that measure the progress of an underlying process, like an HTTP request (e.g., an XMLHttpRequest, or the loading of the underlying resource of an img, audio, video, style or link).

The PromiseRejectionEvent interface represents events which are sent to the global script context when JavaScript Promises are rejected.

The Range interface represents a fragment of a document that can contain nodes and parts of text nodes.

The RemotePlayback interface of the Remote Playback API allows the page to detect availability of remote playback devices, then connect to and control playing on these devices.

The RTCDataChannel interface represents a network channel which can be used for bidirectional peer-to-peer transfers of arbitrary data.

The RTCDataChannelEvent interface represents an event related to a specific RTCDataChannel.

The RTCDtlsTransport interface provides access to information about the Datagram Transport Layer Security (DTLS) transport over which a RTCPeerConnection's RTP and RTCP packets are sent and received by its RTCRtpSender and RTCRtpReceiver objects.

The RTCDTMFToneChangeEvent interface represents events sent to indicate that DTMF tones have started or finished playing.

The RTCError interface describes an error which has occurred while handling WebRTC operations.

The WebRTC API's RTCErrorEvent interface represents an error sent to a WebRTC object.

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

The RTCIceCandidatePair dictionary describes a pair of ICE candidates which together comprise a description of a viable connection between two WebRTC endpoints.

The RTCIceTransport interface provides access to information about the ICE transport layer over which the data is being sent and received.

The RTCPeerConnectionIceErrorEvent interface—based upon the Event interface—provides details pertaining to an ICE error announced by sending an RTCPeerConnection.icecandidateerror_event event to the RTCPeerConnection object.

The RTCPeerConnectionIceEvent interface represents events that occur in relation to ICE candidates with the target, usually an RTCPeerConnection.

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

The RTCRtpScriptTransform interface of the WebRTC API is used to insert a WebRTC Encoded Transform (a TransformStream running in a worker thread) into the WebRTC sender and receiver pipelines.

The WebRTC API interface RTCTrackEvent represents the RTCPeerConnection.track_event event, which is sent when a new MediaStreamTrack is added to an RTCRtpReceiver which is part of the RTCPeerConnection.

The Screen interface represents a screen, usually the one on which the current window is being rendered, and is obtained using window.screen.

The ScreenOrientation interface of the Screen Orientation API provides information about the current orientation of the document.

The SecurityPolicyViolationEvent interface inherits from Event, and represents the event object of a securitypolicyviolation event sent on an Element/securitypolicyviolation_event, Document/securitypolicyviolation_event, or WorkerGlobalScope/securitypolicyviolation_event when its Content Security Policy (CSP) is violated.

A Selection object represents the range of text selected by the user or the current position of the caret.

The ShadowRoot interface of the Shadow DOM API is the root node of a DOM subtree that is rendered separately from a document's main DOM tree.

The SourceBuffer interface represents a chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object.

The SpeechSynthesis interface of the Web Speech API 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.

The SpeechSynthesisErrorEvent interface of the Web Speech API contains information about any errors that occur while processing SpeechSynthesisUtterance objects in the speech service.

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

The SpeechSynthesisUtterance interface of the Web Speech API represents a speech request.

The SpeechSynthesisVoice interface of the Web Speech API represents a voice that the system supports.

The DOM StaticRange interface extends AbstractRange to provide a method to specify a range of content in the DOM whose contents don't update to reflect changes which occur within the DOM tree.

The StorageEvent interface is implemented by the Window/storage_event event, which is sent to a window when a storage area the window has access to is changed within the context of another document.

The StylePropertyMap interface of the CSS Typed Object Model API provides a representation of a CSS declaration block that is an alternative to CSSStyleDeclaration.

An object implementing the StyleSheet interface represents a single style sheet.

The SubmitEvent interface defines the object used to represent an HTML form's HTMLFormElement.submit_event event.

The SVGAElement interface provides access to the properties of an a element, as well as methods to manipulate them.

The SVGAngle interface is used to represent a value that can be an <angle> or <number> value.

The SVGAnimatedAngle interface is used for attributes of basic type <angle> which can be animated.

The SVGAnimatedBoolean interface is used for attributes of type boolean which can be animated.

The SVGAnimatedEnumeration interface describes attribute values which are constants from a particular enumeration and which can be animated.

The SVGAnimatedInteger interface is used for attributes of basic type <integer> which can be animated.

The SVGAnimatedLength interface represents attributes of type <length> which can be animated.

The SVGAnimatedLengthList interface is used for attributes of type SVGLengthList which can be animated.

The SVGAnimatedNumber interface represents attributes of type <number> which can be animated.

The SVGAnimatedNumberList interface represents a list of attributes of type <number> which can be animated.

The SVGAnimatedPreserveAspectRatio interface represents attributes of type SVGPreserveAspectRatio which can be animated.

The SVGAnimatedRect interface represents an SVGRect attribute that can be animated.

The SVGAnimatedString interface represents string attributes which can be animated from each SVG declaration.

The SVGAnimatedTransformList interface represents attributes which take a list of numbers and which can be animated.

The SVGAnimateElement interface corresponds to the animate element.

The SVGAnimateMotionElement interface corresponds to the animateMotion element.

The SVGAnimateTransformElement interface corresponds to the animateTransform element.

The SVGAnimationElement interface is the base interface for all of the animation element interfaces: SVGAnimateElement, SVGSetElement, SVGAnimateColorElement, SVGAnimateMotionElement and SVGAnimateTransformElement.

The SVGCircleElement interface is an interface for the circle element.

The SVGClipPathElement interface provides access to the properties of clipPath elements, as well as methods to manipulate them.

The SVGComponentTransferFunctionElement interface represents a base interface used by the component transfer function interfaces.

The SVGDefsElement interface corresponds to the defs element.

The SVGDescElement interface corresponds to the desc element.

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

The SVGEllipseElement interface provides access to the properties of ellipse elements.

The SVGFEBlendElement interface corresponds to the feBlend element.

The SVGFEColorMatrixElement interface corresponds to the feColorMatrix element.

The SVGFEComponentTransferElement interface corresponds to the feComponentTransfer element.

The SVGFECompositeElement interface corresponds to the feComposite element.

The SVGFEConvolveMatrixElement interface corresponds to the feConvolveMatrix element.

The SVGFEDiffuseLightingElement interface corresponds to the feDiffuseLighting element.

The SVGFEDisplacementMapElement interface corresponds to the feDisplacementMap element.

The SVGFEDistantLightElement interface corresponds to the feDistantLight element.

The SVGFEDropShadowElement interface corresponds to the feDropShadow element.

The SVGFEFloodElement interface corresponds to the feFlood element.

The SVGFEFuncAElement interface corresponds to the feFuncA element.

The SVGFEFuncBElement interface corresponds to the feFuncB element.

The SVGFEFuncGElement interface corresponds to the feFuncG element.

The SVGFEFuncRElement interface corresponds to the feFuncR element.

The SVGFEGaussianBlurElement interface corresponds to the feGaussianBlur element.

The SVGFEImageElement interface corresponds to the feImage element.

The SVGFEMergeElement interface corresponds to the feMerge element.

The SVGFEMergeNodeElement interface corresponds to the feMergeNode element.

The SVGFEMorphologyElement interface corresponds to the feMorphology element.

The SVGFEOffsetElement interface corresponds to the feOffset element.

The SVGFEPointLightElement interface corresponds to the fePointLight element.

The SVGFESpecularLightingElement interface corresponds to the feSpecularLighting element.

The SVGFESpotLightElement interface corresponds to the feSpotLight element.

The SVGFETileElement interface corresponds to the feTile element.

The SVGFETurbulenceElement interface corresponds to the feTurbulence element.

The SVGFilterElement interface provides access to the properties of filter elements, as well as methods to manipulate them.

The SVGForeignObjectElement interface provides access to the properties of foreignObject elements, as well as methods to manipulate them.

The SVGGElement interface corresponds to the g element.

The SVGGeometryElement interface represents SVG elements whose rendering is defined by geometry with an equivalent path, and which can be filled and stroked.

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

The SVGGraphicsElement interface represents SVG elements whose primary purpose is to directly render graphics into a group.

The SVGImageElement interface corresponds to the image element.

The SVGLength interface correspond to the <length> basic data type.

The SVGLinearGradientElement interface corresponds to the linearGradient element.

The SVGLineElement interface provides access to the properties of line elements, as well as methods to manipulate them.

The SVGMarkerElement interface provides access to the properties of marker elements, as well as methods to manipulate them.

The SVGMaskElement interface provides access to the properties of mask elements, as well as methods to manipulate them.

The SVGMetadataElement interface corresponds to the metadata element.

The SVGMPathElement interface corresponds to the mpath element.

The SVGNumber interface corresponds to the <number> basic data type.

The SVGPathElement interface corresponds to the path element.

The SVGPatternElement interface corresponds to the pattern element.

The SVGPolygonElement interface provides access to the properties of polygon elements, as well as methods to manipulate them.

The SVGPolylineElement interface provides access to the properties of polyline elements, as well as methods to manipulate them.

The SVGPreserveAspectRatio interface corresponds to the preserveAspectRatio attribute.

The SVGRadialGradientElement interface corresponds to the RadialGradient element.

The SVGRectElement interface provides access to the properties of rect elements, as well as methods to manipulate them.

The SVGScriptElement interface corresponds to the SVG script element.

The SVGSetElement interface corresponds to the set element.

The SVGStopElement interface corresponds to the stop element.

The SVGStyleElement interface corresponds to the SVG style element.

The SVGSVGElement interface provides access to the properties of svg elements, as well as methods to manipulate them.

The SVGSwitchElement interface corresponds to the switch element.

The SVGSymbolElement interface corresponds to the symbol element.

The SVGTextContentElement interface is implemented by elements that support rendering child text content.

The SVGTextElement interface corresponds to the text elements.

The SVGTextPathElement interface corresponds to the textPath element.

The SVGTextPositioningElement interface is implemented by elements that support attributes that position individual text glyphs.

The SVGTitleElement interface corresponds to the title element.

The SVGTransform interface reflects 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 SVGTSpanElement interface represents a tspan element.

The SVGUseElement interface corresponds to the use element.

The SVGViewElement interface provides access to the properties of view elements, as well as methods to manipulate them.

The Text interface represents a text Node in a DOM tree.

The TextEvent interface is a legacy UI event interface for reporting changes to text UI elements.

The TextMetrics interface represents the dimensions of a piece of text in the canvas; a TextMetrics instance can be retrieved using the CanvasRenderingContext2D.measureText() method.

The TextTrack interface of the WebVTT API represents a text track associated with a media element.

The TextTrackCue interface of the WebVTT API is the abstract base class for the various derived cue types, such as VTTCue; you will work with these derived types rather than the base class.

When loading a media resource for use by an audio or video element, the TimeRanges interface is used for representing the time ranges of the media resource that have been buffered, the time ranges that have been played, and the time ranges that are seekable.

The ToggleEvent interface represents an event notifying the user an Element's state has changed.

The Touch interface represents a single contact point on a touch-sensitive device.

The TouchEvent interface represents an UIEvent which is sent when the state of contacts with a touch-sensitive surface changes.

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

The TransitionEvent interface represents events providing information related to transitions.

The TreeWalker object represents the nodes of a document subtree and a position within them.

The UIEvent interface represents simple user interface events.

The ValidityState interface represents the validity states that an element can be in, with respect to constraint validation.

The VideoColorSpace interface of the WebCodecs API represents the color space of a video.

The VideoFrame interface of the Web Codecs API represents a frame of a video.

A VideoPlaybackQuality object is returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video.

The ViewTransition interface of the View Transition API represents an active view transition, and provides functionality to react to the transition reaching different states (e.g., ready to run the animation, or animation finished) or skip the transition altogether.

The VisualViewport interface of the Visual Viewport API represents the visual viewport for a given window.

The WEBGL_color_buffer_float extension is part of the WebGL API and adds the ability to render to 32-bit floating-point color buffers.

The WEBGL_compressed_texture_astc extension is part of the WebGL API and exposes Adaptive Scalable Texture Compression (ASTC) compressed texture formats to WebGL.

The WEBGL_compressed_texture_etc extension is part of the WebGL API and exposes 10 ETC/EAC compressed texture formats.

The WEBGL_compressed_texture_etc1 extension is part of the WebGL API and exposes the ETC1 compressed texture format.

The WEBGL_compressed_texture_pvrtc extension is part of the WebGL API and exposes four PVRTC compressed texture formats.

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

The WEBGL_compressed_texture_s3tc_srgb extension is part of the WebGL API and exposes four S3TC compressed texture formats for the sRGB colorspace.

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

The WEBGL_debug_shaders extension is part of the WebGL API and exposes a method to debug shaders from privileged contexts.

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

The WEBGL_lose_context extension is part of the WebGL API and exposes functions to simulate losing and restoring a WebGLRenderingContext.

The WebGL2RenderingContext interface provides the OpenGL ES 3.0 rendering context for the drawing surface of an HTML canvas element.

The WebGLActiveInfo interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods.

The WebGLBuffer interface is part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.

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

The WebGLFramebuffer interface is 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).

The WebGLQuery interface is part of the WebGL 2 API and provides ways to asynchronously query for information.

The WebGLRenderbuffer interface is part of the WebGL API and represents a buffer that can contain an image, or that can be a source or target of a rendering operation.

The WebGLRenderingContext interface provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML canvas element.

The WebGLSampler interface is part of the WebGL 2 API and stores sampling parameters for WebGLTexture access inside of a shader.

The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader.

The WebGLShaderPrecisionFormat interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method.

The WebGLSync interface is part of the WebGL 2 API and is used to synchronize activities between the GPU and the application.

The WebGLTexture interface is part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.

The WebGLTransformFeedback interface is part of the WebGL 2 API and enables transform feedback, which is the process of capturing primitives generated by vertex processing.

The WebGLUniformLocation interface is part of the WebGL API and represents the location of a uniform variable in a shader program.

The WebGLVertexArrayObject interface is part of the WebGL 2 API, represents vertex array objects (VAOs) pointing to vertex array data, and provides names for different sets of vertex data.

MDN Reference

The WheelEvent interface represents events that occur due to the user moving a mouse wheel or similar input device.

The Window interface represents a window containing a DOM document; the document property points to the DOM document loaded in that window.

The Worker interface of the Web Workers API represents a background task that can be created via script, which can send messages back to its creator.

The XMLDocument interface represents an XML document.

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

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

Defines the TReturn type used for built-in iterators produced by Array, Map, Set, and others. This is undefined when strictBuiltInIteratorReturn is true; otherwise, this is any.