org.scalajs.dom

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

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.

The AbstractRange abstract interface is the base class upon which all DOM range types are defined. A range is an object that indicates the start and end points of a section of content within the document.

The AbstractWorker interface abstracts properties and methods common to all kind of workers, being Worker or SharedWorker.

The AnalyserNode interface represents a node able to provide real-time frequency and time-domain analysis information. It is an AudioNode that passes the audio stream unchanged from the input to the output, but allows you to take the generated data,process it, and create audio visualizations.

An AnalyzerNode has exactly one input and one output. The node works even if the output is not connected.

• Number of inputs: 1
• Number of outputs: 1 (but may be left unconnected)
• Channel count mode: "explicit"
• Channel count: 1
• Channel interpretation: "speakers"

The AnimationEvent interface represents events providing information related to animations.

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.

Creates and returns a new HTMLAudioElement which can be either attached to a document for the user to interact with and/or listen to, or can be used offscreen to manage and play audio.

The AudioBuffer interface represents a short audio asset residing in memory, created from an audio file using the AudioContext.decodeAudioData() method, or from raw data using AudioContext.createBuffer(). Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode.

Objects of these types are designed to hold small audio snippets, typically less than 45 s. For longer sounds, objects implementing the MediaElementAudioSourceNode are more suitable.

The buffer contains data in the following format: non-interleaved IEEE754 32-bit linear PCM with a nominal range between -1 and +1, that is, 32bits floating point buffer, with each samples between -1.0 and 1.0. If the AudioBuffer has multiple channels, they are stored in separate buffer.

AudioBufferSourceNode has no input and exactly one output. The number of channels in the output corresponds to the number of channels of the AudioBuffer that is set to the AudioBufferSourceNode.buffer property. If there is no buffer set—that is, if the attribute's value is NULL—the output contains one channel consisting of silence. An AudioBufferSourceNode can only be played once; that is, only one call to AudioBufferSourceNode.start() is allowed. If the sound needs to be played again, another AudioBufferSourceNode has to be created. Those nodes are cheap to create, and AudioBuffers can be reused across plays. It is often said that AudioBufferSourceNodes have to be used in a "fire and forget" fashion: once it has been started, all references to the node can be dropped, and it will be garbage-collected automatically.

Multiple calls to AudioBufferSourceNode.stop() are allowed. The most recent call replaces the previous one, granted the AudioBufferSourceNode has not already reached the end of the buffer.

• Number of inputs: 0
• Number of outputs: 1
• Channel count: defined by the associated AudioBuffer

The AudioContext interface represents an audio-processing graph built from audio modules linked together, each represented by an AudioNode. An audio context controls both the creation of the nodes it contains and the execution of the audio processing, or decoding. You need to create an AudioContext before you do anything else, as everything happens inside a context.

An AudioContext can be a target of events, therefore it implements the EventTarget interface.

The AudioDestinationNode interface represents the end destination of an audio graph in a given context — usually the speakers of your device. It can also be the node that will "record" the audio data when used with an OfflineAudioContext.

AudioDestinationNode has no output (as it is the output, no more AudioNode can be linked after it in the audio graph) and one input. The amount of channels in the input must be between 0 and the maxChannelCount value or an exception is raised.

The AudioDestinationNode of a given AudioContext can be retrieved using the AudioContext.destination property.

• Number of inputs: 1
• Number of outputs: 0
• Channel count mode: "explicit"
• Channel count: 2
• Channel interpretation: "speakers"

The AudioListener interface represents the position and orientation of the unique person listening to the audio scene, and is used in audio spatialisation. All PannerNodes spatialise in relation to the AudioListener stored in the AudioContext.listener attribute.

It is important to note that there is only one listener per context and that it isn't an AudioNode.

The AudioNode interface is a generic interface for representing an audio processing module like an audio source (e.g. an HTML <audio> or <video> element, an OscillatorNode, etc.), the audio destination, intermediate processing module (e.g. a filter like BiquadFilterNode or ConvolverNode), or volume control (like GainNode).

An AudioNode has inputs and outputs, each with a given amount of channels. An AudioNode with zero inputs and one or multiple outputs is called a source node. The exact processing done varies from one AudioNode to another but, in general, a node reads its inputs, does some audio-related processing, and generates new values for its outputs, or simply lets the audio pass through (for example in the AnalyserNode, where the result of the processing is accessed separately).

Different nodes can be linked together to build a processing graph. Such a graph is contained in an AudioContext. Each AudioNode participates in exactly one such context. In general, processing nodes inherit the properties and methods of AudioNode, but also define their own functionality on top. See the individual node pages for more details, as listed on the Web Audio API homepage.

The AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). An AudioParam can be set to a specific value or a change in value, and can be scheduled to happen at a specific time and following a specific pattern.

There are two kinds of AudioParam, a-rate and k-rate parameters:

• An a-rate AudioParam takes the current audio parameter value for each sample frame of the audio signal.
• A k-rate AudioParam uses the same initial audio parameter value for the whole block processed, that is 128 sample frames.

Each AudioNode defines which of its parameters are a-rate or k-rate in the spec.

Each AudioParam has a list of events, initially empty, that define when and how values change. When this list is not empty, changes using the AudioParam.value attributes are ignored. This list of events allows us to schedule changes that have to happen at very precise times, using arbitrary timelime-based automation curves. The time used is the one defined in AudioContext.currentTime.

The BiquadFilterNode interface represents a simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. A BiquadFilterNode always has exactly one input and one output.

• Number of inputs: 1
• Number of outputs: 1
• Channel count mode: "max"
• Channel count: 2 (not used in the default count mode)
• Channel interpretation: "speakers"

A Blob object represents a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a ReadableStream so its methods can be used for processing the data. Blobs can 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.

To construct a Blob from other non-blob objects and data, use the Blob() constructor. To create a blob that contains a subset of another blob's data, use the slice() method. To obtain a Blob object for a file on the user's file system, see the File documentation.

The APIs accepting Blob objects are also listed in the File documentation.

See body interface in whatwg Fetch spec.

see also Body in MDN

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, except the object that sent the message.

A CDATA Section can be used within XML to include extended portions of unescaped text, such that the symbols < and & do not need escaping as they normally do within XML when used as text.

As a CDATASection has no properties or methods unique to itself and only directly implements the Text interface, one can refer to Text to find its properties and methods.

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

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 is an object 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).

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 is an object representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE).

An object implementing the CSSRule DOM interface represents a single CSS at-rule. References to a CSSRule-implementing object may be obtained by looking at a CSS style sheet's cssRules list.

A CSSRuleList is an array-like object containing an ordered collection of CSSRule objects.

A CSSStyleDeclaration is an interface to the declaration block returned by the style property of a cssRule in a stylesheet, when the rule is a CSSStyleRule.

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

An object implementing the CSSStyleSheet interface represents a single CSS style sheet.

See ¶5.4 cache of ServiceWorker whatwg spec.

See ¶5.4 cache of ServiceWorker whatwg spec.

See ¶5.5 cache of ServiceWorker whatwg spec.

The CanvasGradient interface represents an opaque object describing a gradient and returned by CanvasRenderingContext2D.createLinearGradient or CanvasRenderingContext2D.createRadialGradient methods.

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

see ¶4.12.4.1 Proxying canvases to workers in whatwg html spec.

The 2D rendering context for the drawing surface of a <canvas> element. To get this object, call getContext() on a <canvas>, supplying "2d" as the argument:

The ChannelMergerNode interface, often used in conjunction with its opposite, ChannelSplitterNode, reunites different mono inputs into a single output. Each input is used to fill a channel of the output. This is useful for accessing each channels separately, e.g. for performing channel mixing where gain must be separately controlled on each channel.

If ChannelMergerNode has one single output, but as many inputs as there are channels to merge; the amount of inputs is defined as a parameter of its constructor and the call to AudioContext.createChannelMerger. In the case that no value is given, it will default to 6.

Using a ChannelMergerNode, it is possible to create outputs with more channels than the rendering hardware is able to process. In that case, when the signal is sent to the AudioContext.listener object, supernumerary channels will be ignored.

• Number of inputs: variable; default to 6.
• Number of outputs: 1
• Channel count mode: "max"
• Channel count: 2 (not used in the default count mode)
• Channel interpretation: "speakers"

The ChannelSplitterNode interface, often used in conjunction with its opposite, ChannelMergerNode, separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g. for performing channel mixing where gain must be separately controlled on each channel.

If your ChannelSplitterNode always has one single input, the amount of outputs is defined by a parameter on its constructor and the call to AudioContext.createChannelSplitter(). In the case that no value is given, it will default to 6. If there are less channels in the input than there are outputs, supernumerary outputs are silent.

• Number of inputs: 1
• Number of outputs: variable; default to 6.
• Channel count mode: "max"
• Channel count: 2 (not used in the default count mode)
• Channel interpretation: "speakers"

The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any object of type CharacterData: it is implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't abstract.

See ¶2 Model but mostly the examples in the whatwg streams spec

¶4.2 Client of Service Workers 1 spec.

¶4.2 Client of Service Workers 1 spec.

See ¶4.3 clients of ServiceWorker whatwg spec.

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. The Clipboard API can be used to implement cut, copy, and paste features within a web application.

The system clipboard is exposed through the global Navigator.clipboard property

Clipboard is based on the EventTarget interface, and includes its methods.

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

A clipboard item is conceptually data that the user has expressed a desire to make shareable by invoking a "cut" or "copy" command

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.

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.

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

An API for compressing a stream of data.

The console object provides access to the browser's debugging console. The specifics of how it works vary from browser to browser, but there is a de facto set of features that are typically provided.

The ConvolverNode interface is an AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. A ConvolverNode always has exactly one input and one output.

Note: For more information on the theory behind Linear Convolution, see the W3C Web Audio API spec section, Linear Effects Using Convolution, or read the The Wikipedia Linear Convolution Article.

• Number of inputs: 1
• Number of outputs: 1
• Channel count mode: "clamped-max"
• Channel count: 2
• Channel interpretation: "speakers"

The Coordinates interface represents the position and attitude of the device on Earth, as well as the accuracy with which these data are computed.

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.

The CryptoKey object represents an opaque reference to keying material that is managed by the user agent.

defined at ¶13 The CryptoKey Interface

The CryptoKeyPair dictionary represents an asymmetric key pair that is comprised of both public and private keys. defined at ¶17 CryptoKeyPair dictionary of spec

The CustomElementRegistry interface provides methods for registering custom elements and querying registered elements. To get an instance of it, use the window.customElements property.

The DOM CustomEvent are events initialized by an application for any purpose.

The DOMException interface represents an anormal event happening when a method or a property is used.

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.

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

You can perform the opposite operation—converting a DOM tree into XML or HTML source—using the XMLSerializer interface.

In the case of an HTML document, you can also replace portions of the DOM with new DOM trees built from HTML by setting the value of the Element.innerHTML and outerHTML properties. These properties can also be read to fetch HTML fragments corresponding to the corresponding DOM subtree.

Note that XMLHttpRequest can parse XML and HTML directly from a URL-addressable resource, returning a Document in its response property.

A DOMRect describes the size and position of a rectangle.

A type returned by DOMConfiguration.parameterNames which contains a list of DOMString (strings).

This type represents a set of space-separated tokens. Commonly returned by HTMLElement.classList, HTMLLinkElement.relList, HTMLAnchorElement.relList or HTMLAreaElement.relList. It is indexed beginning with 0 as with JavaScript arrays. DOMTokenList is always case-sensitive.

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 Drag and Drop.

This object is available from the dataTransfer property of all drag events. It cannot be created separately.

Each DataTransferItem object is associated with a DataTransfer object.

A list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a dataTransfer property and that property is a DataTransferItemList.

An API for decompressing a stream of data.

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.

The DelayNode interface represents a delay-line; an AudioNode audio-processing module that causes a delay between the arrival of an input data and its propagation to the output. A DelayNode always has exactly one input and one output, both with the same amount of channels.

When creating a graph that has a cycle, it is mandatory to have at least one DelayNode in the cycle, or the nodes taking part in the cycle will be muted.

• Number of inputs: 1
• Number of outputs: 1
• Channel count mode: "max"
• Channel count: 2 (not used in the default count mode)
• Channel interpretation: "speakers"

Each web page loaded in the browser has its own document object. The Document interface serves as an entry point to the web page's content (the DOM tree, including elements such as <body> and <table>) and provides functionality global to the document (such as obtaining the page's URL and creating new elements in the document).

The DocumentFragment interface represents a minimal document object that has no parent. It is used as a light-weight version of Document to store well-formed or potentially non-well-formed fragments of XML.

The DocumentType interface represents a Node containing a doctype.

When dragging, there are several operations that may be performed. The copy operation is used to indicate that the data being dragged will be copied from its present location to the drop location. The move operation is used to indicate that the data being dragged will be moved, and the link operation is used to indicate that some form of relationship or connection will be created between the source and drop locations.

You can specify which of the three operations are allowed for a drag source by setting the effectAllowed property within a dragstart event listener.

Note that these values must be used exactly as defined below.

https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Drag_operations#drageffects

The DynamicsCompressorNode interface provides a compression effect, which lowers the volume of the loudest parts of the signal in order to help prevent clipping and distortion that can occur when multiple sounds are played and multiplexed together at once. This is often used in musical production and game audio. DynamicsCompressorNode is an AudioNode that has exactly one input and one output; it is created using the AudioContext.createDynamicsCompressor method.

• Number of inputs: 1
• Number of outputs: 1
• Channel count mode: "explicit"
• Channel count: 2
• Channel interpretation: "speakers"

The Element interface represents part of the document. This interface describes methods and properties common to each kind of elements. Specific behaviors are described in the specific interfaces, inheriting from Element: the HTMLElement interface for HTML elements, or the SVGElement interface for SVG elements.

https://developer.mozilla.org/en-US/docs/Web/API/element

An ElementDefinitionOptions object represents additional options associated with CustomElementRegsitry.define.

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

Event handlers may be attached to various objects including DOM elements, document, the window object, etc. When an event occurs, an event object is created and passed sequentially to the event listeners.

The DOM Event interface is accessible from within the handler function, via the event object passed as the first argument. The following simple example shows how an event object is passed to the event handler function, and can be used from within one such function.

An options object that specifies characteristics about the event listener.

EventSource enables servers to push data to Web pages over HTTP or using dedicated server-push protocols. Event streams requests can be redirected using HTTP 301 and 307 redirects as with normal HTTP requests. Clients will reconnect if the connection is closed; a client can be told to stop reconnecting using the HTTP 204 No Content response code. W3C 2012

Provides options to configure the new connection.

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

Element, document, and window are the most common event targets, but other objects can be event targets too, for example XMLHttpRequest, AudioNode, AudioContext and others.

Many event targets (including elements, documents, and windows) also support setting event handlers via on... properties and attributes.

See ¶4.4 ExtendableEvent of whatwg ServiceWorker spec.

An ExtendableEvent object has an associated extend lifetime promises (an array of promises). It is initially set to null.

Service workers define the extendable message event that extends the message event defined in HTML to allow extending the lifetime of the event.

See FetchEvent on MDN

¶4.5 FetchEvent on whatwg ServiceWorker spec.

The File interface provides information about -- and access to the contents of -- files.

These are generally retrieved from a FileList object returned as a result of a user selecting files using the input element, or from a drag and drop operation's DataTransfer object.

The file reference can be saved when the form is submitted while the user is offline, so that the data can be retrieved and uploaded when the Internet connection is restored.

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.

An options object containing optional attributes for the file.

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.

The FileReaderSync interface allows to read File or Blob objects synchronously.

This interface is only available in workers as it enables synchronous I/O that could potentially block.

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

XMLHttpRequest Level 2 adds support for the new FormData interface. FormData objects provide 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.

part of ServiceWorker ¶4.2.2 frameType of serviceWorker spec

A frozen array type is a parameterized type whose values are references to objects that hold a fixed length array of unmodifiable values. The values in the array are of type T.

Since FrozenArray values are references, they are unlike sequence types, which are lists of values that are passed by value.

The GainNode interface represents a change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels.

The gain is a unitless value, changing with time, that is multiplied to each corresponding sample of all input channels. If modified, the new gain is applied using a de-zippering algorithm in order to prevent unaesthetic 'clicks' from appearing in the resulting audio.

The GainNode is increasing the gain of the output.

• Number of inputs: 1
• Number of outputs: 1
• Channel count mode: "max"
• Channel count: 2 (not used in the default count mode)
• Channel interpretation: "speakers"

Represents the state of a connected gamepad device.

Represents the state of a button.

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 offer customized results based on the user's location.

An object containing options to filter the notifications returned.

The HTMLAnchorElement interface represents hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface they also have available to them by inheritance) 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. It derives from the HTMLMediaElement interface.

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

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.

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

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.

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.

HTMLCollection is an interface representing a generic collection of elements (in document order) and offers methods and properties for traversing the list.

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.

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 HTMLDialogElement interface provides methods to manipulate <dialog> elements. It inherits properties and methods from the HTMLElement interface.

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

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

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

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

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

It represents the lists returned by the HTMLFormElement interface's elements property and the HTMLFieldSetElement interface's elements property.

This interface replaces one method from HTMLCollection, on which it is based.

The HTMLFormElement interface provides methods to create and modify <form> elements; it inherits from properties and methods of the HTMLElement interface.

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

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

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.

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

The HTMLInputElement 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 input elements.

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

The HTMLLabelElement interface gives access to properties specific to <label> elements. It inherits from HTMLElement.

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

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.

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 HTMLMediaElement interface has special properties and methods (beyond the properties and methods available for all children of HTMLElement), that are common to all media-related objects.

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

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 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 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 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 classes and methods of the HTMLElement interface.

The HTMLOptionsCollection interface represents a collection of HTML elements (in document order) and offers methods and properties for selecting from the list as well as optionally altering its items. This object is returned only by the options property of select.

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

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.

DOM Script objects expose the HTMLScriptElement (or HTML 4 HTMLScriptElement) interface, which provides special properties and methods (beyond the regular element object interface they also have available to them by inheritance) for manipulating the layout and presentation of <script> elements.

DOM select elements share all of the properties and methods of other HTML elements described in the element section. They also have the specialized interface HTMLSelectElement (or HTML 4 HTMLSelectElement).

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. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle.

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

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.

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