The AbortSignal interface represents a signal object that allows
to communicate with a DOM request (such as a Fetch) and abort
if required via an `web.dom.AbortController` object.

AbortSignal Events.

The Accelerometer interface of the Sensor APIs provides on each
the acceleration applied to the device along all three axes.

web.accelerometer interfaces.

The LinearAccelerationSensor interface of the Sensor APIs provides
each reading the acceleration applied to the device along all
axes, but without the contribution of gravity.

The AmbientLightSensor interface of the the Sensor APIs returns
current light level or illuminance of the ambient light around
hosting device.

web.ambient interfaces.

The DeviceLightEvent provides web developers with information
photo sensors or similiar detectors about ambient light levels
the device. For example this may be useful to adjust the screen's
based on the current ambient light level in order to save energy
provide better readability.

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

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

The AnimationEvent interface represents events providing information
to animations.

The AnimationPlaybackEvent interface of the Web Animations API
animation events.

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

web.animation interfaces.

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

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

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

web.ar interfaces.

The XR interface of the WebXR Device API provides methods for
an `web.ar.XRSession` object. Once a session is obtained, subsequent
or VR interactions with the hardware are done through it.

XR Events.

The XRFrame interface of the WebXR Device API provides information
to render a single frame of an AR/VR scene to the display. An
of this object is passed to each call of the callback provided
`XRSession.requestAnimationFrame`.

The XRInputSource interface of the WebXR Device API returns information
the Web AR/VR control device being used. The control device is
and defines a primary action. A primary action is a trigger,
button, spoken command, or hand gesture that when performed produces
`selectend`, and `select` events.

The XRSession of the WebXR Device API provides the means to interact
an AR/VR device, providing features such as polling the viewer
(viewer pose), getting information about the user's environment,
presenting imagery to the user. To get an XRSession call XR.requestSession().

The Attr interface represents one of a DOM element's attributes
an object. In most DOM methods, you will directly retrieve the
as a string (e.g., `Element.getAttribute()`), but certain functions
`Element.getAttributeNode()`) or means of iterating return Attr

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

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

The AudioBufferSourceNode interface is an `web.audio.AudioScheduledSourceNode`
represents an audio source consisting of in-memory audio data,
in an `web.audio.AudioBuffer`. It's especially useful for playing
audio which has particularly stringent timing accuracy requirements,
as for sounds that must match a specific rhythm and can be kept
memory rather than being played from disk or the network.

The AudioContext interface represents an audio-processing graph
from audio modules linked together, each represented by an `web.audio.AudioNode`.

The AudioContextOptions dictionary is used to specify configuration
when constructing a new `web.audio.AudioContext` object to represent
graph of web audio nodes.

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

The AudioListener interface represents the position and orientation
the unique person listening to the audio scene, and is used in
spatialization. All `web.audio.PannerNode`s spatialize in relation
the AudioListener stored in the `BaseAudioContext.listener` attribute.

The AudioNode interface is a generic interface for representing
audio processing module. Examples include:

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

The AudioParamDescriptor dictionary of the Web Audio API specifies
for an `web.audio.AudioParam` objects.

The Web Audio API interface AudioParamMap represents a set of
audio parameters, each described as a mapping of a `web.dom.DOMString`
the parameter to the `web.audio.AudioParam` object representing
value.

The AudioScheduledSourceNode interface—part of the Web Audio
a parent interface for several types of audio source node interfaces
share the ability to be started and stopped, optionally at specified
Specifically, this interface defines the `start()` and `stop()`
as well as the `onended` event handler.

AudioScheduledSourceNode Events.

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

The AudioTrackList interface is used to represent a list of the
tracks contained within a given HTML media element, with each
represented by a separate `web.audio.AudioTrack` object in the

AudioTrackList Events.

The AudioWorkletGlobalScope interface of the Web Audio API represents
global execution context for user-supplied code, which defines
`web.audio.AudioWorkletProcessor`-derived classes. Each `web.audio.BaseAudioContext`
a single `web.audio.AudioWorklet` available under the `audioWorklet`
which runs its code in a single AudioWorkletGlobalScope.

The AudioWorkletNode interface of the Web Audio API represents
base class for a user-defined `web.audio.AudioNode`, which can
connected to an audio routing graph along with other nodes. It
an associated `web.audio.AudioWorkletProcessor`, which does the
audio processing in a Web Audio rendering thread.

The AudioWorkletNodeOptions dictionary of the Web Audio API is
to specify configuration options when constructing a new `web.audio.AudioWorkletNode`
for custom audio processing.

The AudioWorkletProcessor interface of the Web Audio API represents
audio processing code behind a custom `web.audio.AudioWorkletNode`.
lives in the `web.audio.AudioWorkletGlobalScope` and runs on
Web Audio rendering thread. In turn, an `web.audio.AudioWorkletNode`
on it runs on the main thread.

The BaseAudioContext interface of the Web Audio API acts as a
definition for online and offline audio-processing graphs, as
by `web.audio.AudioContext` and `web.audio.OfflineAudioContext`

The BiquadFilterNode interface represents a simple low-order
and is created using the `AudioContext.createBiquadFilter()`
It is an `web.audio.AudioNode` that can represent different kinds
filters, tone control devices, and graphic equalizers.

The BlobEvent interface represents events associated with a `web.files.Blob`.
blobs are typically, but not necessarily, associated with media

The ConstantSourceNode interface—part of the Web Audio API—represents
audio source (based upon `web.audio.AudioScheduledSourceNode`)
output is single unchanging value. This makes it useful for cases
which you need a constant value coming in from an audio source.
addition, it can be used like a constructible `web.audio.AudioParam`
automating the value of its `offset` or by connecting another
to it; see Controlling multiple parameters with ConstantSourceNode.

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

web.audio interfaces.

The DelayNode interface represents a delay-line; an `web.audio.AudioNode`
module that causes a delay between the arrival of an input data
its propagation to the output.

The DisplayMediaStreamConstraints dictionary is used to specify
or not to include video and/or audio tracks in the `web.streams.MediaStream`
be returned by `getDisplayMedia()`, as well as what type of processing
be applied to the tracks.

Inherits properties from its parent, `web.audio.AudioNode`.

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

The HTMLAudioElement interface provides access to the properties
`<audio>` elements, as well as methods to manipulate them. It
from the `web.media.HTMLMediaElement` interface.

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

The MediaCapabilities interface of the Media Capabilities API
information about the decoding abilities of the device, system
browser. The API can be used to query the browser about the decoding
of the device based on codecs, profile, resolution, and bitrates.
information can be used to serve optimal media streams to the
and determine if playback should be smooth and power efficient.

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

The MediaDevices interface provides access to connected media
devices like cameras and microphones, as well as screen sharing.
essence, it lets you obtain access to any hardware source of
data.

MediaDevices Events.

The MediaError interface represents an error which occurred while
media in an HTML media element based on `web.media.HTMLMediaElement`,
as `<audio>` or `<video>`.

The MediaKeys interface of EncryptedMediaExtensions API represents
set of keys that an associated `web.media.HTMLMediaElement` can
for decryption of media data during playback.

The MediaKeySession interface of the EncryptedMediaExtensions
represents a context for message exchange with a content decryption
(CDM).

The MediaKeySystemAccess interface of the EncryptedMediaExtensions
provides access to a Key System for decryption and/or a content
provider. You can request an instance of this object using the
method.

The MediaMetadata interface of the the Media Session API provides
a web page to provide rich media metadata for display in a platform

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

MediaRecorder Events.

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

The MediaSession interface of the Media Session API allows a
page to provide custom behaviors for standard media playback

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

Inherits properties from its parent, `web.audio.AudioNode`.

The MediaStreamAudioSourceNode interface is a type of `web.audio.AudioNode`
operates as an audio source whose media is received from a `web.streams.MediaStream`
using the WebRTC or Media Capture and Streams APIs.

The MediaStreamAudioSourceOptions dictionary provides configuration
used when creating a `web.audio.MediaStreamAudioSourceNode` using
constructor.

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

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

MediaStreamTrack Events.

The MediaStreamTrackAudioSourceOptions dictionary is used when
options to the `MediaStreamTrackAudioSourceNode()` constructor.

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

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

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

OfflineAudioContext Events.

The OscillatorNode interface represents a periodic waveform,
as a sine wave. It is an `web.audio.AudioScheduledSourceNode`
module that causes a specified frequency of a given wave to be
effect, a constant tone.

The OverconstrainedError interface of the Media Capture and Streams
indicates that the set of desired capabilities for the current
cannot currently be met. When this event is thrown on a MediaStreamTrack,
is muted until either the current constraints can be established
until satisfiable constraints are applied.

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

Listen to these events using `addEventListener()` or by assigning
event listener to the oneventname property of this interface.

RTCDTMFSender Events.

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

RTCIceTransport Events.

The RTCPeerConnection interface represents a WebRTC connection
the local computer and a remote peer. It provides methods to
to a remote peer, maintain and monitor the connection, and close
connection once it's no longer needed.

RTCPeerConnection Events.

The RTCRtpSender interface provides the ability to control and
details about how a particular `web.audio.MediaStreamTrack` is
and sent to a remote peer.

The RTCSessionDescription interface describes one end of a connection—or
connection—and how it's configured. Each RTCSessionDescription
of a description `type` indicating which part of the offer/answer
process it describes and of the SDP descriptor of the session.

The SourceBuffer interface represents a chunk of media to be
into an `web.media.HTMLMediaElement` and played, via a `web.audio.MediaSource`
This can be made up of one or several media segments.

The SourceBufferList interface represents a simple container
for multiple `web.audio.SourceBuffer` objects.

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

The TrackDefault interface provides a `web.audio.SourceBuffer`
kind, label, and language information for tracks that do not
this information in the initialization segments of a media chunk.

The TrackDefaultList interface represents a simple container
for multiple `web.audio.TrackDefault` objects.

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

A WaveShaperNode always has exactly one input and one output.

The AuthenticatorAssertionResponse interface of the Web Authentication
is returned by `CredentialsContainer.get()` when a `web.auth.PublicKeyCredential`
passed, and provides proof to a service that it has a key pair
that the authentication request is valid and approved.

The AuthenticatorAttestationResponse interface of the Web Authentication
is returned by `CredentialsContainer.create()` when a `web.auth.PublicKeyCredential`
passed, and provides a cryptographic root of trust for the new
pair that has been generated. This response should be sent to
relying party's server to complete the creation of the credential.

The AuthenticatorResponse interface of the Web Authentication
is the base interface for interfaces that provide a cryptographic
of trust for a key pair. The child interfaces include information
the browser such as the challenge origin and either may be returned
`PublicKeyCredential.response`.

web.auth interfaces.

The PublicKeyCredential interface provides information about
public key / private key pair, which is a credential for logging
to a service using an un-phishable and data-breach resistant
key pair instead of a password. It inherits from `web.credential.Credential`,
was created by the Web Authentication API extension to the Credential
API. Other interfaces that inherit from `web.credential.Credential`
`web.credential.PasswordCredential` and `web.credential.FederatedCredential`.

The PublicKeyCredentialCreationOptions dictionary of the Web
API holds options passed to `navigators.credentials.create()`
order to create a `web.auth.PublicKeyCredential`.

The PublicKeyCredentialRequestOptions dictionary of the Web Authentication
holds the options passed to `navigator.credentials.get()` in
to fetch a given `web.auth.PublicKeyCredential`.

The Bluetooth interface of the Web Bluetooth API returns a `js.Promise`
a `web.bluetooth.BluetoothDevice` object with the specified options.

The BluetoothDevice interface of the Web Bluetooth API provides
data about a particular Bluetooth device.

The BluetoothCharacteristicProperties interface of the the Web
API provides an object provides propertieds of a particular BluetoothRemoteGATTCharacteristic.

The BluetoothDevice interface of the Web Bluetooth API represents
Bluetooth device inside a particular script execution environment.

The BluetoothRemoteGattCharacteristic interface of the Web Bluetooth
represents a GATT Characteristic, which is a basic data element
provides further information about a peripheral’s service.

The BluetoothRemoteGATTDescriptor interface of the Web Bluetooth
provides a GATT Descriptor, which provides further information
a characteristic’s value.

The BluetoothRemoteGATTServer interface of the Web Bluetooth
represents a GATT Server on a remote device.

The BluetoothRemoteGATTService interface of the Web Bluetooth
represents a service provided by a GATT server, including a device,
list of referenced services, and a list of the characteristics
this service.

web.bluetooth interfaces.

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

BroadcastChannel Events.

web.broadcast interfaces.

The BudgetService interface of the Web Budget API provides a
interface to the user agent’s budget service. It is available
both document and worker environments.

The BudgetState interface of the the Web Budget API provides
amount of the user agent's processing budget at a specific point
time.

web.budget interfaces.

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

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

The CanvasRenderingContext2D interface, part of the Canvas API,
the 2D rendering context for the drawing surface of a `<canvas>`
It is used for drawing shapes, text, images, and other objects.

web.canvas interfaces.

The HTMLCanvasElement interface provides properties and methods
manipulating the layout and presentation of `<canvas>` elements.
HTMLCanvasElement interface also inherits the properties and
of the `web.dom.HTMLElement` interface.

HTMLCanvasElement Events.

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

The ImageBitmapRenderingContext interface is a canvas rendering
that provides the functionality to replace the canvas's contents
the given `web.canvas.ImageBitmap`. Its context id (the first
to `HTMLCanvasElement.getContext()` or `OffscreenCanvas.getContext()`)
\"bitmaprenderer\".

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

The OffscreenCanvas interface provides a canvas that can be rendered
screen. It is available in both the window and worker contexts.

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

The TextMetrics interface represents the dimensions of a piece
text in the canvas, as created by the `CanvasRenderingContext2D.measureText()`

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

The ChildNode interface contains methods that are particular
`web.Node` objects that can have a parent.

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

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

web.clipboard interfaces.

web interfaces.

web.credential interfaces.

The Credential interface of the the Credential Management API
information about an entity as a prerequisite to a trust decision.

The CredentialsContainer interface of the the Credential Management
exposes methods to request credentials and notify the user agent
events such as successful sign in or sign out happen. This interface
accessible from `Navigator.credentials`.

The FederatedCredential interface of the the Credential Management
provides information about credentials from a federated identity
A federated identity provider is an entity that a website trusts
correctly authenticate a user, and that provides an API for that
OpenID Connect is an example of a federated identity provider

The interface of the Credential Management API provides information
a username/password pair. In supporting browsers an instance
this class may be passed in the credential member of the init
for global `fetch`.

The AesCbcParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
`SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()`, or `SubtleCrypto.unwrapKey()`,
using the AES-CBC algorithm.

The AesCtrParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
`SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()`, or `SubtleCrypto.unwrapKey()`,
using the AES-CTR algorithm.

The AesGcmParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
`SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()`, or `SubtleCrypto.unwrapKey()`,
using the AES-GCM algorithm.

See the examples for `SubtleCrypto.generateKey()`.

web.crypto interfaces.

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

The CryptoKey interface of the Web Crypto API represents a cryptographic

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

The EcdhKeyDeriveParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
when using the ECDH algorithm.

The EcdsaParams dictionary of the Web Crypto API represents the
that should be passed as the algorithm parameter into `SubtleCrypto.sign()`
`SubtleCrypto.verify()` when using the ECDSA algorithm.

The EcKeyGenParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
when generating any elliptic-curve-based key pair: that is, when
algorithm is identified as either of ECDSA or ECDH.

See the examples for `SubtleCrypto.importKey()`.

See the examples for `SubtleCrypto.deriveKey()`.

The HmacImportParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
or `SubtleCrypto.unwrapKey()`, when generating a key for the
algorithm.

The HmacKeyGenParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
when generating a key for the HMAC algorithm.

The Pbkdf2Params dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
when using the PBKDF2 algorithm.

The RsaHashedImportParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
or `SubtleCrypto.unwrapKey()`, when importing any RSA-based key
that is, when the algorithm is identified as any of RSASSA-PKCS1-v1_5,
or RSA-OAEP.

The RsaHashedKeyGenParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
when generating any RSA-based key pair: that is, when the algorithm
identified as any of RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP.

The RsaOaepParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
`SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()`, or `SubtleCrypto.unwrapKey()`,
using the RSA_OAEP algorithm.

The RsaPssParams dictionary of the Web Crypto API represents
object that should be passed as the algorithm parameter into
or `SubtleCrypto.verify()`, when using the RSA-PSS algorithm.

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

web.css interfaces.

The CSSCounterStyleRule interface represents an `@counter-style`

The CSSKeywordValue interface of the the CSS Typed Object Model
creates an object to represent CSS keywords and other identifiers.

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

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

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

The CSSPositionValue interface of the the CSS Typed Object Model
represents values for properties that take a position, for example

The CSSPrimitiveValue interface derives from the `web.css.CSSValue`
and represents the current computed value of a CSS property.

The CSSPseudoElement interface represents a pseudo-element that
be the target of an event or animated using the Web Animations
Instances of this interface may be obtained by calling `Element.pseudo()`.

The CSSStyleValue interface of the the CSS Typed Object Model
is the base class of all CSS values accessible through the Typed
API. An instance of this class may be used anywhere a string
expected.

The CSSUnitValue interface of the CSS Typed Object Model API
values that contain a single unit type. For example, \"42px\"
be represented by a CSSNumericValue.

The CSSUnparsedValue interface of the CSS Typed Object Model
represents property values that reference custom properties.
consists of a list of string fragments and variable references.

The CSSValue interface represents the current computed value
a CSS property.

The CSSValueList interface derives from the `web.css.CSSValue`
and provides the abstraction of an ordered collection of CSS

The CSSVariableReferenceValue interface of the CSS Typed Object
API allows you to create a custom name for a built-in CSS value.
object functionality is sometimes called a \"CSS variable\" and
the same purpose as the `var()` function. The custom name must
with two dashes.

The PaintWorklet interface of the CSS Painting API programmatically
an image where a CSS property expects a file. Access this interface
`CSS.paintWorklet`.

Point is an interface, which existed only briefly in the CSS
Level 1 specification, which represents a point in 2-dimensional
It is non-standard, not broadly compatible, and should not be

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

The StylePropertyMapReadOnly interface of the the CSS Typed Object
API provides a read-only representation of a CSS declaration
that is an alternative to `web.cssdom.CSSStyleDeclaration`. Retrieve
instance of this interface using `Element.computedStyleMap()`.

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

web.cssdom interfaces.

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

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

The CSSKeyframeRule interface describes an object representing
set of style for a given keyframe. It corresponds to the contains
a single keyframe of a `@keyframes` at-rule. It implements the
interface with a type value of 8 (CSSRule.KEYFRAME_RULE).

The CSSKeyframesRule interface describes an object representing
complete set of keyframes for a CSS animation. It corresponds
the contents of a whole `@keyframes` at-rule. It implements the
interface with a type value of 7 (CSSRule.KEYFRAMES_RULE).

The CSSMediaRule interface represents a single CSS `@media` rule.
implements the `web.cssdom.CSSConditionRule` interface, and therefore
`web.cssdom.CSSGroupingRule` and the `web.cssdom.CSSRule` interface
a type value of 4 (CSSRule.MEDIA_RULE).

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

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

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

The CSSStyleDeclaration interface represents an object that is
CSS declaration block, and exposes style information and various
methods and properties.

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

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

The GeometryUtils interface provides different utility function
retrieve geometry information about DOM nodes.

The LinkStyle interface provides access to the associated CSS
sheet of a node.

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

MediaQueryList Events.

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

The ScrollToOptions dictionary of the CSSOM View spec contains
specifying where an element should be scrolled to, and whether
scrolling should be smooth.

An object implementing the StyleSheet interface represents a
style sheet. CSS style sheets will further implement the more
`web.cssdom.CSSStyleSheet` interface.

The TransitionEvent interface represents events providing information
to transitions.

This interface inherits properties from its parent, `web.event.Event`:

web.deprecated interfaces.

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

The HTMLContentElement interface represents a `<content>` HTML
which is used in Shadow DOM.

The HTMLMarqueeElement interface provides methods to manipulate
elements.

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

The non-standard, obsolete, NotifyAudioAvailableEvent interface
the event sent to audio elements when the audio buffer is full.

NotifyAudioAvailableEvent Events.

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

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

Returns an interface to register or unregister a push registration,
an active registration, or check the permission status of the
This interface has been superceded by `web.service-workers.PushManager`.

The ScriptProcessorNode interface allows the generation, processing,
analyzing of audio using JavaScript.

ScriptProcessorNode Events.

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

The SVGAltGlyphElement interface represents an `<altglyph>` element.
interface makes it possible to implement more sophisticated and
glyph characters. For some textal representations as: ligatures
æ, ß, etc ), special-purpose fonts (e.g. musical symbols) or
alternate glyphs such as Asian text strings it is required that
different set of glyphs be used than the normal given character

The SVGColorProfileElement interface corresponds to the `<color-profile>`

The SVGExternalResourcesRequired interface defines an interface
applies to all elements where this element or one of its descendants
reference an external resource.

The SVGGlyphRefElement interface corresponds to the `<glyphRef>`

Many of SVG's graphics operations utilize 2x3 matrices of the

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

web.device interfaces.

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

web.divice interfaces.

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

The DeviceProximityEvent interface provides information about
distance of a nearby physical object using the proximity sensor
a device.

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

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

Document Events.

The DocumentType interface represents a `web.Node` containing
doctype.

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

web.dom interfaces.

Pre-defined parameters: \"canonical-form\", \"cdata-sections\",
\"comments\", \"datatype-normalization\", \"element-content-whitespace\",
\"error-handler\", \"infoset\", \"namespaces\", \"namespace-declarations\",
\"schema-type\", \"split-cdata-sections\", \"validate\", \"validate-if-schema\",

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

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

Returned by `DOMImplementationSource.getDOMImplementationList()`
`DOMImplementationRegistry.getDOMImplementationList()` . Can
iterated with 0-based index.

Indicates a location such as where an error occurred. Returned
DOMError.location.

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

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

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

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

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

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

A DOMRect represents a rectangle.

The DOMRectReadOnly interface specifies the standard properties
by `web.dom.DOMRect` to define a rectangle.

A type returned by some APIs which contains a list of DOMString

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

The DOMTokenList interface represents a set of space-separated
Such a set is returned by `Element.classList`, `HTMLLinkElement.relList`,
`HTMLAreaElement.relList`, `HTMLIframeElement.sandbox`, or `HTMLOutputElement.htmlFor`.
is indexed beginning with 0 as with JavaScript `js.Array` objects.
is always case-sensitive.

The GlobalEventHandlers mixin describes the event handlers common
several interfaces like `web.dom.HTMLElement`, `web.Document`,
`web.Window`.

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

The HTMLAnchorElement interface represents hyperlink elements
provides special properties and methods (beyond those of the
`web.dom.HTMLElement` object interface that they inherit from)
manipulating the layout and presentation of such elements. This
corresponds to <a> element; not to be confused with <link>, which
represented by HTMLLinkElement)

The HTMLAreaElement interface provides special properties and
(beyond those of the regular object `web.dom.HTMLElement` interface
also has available to it by inheritance) for manipulating the
and presentation of `<area>` elements.

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

The HTMLBaseFontElement interface provides special properties
the regular `web.dom.HTMLElement` interface it also has available
it by inheritance) for manipulating `<basefont>` elements.

The HTMLBodyElement interface provides special properties (beyond
inherited from the regular `web.dom.HTMLElement` interface) for
`<body>` elements.

The HTMLBRElement interface represents a HTML line break element
It inherits from `web.dom.HTMLElement`.

The HTMLButtonElement interface provides properties and methods
the regular `web.dom.HTMLElement` interface it also has available
it by inheritance) for manipulating `<button>` elements.

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

The HTMLDataElement interface provides special properties (beyond
regular `web.dom.HTMLElement` interface it also has available
it by inheritance) for manipulating `<data>` elements.

The HTMLDataListElement interface provides special properties
the `web.dom.HTMLElement` object interface it also has available
it by inheritance) to manipulate `<datalist>` elements and their

The HTMLDetailsElement interface provides special properties
the regular `web.dom.HTMLElement` interface it also has available
it by inheritance) for manipulating `<details>` elements.

HTMLDetailsElement Events.