package js.html

..
audio
eme
idb
midi
push
rtc
svg
webgl
AbortController

The AbortController interface represents a controller object that allows you to abort one or more DOM requests as and when desired.

AbortSignal

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

AddEventListenerOptions

AlignSetting

AnchorElement

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.

Animation

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.

AnimationEffect

The AnimationEffect interface of the Web Animations API defines current and future animation effects like KeyframeEffect, which can be passed to Animation objects for playing, and KeyframeEffectReadOnly (which is used by CSS Animations and Transitions).

AnimationEvent

The AnimationEvent interface represents events providing information related to animations.

AnimationEventInit

AnimationFilter

AnimationPlayState

AnimationPlaybackEvent

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

AnimationPlaybackEventInit

AnimationTimeline

The AnimationTimeline interface of the Web Animations API represents the timeline of an animation. This interface exists to define timeline features (inherited by DocumentTimeline and future timeline types) and is not itself directly used by developers. Anywhere you see AnimationTimeline, you should use DocumentTimeline or any other timeline type instead.

AreaElement

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.

ArrayBuffer

ArrayBufferView

AssignedNodesOptions

Attr

This type represents 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.

Audio

AudioElement

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

AudioStreamTrack

AudioTrack

The AudioTrack interface represents a single audio track from one of the HTML media elements, audio or video.

AudioTrackList

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

AutoKeyword

BRElement

The HTMLBRElement interface represents a HTML line break element (br). It inherits from HTMLElement.

BarProp

BaseElement

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

BatteryManager

The BatteryManager interface provides ways to get information about the system's battery charge level.

BeforeUnloadEvent

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

BinaryType

Blob

A Blob object represents 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.

BlobEvent

The BlobEvent interface represents events associated with a Blob. These blobs are typically, but not necessarily,  associated with media content.

BlobEventInit

BlobPropertyBag

BodyElement

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

BroadcastChannel

The BroadcastChannel interface represents a named channel that any browsing context of a given origin can subscribe to. It allows communication between different documents (in different windows, tabs, frames or iframes) of the same origin. Messages are broadcasted via a message event fired at all BroadcastChannel objects listening to the channel.

ButtonElement

The HTMLButtonElement interface provides properties and methods (beyond the button object interface it also has available to them by inheritance) for manipulating the layout and presentation of button elements.

CDATASection

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

CSS

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

CSSAnimation

CSSBoxType

CSSConditionRule

An object implementing the CSSConditionRule interface represents a single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule.

CSSCounterStyleRule

The CSSCounterStyleRule interface represents an @counter-style at-rule.

CSSFontFaceRule

CSSFontFeatureValuesRule

CSSGroupingRule

An object implementing the CSSGroupingRule interface represents any CSS at-rule that contains other rules nested within it.

CSSImportRule

CSSKeyframeRule

The CSSKeyframeRule interface describes 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).

CSSKeyframesRule

The CSSKeyframesRule interface describes 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).

CSSMediaRule

The CSSMediaRule is an interface representing 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).

CSSMozDocumentRule

CSSNamespaceRule

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

CSSPageRule

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

CSSPseudoElement

CSSRule

The CSSRule interface represents a single CSS rule. There are several types of rules, listed in the Type constants section below.

CSSRuleList

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

CSSStyleDeclaration

CSSStyleDeclaration represents a collection of CSS property-value pairs. It is used in a few APIs:

CSSStyleRule

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

CSSStyleSheet

The CSSStyleSheet interface represents a single CSS style sheet. It inherits properties and methods from its parent, StyleSheet.

CSSSupportsRule

The CSSSupportsRule interface describes 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).

CSSTransition

Cache

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

CacheQueryOptions

CacheStorage

The CacheStorage interface represents the storage for Cache objects.

CacheStorageNamespace

CanvasCaptureMediaStream

CanvasElement

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

CanvasGradient

The CanvasGradient interface represents an opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient().

CanvasPattern

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.

CanvasRenderingContext2D

To get an object of this interface, call getContext() on a canvas element, supplying "2d" as the argument:

CanvasWindingRule

CaretPosition

The CaretPosition interface represents the caret postion, an indicator for the text insertion point. You can get a CaretPosition using the document.caretPositionFromPoint method.

ChannelPixelLayout

ChannelPixelLayoutDataType

CharacterData

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, '. In XML, the character sequence '--' cannot be used within a comment.">Comment, or ProcessingInstruction which aren't abstract.

Client

The Client interface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can get Client/WindowClient objects from methods such as Clients.matchAll() and Clients.get().

ClientQueryOptions

ClientType

Clients

The Clients interface provides access to Client objects. Access it via self.clients within a service worker.

Clipboard

The Clipboard interface implements the Clipboard API, providing—if the user grants permission—both read and write access to the contents of the system clipboard.

ClipboardEvent

The ClipboardEvent interface represents events providing information related to modification of the clipboard, that is cut, copy, and paste events.

ClipboardEventInit

CloseEvent

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.

CloseEventInit

Comment

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. Comments are represented in HTML and XML as content between '!--' and '--'. In XML, the character sequence '--' cannot be used within a comment.

CompositeOperation

CompositionEvent

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

CompositionEventInit

ComputedEffectTiming

Console

The Console object 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.

ConsoleInstance

The Console object 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.

ConstrainBooleanParameters

ConstrainDOMStringParameters

ConstrainDoubleRange

ConstrainLongRange

ConvertCoordinateOptions

Coordinates

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

Crypto

The Crypto interface represents basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.

CryptoKey

The CryptoKey interface represents a cryptographic key derived from a specific key algorithm.

CustomEvent

This interface inherits properties from its parent, Event:

CustomEventInit

DListElement

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

DOMElement

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.

DOMError

The DOMError interface describes an error object that contains an error name.

DOMException

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

DOMImplementation

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

DOMMatrix

The DOMMatrix interface represents 4x4 matrices, suitable for 2D and 3D operations.

DOMMatrixReadOnly

The DOMMatrixReadOnly interface represents 4x4 matrices, suitable for 2D and 3D operations. If this interface defines only read-only matrices, the DOMMatrix interface which inherits from it, add all the properties and the methods to allow to have modifiable matrices.

DOMParser

The DOMParser interface provides the ability to parse XML or HTML source code from a string into a DOM Document.

DOMPoint

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.

DOMPointInit

The DOMPointInit dictionary is used to provide the values of the coordinates and perspective when creating and JSONifying a DOMPoint or DOMPointReadOnly object.

DOMPointReadOnly

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

DOMQuad

A DOMQuad is a collection of four DOMPoints defining the corners of an arbitrary quadrilateral. Returning DOMQuads lets getBoxQuads() return accurate information even when arbitrary 2D or 3D transforms are present. It has a handy bounds attribute returning a DOMRectReadOnly for those cases where you just want an axis-aligned bounding rectangle.

DOMQuadJSON

DOMRect

A DOMRect represents a rectangle.

DOMRectList

DOMRectReadOnly

The DOMRectReadOnly interface specifies the standard properties used by DOMRect to define a rectangle.

DOMRequest

DOMRequestReadyState

DOMStringList

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

DOMStringMap

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

DOMTokenList

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

DataElement

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

DataListElement

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.

DataTransfer

The DataTransfer object is 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.

DataTransferItem

The DataTransferItem object represents 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.

DataTransferItemList

The DataTransferItemList object is 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.

DataView

DedicatedWorkerGlobalScope

The DedicatedWorkerGlobalScope object (the Worker global scope) is accessible through the self keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the JavaScript Reference. See also: Functions available to workers.

DetailsElement

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

DeviceAcceleration

A DeviceAcceleration object provides information about the amount of acceleration the device is experiencing along all three axes.

DeviceAccelerationInit

DeviceMotionEvent

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

DeviceMotionEventInit

DeviceOrientationEvent

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

DeviceOrientationEventInit

DeviceRotationRate

A DeviceRotationRate object provides information about the rate at which the device is rotating around all three axes.

DeviceRotationRateInit

DirectionSetting

Directory

DirectoryElement

DisplayNameOptions

DisplayNameResult

DivElement

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

Document

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

DocumentFragment

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

DocumentTimeline

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

DocumentTimelineOptions

DocumentType

The DocumentType interface represents a Node containing a doctype.

DragEvent

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

DragEventInit

EffectTiming

The EffectTiming dictionary, part of the Web Animations API, is used by Element.animate(), KeyframeEffectReadOnly(), and KeyframeEffect() to describe timing properties for animation effects. These properties are all optional, although without setting a duration the animation will not play.

Element

The HTMLElement interface represents any HTML element. Some elements directly implement this interface, others implement it via an interface that inherits it.

ElementCreationOptions

EmbedElement

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

EndingTypes

ErrorCallback

ErrorEvent

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

ErrorEventInit

Event

The Event interface represents any event which takes place in the DOM; some are user-generated (such as mouse or keyboard events), while others are generated by APIs (such as events that indicate an animation has finished running, a video has been paused, and so forth). There are many types of events, some of which use other interfaces based on the main Event interface. Event itself contains the properties and methods which are common to all events.

EventInit

EventListener

The EventListener interface represents an object that can handle an event dispatched by an EventTarget object.

EventListenerOptions

EventModifierInit

EventSource

The EventSource interface is web content's interface to server-sent events. An EventSource instance opens a persistent connection to an HTTP server, which sends events in text/event-stream format.

EventSourceInit

EventTarget

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

Exception

ExtendableEvent

The ExtendableEvent interface extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.

ExtendableEventInit

ExtendableMessageEvent

The ExtendableMessageEvent interface of the ServiceWorker API represents the event object of a message event fired on a service worker (when a channel message is received on the ServiceWorkerGlobalScope from another context) — extends the lifetime of such events.

ExtendableMessageEventInit

External

FetchEvent

This is the event type for fetch events dispatched on the service worker global scope. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the event.respondWith() method, which allows us to provide a response to this fetch.

FetchEventInit

FetchObserver

FetchState

FieldSetElement

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

File

The File interface provides information about files and allows JavaScript in a web page to access their content.

FileCallback

FileList

An object of this type is returned by the files property of the HTML input element; this lets you access the list of files selected with the input type="file" 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.

FileMode

FilePropertyBag

FileReader

The FileReader object 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.

FileReaderSync

The FileReaderSync interface allows to read File or Blob objects in a synchronous way.

FileSystem

The File and Directory Entries API interface FileSystem is used to represent a file system. These objects can be obtained from the filesystem property on any file system entry. Some browsers offer additional APIs to create and manage file systems, such as Chrome's requestFileSystem() method.

FileSystemDirectoryEntry

The FileSystemDirectoryEntry interface of the File and Directory Entries API represents a directory in a file system. It provides methods which make it possible to access and manipulate the files in a directory, as well as to access the entries within the directory.

FileSystemDirectoryReader

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

FileSystemEntriesCallback

FileSystemEntry

The FileSystemEntry interface of the File and Directory Entries API represents a single in a file system. The entry can be a file or a directory (directories are represented by the DirectoryEntry interface). It includes methods for working with files—including copying, moving, removing, and reading files—as well as information about a file it points to—including the file name and its path from the root to the entry.

FileSystemEntryCallback

FileSystemFileEntry

The FileSystemFileEntry interface of the File System API represents a file in a file system. It offers properties describing the file's attributes, as well as the file() method, which creates a File object that can be used to read the file.

FileSystemFlags

The FileSystemFlags dictionary defines a set of values which are used when specifying option flags when calling certain methods in the File and Directory Entries API. Methods which accept an options parameter of this type may specify zero or more of these flags as fields in an object, like this:

FillMode

Float32Array

Float64Array

FocusEvent

The FocusEvent interface represents focus-related events like focus, blur, focusin, or focusout.

FocusEventInit

FontElement

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

FontFace

The FontFace interface represents a single usable font face. It allows control of the source of the font face, being a URL to an external resource, or a buffer; it also allows control of when the font face is loaded and its current status.

FontFaceDescriptors

FontFaceLoadStatus

FontFaceSet

The FontFaceSet interface of the CSS Font Loading API manages the loading of font-faces and querying of their download status.

FontFaceSetIterator

FontFaceSetIteratorResult

FontFaceSetLoadEvent

The FontFaceSetLoadEvent interface of the the Css Font Loading API is fired whenever a FontFaceSet loads.

FontFaceSetLoadEventInit

FontFaceSetLoadStatus

FormData

The FormData interface 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".

FormDataIterator

FormElement

The HTMLFormElement interface represents a form 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.

FrameElement

FrameSetElement

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

FrameType

Gamepad

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.

GamepadButton

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.

GamepadEvent

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

GamepadEventInit

GamepadMappingType

Geolocation

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

GetNotificationOptions

GetRootNodeOptions

GetUserMediaRequest

HRElement

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

HTMLAllCollection

HTMLCollection

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

HTMLDocument

HTMLDocument is an abstract interface which extends the Document interface to add HTML-specific features to the document object. It represents the root of the HTML document, within which its entire DOM hierarchy resides.

HTMLFormControlsCollection

The HTMLFormControlsCollection interface represents a collection of HTML form control elements.

HTMLOptionsCollection

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.

HTMLPropertiesCollection

HashChangeEvent

The HashChangeEvent event is fired when the fragment identifier of the URL has changed (the part of the URL that follows the # symbol, including the # symbol).

HashChangeEventInit

HeadElement

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

Headers

The Headers interface of the Fetch API 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.

HeadersIterator

HeadingElement

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

History

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

HitRegionOptions

HtmlElement

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

IFrameElement

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.

Image

ImageBitmap

The ImageBitmap interface represents a bitmap image which can be drawn to a canvas without undue latency. It can be created from a variety of source objects using the createImageBitmap() factory method. ImageBitmap provides an asynchronous and resource efficient pathway to prepare textures for rendering in WebGL.

ImageBitmapFormat

ImageBitmapRenderingContext

The ImageBitmapRenderingContext interface is a canvas rendering context which only provides the functionality to replace the canvas's contents with the given ImageBitmap. Its context id (the first argument to HTMLCanvasElement.getContext() or OffscreenCanvas.getContext()  is "bitmaprenderer".

ImageCapture

The ImageCapture interface of the MediaStream Image Capture API provides an interface for capturing images from a photographic device referenced through a valid MediaStreamTrack.

ImageCaptureError

ImageCaptureErrorEvent

ImageCaptureErrorEventInit

ImageData

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

ImageElement

The HTMLImageElement interface provides special properties and methods  for manipulating the layout and presentation of img elements.

InputElement

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

InputEvent

The InputEvent interface represents an event notifying of editable content change.

InputEventInit

Int16Array

Int32Array

Int8Array

IntersectionObserver

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.

IntersectionObserverEntry

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

IntersectionObserverInit

IntlUtils

IterationCompositeOperation

KeyEvent

KeyboardEvent

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.

KeyboardEventInit

KeyframeAnimationOptions

KeyframeEffect

The KeyframeEffect interface of the Web Animations API lets us create sets of animatable properties and values, called keyframes. These can then be played using the Animation() constructor.

KeyframeEffectOptions

LIElement

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.

LabelElement

The HTMLLabelElement interface gives access to properties specific to label elements. It inherits methods and properties from the base HTMLElement interface.

LegendElement

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

LineAlignSetting

LinkElement

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

LocalMediaStream

The LocalMediaStream interface was part of the Media Capture and Streams API, representing a stream of data being generated locally (such as by getUserMedia(). However, getUserMedia() now returns a MediaStream instead, and this interface has been removed from the specification.

LocaleInfo

Location

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

MapElement

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.

MediaDeviceInfo

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

MediaDeviceKind

MediaDevices

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

MediaElement

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

MediaError

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

MediaKeyStatusMapIterator

MediaList

MediaQueryList

A MediaQueryList object 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).

MediaQueryListEvent

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.onchange property or MediaQueryList.addEvent() call.

MediaQueryListEventInit

MediaRecorder

The MediaRecorder interface of the MediaStream Recording API provides functionality to easily record media. It is created using the MediaRecorder() constructor.

MediaRecorderErrorEvent

The MediaRecorderErrorEvent interface represents errors returned by the MediaStream Recording API. It is an Event object that encapsulates a reference to a DOMException describing the error that occurred.

MediaRecorderErrorEventInit

MediaRecorderOptions

MediaSource

The MediaSource interface of the Media Source Extensions API 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.

MediaSourceEndOfStreamError

MediaSourceReadyState

MediaStream

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

MediaStreamConstraints

The MediaStreamConstraints dictionary is used when calling getUserMedia() to specify what kinds of tracks should be included in the returned MediaStream, and, optionally, to establish constraints for those tracks' settings.

MediaStreamError

MediaStreamEvent

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

MediaStreamEventInit

MediaStreamTrack

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

MediaStreamTrackEvent

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

MediaStreamTrackEventInit

MediaStreamTrackState

MediaTrackConstraintSet

MediaTrackConstraints

The MediaTrackConstraints dictionary is used to describe a set of capabilities and the value or values each can take on. A constraints dictionary is passed into applyConstraints() to allow a script to establish a set of exact (required) values or ranges and/or preferred values or ranges of values for the track, and the most recently-requested set of custom constraints can be retrieved by calling getConstraints().

MediaTrackSettings

The MediaTrackSettings dictionary is used to return the current values configured for each of a MediaStreamTrack's settings. These values will adhere as closely as possible to any constraints previously described using a MediaTrackConstraints object and set using applyConstraints(), and will adhere to the default constraints for any properties whose constraints haven't been changed, or whose customized constraints couldn't be matched.

MediaTrackSupportedConstraints

The MediaTrackSupportedConstraints dictionary establishes the list of constrainable properties recognized by the user agent or browser in its implementation of the MediaStreamTrack object. An object conforming to MediaTrackSupportedConstraints is returned by MediaDevices.getSupportedConstraints().

MenuElement

MenuItemElement

MessageChannel

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

MessageEvent

The MessageEvent interface represents a message received by a target object.

MessageEventInit

MessagePort

The MessagePort interface of the Channel Messaging API 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.

MetaElement

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

MeterElement

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.

MimeType

The MimeType interface provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object.

MimeTypeArray

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

ModElement

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.

MouseEvent

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

MouseEventInit

MouseScrollEvent

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

MutationEvent

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

MutationObserver

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

MutationObserverInit

The MutationObserverInit dictionary describes the configuration of a mutation observer. As such, it's primarily used as the type of the options parameter on the MutationObserver.observe() method.

MutationRecord

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

NamedNodeMap

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

NavigationType

Navigator

The Navigator interface represents 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

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.

NodeFilter

A NodeFilter interface represents 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.

NodeIterator

The NodeIterator interface represents 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

NodeList objects are collections of nodes such as those returned by properties such as Node.childNodes and the document.querySelectorAll() method.

Notification

The Notification interface of the Notifications API is used to configure and display desktop notifications to the user.

NotificationDirection

NotificationEvent

The parameter passed into the onnotificationclick handler, the NotificationEvent interface represents a notification click event that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.

NotificationEventInit

NotificationOptions

NotificationPermission

OListElement

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.

ObjectElement

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.

ObserverCallback

OfflineAudioCompletionEventInit

OptGroupElement

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.

Option

OptionElement

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

OptionalEffectTiming

OrientationLockType

OrientationType

OutputElement

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

PageTransitionEvent

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

PageTransitionEventInit

PaintRequest

PaintRequestList

PaintWorkletGlobalScope

ParagraphElement

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

ParamElement

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.

Path2D

The Path2D interface of the Canvas 2D API is used to declare paths that are then later used on CanvasRenderingContext2D objects. The path methods of the CanvasRenderingContext2D interface are present on this interface as well and are allowing you to create paths that you can retain and replay as required on a canvas.

Performance

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

PerformanceEntry

The PerformanceEntry object 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).

PerformanceEntryFilterOptions

PerformanceMark

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

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.

PerformanceNavigation

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

PerformanceNavigationTiming

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

PerformanceObserver

The PerformanceObserver interface is used to observe performance measurement events and be notified of new performance entries as they are recorded in the browser's performance timeline.

PerformanceObserverEntryList

The PerformanceObserverEntryList interface is a list of peformance events that were explicitly observed via the observe() method.

PerformanceObserverInit

PerformanceResourceTiming

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

PerformanceServerTiming

The PerformanceServerTiming interface surfaces server metrics that are sent with the response in the Server-Timing HTTP header.

PerformanceTiming

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. You get a PerformanceTiming object describing your page using the window.performance.timing property.

PermissionState

PermissionStatus

The PermissionStatus interface of the Permissions API provides the state of an object and an event handler for monitoring changes to said state.

Permissions

Documentation Permissions by Mozilla Contributors, licensed under CC-BY-SA 2.5.

PictureElement

The HTMLPictureElement interface represents a picture HTML element. It doesn't implement specific properties or methods.

PlaybackDirection

Plugin

The Plugin interface provides information about a browser plugin.

PluginArray

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

PointerEvent

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.

PointerEventInit

PopStateEvent

An event handler for the popstate event on the window.

PopStateEventInit

PopupBlockedEvent

PopupBlockedEventInit

Position

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

PositionAlignSetting

PositionError

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

PositionOptions

The PositionOptions interface describes an object containing option properties to pass as a parameter of Geolocation.getCurrentPosition() and Geolocation.watchPosition().

PreElement

The HTMLPreElement interface expose specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating block of preformatted text.

ProcessingInstruction

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

ProgressElement

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.

ProgressEvent

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

ProgressEventInit

PromiseNativeHandler

PropertyNodeList

QuoteElement

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.

RadioNodeList

The RadioNodeList interface represents a collection of elements in a form or a fieldset element.

Range

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

RecordingState

ReferrerPolicy

RegistrationOptions

Request

The Request interface of the Fetch API represents a resource request.

RequestCache

RequestCredentials

RequestDestination

The RequestDestination enumerated type contains the permitted values for a request's destination. These string values indicate potential types of content that a request may try to retrieve.

RequestInit

RequestMode

RequestRedirect

Response

The Response interface of the Fetch API represents the response to a request.

ResponseInit

ResponseType

Screen

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

ScreenOrientation

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

ScriptElement

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

ScrollAreaEvent

ScrollBehavior

ScrollIntoViewOptions

ScrollLogicalPosition

ScrollOptions

ScrollRestoration

ScrollSetting

ScrollToOptions

SecurityPolicyViolationEvent

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

SecurityPolicyViolationEventDisposition

SecurityPolicyViolationEventInit

SelectElement

The HTMLSelectElement interface represents a select HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface.

Selection

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

SelectionMode

ServiceWorker

The ServiceWorker interface of the ServiceWorker API 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.

ServiceWorkerContainer

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.

ServiceWorkerGlobalScope

The ServiceWorkerGlobalScope interface of the ServiceWorker API represents the global execution context of a service worker.

ServiceWorkerRegistration

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

ServiceWorkerState

The ServiceWorkerState is associated with its ServiceWorker's state.

ServiceWorkerUpdateViaCache

ShadowRoot

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.

ShadowRootInit

ShadowRootMode

SharedWorker

The SharedWorker interface represents a specific kind of worker that can be accessed from several browsing contexts, such as several windows, iframes or even workers. They implement an interface different than dedicated workers and have a different global scope, SharedWorkerGlobalScope.

SharedWorkerGlobalScope

The SharedWorkerGlobalScope object (the SharedWorker global scope) is accessible through the self keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the JavaScript Reference. See the complete list of functions available to workers.

SlotElement

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

SourceBuffer

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

SourceBufferAppendMode

SourceBufferList

The SourceBufferList interface represents a simple container list for multiple SourceBuffer objects.

SourceElement

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

SpanElement

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

SpeechGrammar

The SpeechGrammar interface of the Web Speech API represents a set of words or patterns of words that we want the recognition service to recognize.

SpeechGrammarList

The SpeechGrammarList interface of the Web Speech API represents a list of SpeechGrammar objects containing words or patterns of words that we want the recognition service to recognize.

SpeechRecognition

The SpeechRecognition interface of the Web Speech API is the controller interface for the recognition service; this also handles the SpeechRecognitionEvent sent from the recognition service.

SpeechRecognitionAlternative

The SpeechRecognitionAlternative interface of the Web Speech API represents a single word that has been recognised by the speech recognition service.

SpeechRecognitionError

The SpeechRecognitionError interface of the Web Speech API represents error messages from the recognition service.

SpeechRecognitionErrorCode

SpeechRecognitionErrorInit

SpeechRecognitionEvent

The SpeechRecognitionEvent interface of the Web Speech API represents the event object for the result and nomatch events, and contains all the data associated with an interim or final speech recognition result.

SpeechRecognitionEventInit

SpeechRecognitionResult

The SpeechRecognitionResult interface of the Web Speech API represents a single recognition match, which may contain multiple SpeechRecognitionAlternative objects.

SpeechRecognitionResultList

The SpeechRecognitionResultList interface of the Web Speech API represents a list of SpeechRecognitionResult objects, or a single one if results are being captured in continuous mode.

SpeechSynthesis

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.

SpeechSynthesisErrorCode

SpeechSynthesisErrorEvent

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

SpeechSynthesisErrorEventInit

SpeechSynthesisEvent

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.

SpeechSynthesisEventInit

SpeechSynthesisUtterance

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

SpeechSynthesisVoice

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

Storage

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

StorageEstimate

The StorageEstimate dictionary is used by the StorageManager to provide estimates of the size of a site's or application's data store and how much of it is in use. The estimate() method returns an object that conforms to this dictionary when its Promise resolves.

StorageEvent

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

StorageEventInit

StorageManager

The StorageManager interface of the the Storage API provides an interface for managing persistance permissions and estimating available storage. You can get a reference to this interface using either navigator.storage or WorkerNavigator.storage.

StorageType

StyleElement

The HTMLStyleElement interface represents a style element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle.

StyleSheet

An object implementing the StyleSheet interface represents a single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface.

StyleSheetList

The StyleSheetList interface represents a list of StyleSheet.

SubtleCrypto

The SubtleCrypto interface represents a set of cryptographic primitives. It is available via the Crypto.subtle properties available in a window context (via Window.crypto).

SupportedType

TableCaptionElement

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

TableCellElement

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 or data cells, in an HTML document.

TableColElement

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

TableElement

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.

TableRowElement

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.

TableSectionElement

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, in an HTML table.

TemplateElement

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

Text

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

TextAreaElement

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

TextDecodeOptions

TextDecoder

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

TextDecoderOptions

TextEncoder

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.

TextMetrics

The TextMetrics interface represents the dimension of a text in the canvas, as created by the CanvasRenderingContext2D.measureText() method.

TextTrack

This interface also inherits properties from EventTarget.

TextTrackCue

TextTrackCueList

TextTrackKind

TextTrackList

TextTrackMode

TimeElement

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

TimeEvent

Extends Event.

TimeRanges

The TimeRanges interface is 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 audio and video elements.

TitleElement

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

Touch

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

TouchEvent

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

TouchEventInit

TouchInit

TouchList

The TouchList interface represents a list of contact points with 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.

TrackElement

The HTMLTrackElement

TrackEvent

TrackEventInit

TransitionEvent

The TransitionEvent interface represents events providing information related to transitions.

TransitionEventInit

TreeWalker

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

UIEvent

The UIEvent interface represents simple user interface events.

UIEventInit

UListElement

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

URL

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

URLSearchParams

The URLSearchParams interface defines utility methods to work with the query string of a URL.

URLSearchParamsIterator

Uint16Array

Uint32Array

Uint8Array

Uint8ClampedArray

UnknownElement

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

VTTCue

VTTCues represent a cue in a text track.

VTTRegion

ValidityState

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

VideoElement

The HTMLVideoElement interface provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement.

VideoPlaybackQuality

The VideoPlaybackQuality interface represents the set of metrics describing the playback quality of a video.

VideoStreamTrack

VideoTrack

VideoTrackList

VisibilityState

VisualViewport

The VisualViewport interface of the the Visual Viewport API represents the visual viewport for a given window. For a page containing iframes, each iframe, as well as the containing page, will have a unique window object. Each window on a page will have a unique VisualViewport representing the properties associated with that window.

WebSocket

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

WheelEvent

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

WheelEventInit

Window

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

WindowClient

The WindowClient interface of the ServiceWorker API represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.

Worker

The Worker interface of the Web Workers API 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.

WorkerDebuggerGlobalScope

WorkerGlobalScope

The WorkerGlobalScope interface of the Web Workers API is an interface representing the scope of any worker. Workers have no browsing context; this scope contains the information usually conveyed by Window objects — in this case event handlers, the console or the associated WorkerNavigator object. Each WorkerGlobalScope has its own event loop.

WorkerLocation

The WorkerLocation interface defines the absolute location of the script executed by the Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.location property obtained by calling self.location.

WorkerNavigator

The WorkerNavigator interface represents a subset of the Navigator interface allowed to be accessed from a Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.navigator property obtained by calling window.self.navigator.

WorkerOptions

WorkletGlobalScope

XMLDocument

The XMLDocument interface represent 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.

XMLHttpRequest

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.

XMLHttpRequestEventTarget

XMLHttpRequestResponseType

The XMLHttpRequestResponseType type is an enumerated set of strings which are used to specify the type of data contained in the response of an XMLHttpRequest.

XMLHttpRequestUpload

XMLSerializer

The XMLSerializer interface provides the serializeToString() method to construct an XML string representing a DOM tree.

XPathEvaluator

XPathExpression

An XPathExpression is a compiled XPath query returned from document.createExpression(). It has a method evaluate() which can be used to execute the compiled XPath.

XPathNSResolver

XPathResult

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

XSLTProcessor

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.