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

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.AbortController` object.

The AbstractWorker interface of the Web Workers API is an abstract
that defines properties and methods that are common to all types
worker, including not only the basic `web.Worker`, but also `web.ServiceWorker`
`web.SharedWorker`.

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

The AddressErrors dictionary is used by the Payment Request API
to report validation errors in a physical address (typically
billing address or a shipping address).

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

The AnalyserNode interface represents a node able to provide
frequency and time-domain analysis information. It is an `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 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.KeyframeEffect`, which
be passed to `web.Animation` objects for playing, and `web.KeyframeEffectReadOnly`
is used by CSS Animations and Transitions).

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.DocumentTimeline` and future timeline types)
is not itself directly used by developers. Anywhere you see AnimationTimeline,
should use DocumentTimeline or any other timeline type instead.

This type represents a DOM element's attribute as an object.
most DOM methods, you will probably directly retrieve the attribute
a string (e.g., `web.Element.getAttribute()`, but certain functions
`web.Element.getAttributeNode()`) or means of iterating give
types.

The AuthenticatorAssertionResponse interface of the Web Authentication
is returned by `web.CredentialsContainer.get()` when a `web.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 `web.CredentialsContainer.create()` when a `web.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
`web.PublicKeyCredential.response`.

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

The BasicCardRequest dictionary is a JavaScript object-structure
can be used in the Payment Request API. The properties of BasicCardRequest
defined in the Basic Card Payment spec).

The BasicCardResponse dictionary (related to the Payment Request
although defined in the Basic Card Payment spec) defines an object
for payment response details such as the number/expiry date of
card used to make the payment, and the billing address.

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

The BeforeInstallPromptEvent is fired at the `web.Window.onbeforeinstallprompt`
before a user is prompted to \"install\" a web site to a home
on mobile.

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

A Blob object represents a file-like object of immutable, raw
Blobs represent data that isn't necessarily in a JavaScript-native
The `file.File` interface is based on Blob, inheriting blob functionality
expanding it to support files on the user's system.

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

The Body mixin of the Fetch API represents the body of the response/request,
you to declare what its content type is and how it should be

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.

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.

The ByteLengthQueuingStrategy interface of the the Streams API
a built-in byte length queuing strategy that can be used when
streams.

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

The CacheStorage interface represents the storage for `web.Cache`

The CanvasCaptureMediaStreamTrack interface represents the video
contained in a `media.MediaStream` being generated from a `web.<canvas>`
a call to `html.HTMLCanvasElement.captureStream()`.

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

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

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

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 Client interface represents an executable context such as
`web.Worker`, or a `web.SharedWorker`. `web.Window` clients are
by the more-specific `web.WindowClient`. You can get Client/WindowClient
from methods such as `web.Clients.matchAll()` and `web.Clients.get()`.

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

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

A CloseEvent is sent to clients using WebSockets when the connection
closed. This is delivered to the listener indicated by the WebSocket
onclose attribute.

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

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

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

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

The CountQueuingStrategy interface of the the Streams API provides
built-in byte length queuing strategy that can be used when constructing

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 `web.Navigator.credentials`.

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 CustomElementRegistry interface provides methods for registering
elements and querying registered elements. To get an instance
it, use the `web.window.customElements` property.

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

The DataTransfer object is used to hold the data that is being
during a drag and drop operation. It may hold one or more data
each of one or more data types. For more information about drag
drop, see HTML Drag and Drop API.

The DataTransferItem object represents one drag data item. During
drag operation, each `web.drag event` has a `web.dataTransfer`
which contains a `web.list` of drag data items. Each item in
list is a DataTransferItem object.

The DataTransferItemList object is a list of `web.DataTransferItem`
representing items being dragged. During a drag operation, each
has a `web.dataTransfer` property and that property is a DataTransferItemList.

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

DedicatedWorkerGlobalScope Events.

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

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

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 DeviceMotionEvent provides web developers with information
the speed of changes for the device's position and orientation.

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

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 DisplayMediaStreamConstraints dictionary is used to specify
or not to include video and/or audio tracks in the `media.MediaStream`
be returned by `web.getDisplayMedia()`, as well as what type
processing must be applied to the tracks.

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 DocumentFragment interface represents a minimal document
that has no parent. It is used as a lightweight version of `web.Document`
stores a segment of a document structure comprised of nodes just
a standard document. The key difference is that because the document
isn't part of the active document tree structure, changes made
the fragment don't affect the document, cause reflow, or incur
performance impact that can occur when changes are made.

The DocumentOrShadowRoot mixin of the Shadow DOM API provides
that are shared between documents and shadow roots. The following
are included in both `web.Document` and `web.ShadowRoot`.

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

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

The DragEvent interface is a `dom.DOM event` that represents
drag and drop interaction. The user initiates a drag by placing
pointer device (such as a mouse) on the touch surface and then
the pointer to a new location (such as another DOM element).
are free to interpret a drag and drop interaction in an application-specific

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

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

Element is the most general base class from which all objects
a `web.Document` inherit. It only has methods and properties
to all kinds of elements. More specific classes inherit from

Element Events.

The Event interface represents an event which takes place in
DOM.

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

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

EventSource Events.

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

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

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

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

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

The FocusEvent interface represents focus-related events, including
blur, focusin, and focusout.

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

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

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

The FormData interface provides a way to easily construct a set
key/value pairs representing form fields and their values, which
then be easily sent using the `xml.XMLHttpRequest.send()` method.
uses the same format a form would use if the encoding type were
to \"multipart/form-data\".

The FullscreenOptions dictionary is used to provide configuration
when calling `web.requestFullscreen()` on an element to place
element into full-screen mode.

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 Gamepad interface of the Gamepad API defines an individual
or other controller, allowing access to information such as button
axis positions, and id.

The GamepadButton interface defines an individual button of a
or other controller, allowing access to the current state of
types of buttons available on the control device.

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

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

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

The Geolocation interface represents an object able to programmatically
the position of the device. It gives Web content access to the
of the device. This allows a Web site or app to offer customized
based on the user's location.

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

The Gyroscope interface of the Sensor APIs provides on each reading
angular velocity of the device along all three axes.

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

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

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 HMDVRDevice interface of the WebVR API represents a head
display, providing access to information about each eye, and
us to modify the current field of view.

See our complete example in the article Cooperative Scheduling
Background Tasks API.

The IIRFilterNode interface of the Web Audio API is a `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 ImageBitmap interface represents a bitmap image which can
drawn to a `web.<canvas>` without undue latency. It can be created
a variety of source objects using the `web.createImageBitmap()`
method. ImageBitmap provides an asynchronous and resource efficient
to 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.ImageBitmap`. Its context id (the first argument
`html.HTMLCanvasElement.getContext()` or `web.OffscreenCanvas.getContext()`)
\"bitmaprenderer\".

The ImageCapture interface of the MediaStream Image Capture API
methods to enable the capture of images or photos from a camera
other photographic device provides an interface for capturing
from a photographic device referenced through a valid `media.MediaStreamTrack`.

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

The InputDeviceCapabilities interface of the Input Device Capabilities
provides information about the physical device or a group of
devices responsible for generating input events. Events caused
the same physical input device get the same instance of this
but the converse isn't true. For example, two mice with the same
in a system may appear as a single InputDeviceCapabilities instance.

The InputEvent interface represents an event notifying of editable
change.

The parameter passed into the `web.oninstall` handler, the InstallEvent
represents an install action that is dispatched on the `web.ServiceWorkerGlobalScope`
a `web.ServiceWorker`. As a child of `web.ExtendableEvent`, it
that functional events such as `web.FetchEvent` are not dispatched
installation.

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

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

The Keyboard interface of the the Keyboard API provides functions
retrieve keyboard layout maps and toggle capturing of key presses
the physical keyboard.

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

The KeyboardLayoutMap interface of the the Keyboard API is a
object with functions for retrieving the string associated with
physical keys.

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

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 Location interface represents the location (URL) of the object
is linked to. Changes done on it are reflected on the object
relates to. Both the `web.Document` and `web.Window` interface
such a linked Location, accessible via `web.Document.location`
`web.Window.location` respectively.

The Lock interface of the the Web Locks API provides the name
mode of a previously requested lock, which is received in the
to `web.LockManager.request()`.

The LockedFile interface provides tools to deal with a given
with all the necessary locks.

The LockManager interface of the the Web Locks API provides methods
requesting a new `web.Lock` object and querying for an existing
object. To get an instance of LockManager, call `web.navigator.locks`.

The Magnetometer interface of the Sensor APIs provides information
the magnetic field as detected by the device’s primary magnetometer

The MerchantValidationEvent interface of the the Payment Request
enables a merchant to verify themselves as allowed to use a particular
handler.

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

The MessageEvent interface represents a message received by a
object.

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

MessagePort Events.

The Metadata interface is used by the File and Directory Entries
to contain information about a file system entry. This metadata
the file's size and modification date and time.

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

MSManipulationEvent provides contextual information when contact
made to the screen and an element is manipulated.

The `web.MutationObserver` interface provides the ability to
for changes being made to the DOM tree. It is designed as a replacement
the older Mutation Events feature which was part of the DOM3
specification.

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

The NamedNodeMap interface represents a collection of `web.Attr`
Objects inside a NamedNodeMap are not in any particular order,
`web.NodeList`, although they may be accessed by an index as
an array.

The Navigator interface represents the state and the identity
the user agent. It allows scripts to query it and to register
to carry on some activities.

The NavigatorConcurrentHardware mixin adds to the `web.Navigator`
features which allow Web content to determine how many logical
the user has available, in order to let content and Web apps
their operations to best take advantage of the user's CPU.

The NavigatorID interface contains methods and properties related
the identity of the browser.

NavigatorLanguage contains methods and properties related to
language of the navigator.

The NavigatorOnLine interface contains methods and properties
to the connectivity status of the browser.

The NavigatorPlugins mixin adds to the `web.Navigator` interface
and properties for discovering and interacting with plugins installed
the browser.

The NavigatorStorage mixin adds to the `web.Navigator` and `web.WorkerNavigator`
the `web.Navigator.storage` property, which provides access to
`web.StorageManager` singleton used for controlling the persistence
data stores as well as obtaining information

The NetworkInformation interface provides information about the
a device is using to communicate with the network and provides
means for scripts to be notified if the connection type changes.
NetworkInformation interfaces cannot be instantiated. It is instead
through the connection property of the `web.Navigator` interface.

Node Node

A NodeFilter interface represents an object used to filter the
in a `web.NodeIterator` or `web.TreeWalker`. They don't know
about the DOM or how to traverse nodes; they just know how to
a single node against the provided filter.

The NodeIterator interface represents an iterator over the members
a list of the nodes in a subtree of the DOM. The nodes will be
in document order.

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

The NonDocumentTypeChildNode interface contains methods that
particular to `web.Node` objects that can have a parent, but
suitable for `web.DocumentType`.

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

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

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

The OfflineAudioContext interface is an `audio.AudioContext`
representing an audio-processing graph built from linked together
In contrast with a standard `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 `audio.AudioBuffer`.

OfflineAudioContext Events.

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

The OrientationSensor interface of the the Sensor APIs is the
class for orientation sensors. This interface cannot be used
Instead it provides properties and methods accessed by interfaces
inherit from it.

The OscillatorNode interface represents a periodic waveform,
as a sine wave. It is an `audio.AudioScheduledSourceNode` audio-processing
that causes a specified frequency of a given wave to be created—in
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.

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

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

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!

The ParentNode mixin contains methods and properties that are
to all types of `web.Node` objects that can have children.

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 `web.fetch`.

The Path2D interface of the Canvas 2D API is used to declare
path that can then be used on a `web.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 PayerErrors dictionary is used by the Payment Request API
indicate the presence of—and to explain how to correct—validation
in the payer details.

The Permissions interface of the Permissions API provides the
Permission API functionality, such as methods for querying and
permissions

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

The PhotoCapabilities interface of the the MediaStream Image
API provides available configuration options for an attached
device. A PhotoCapabilities object is retrieved by calling `web.ImageCapture.getPhotoCapabilities()`.

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

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

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

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

The PositionSensorVRDevice interface of the WebVR API represents
hardware's position sensor. You can access information such as
current position and orientation of the sensor in relation to
head mounted display through the `web.PositionSensorVRDevice.getState()`

The Presentation can be defined as two possible user agents in
context: Controlling user agent and Receiving user agent.

A PresentationAvailability object is associated with available
displays and represents the presentation display availability
a presentation request. If the controlling user agent can monitor
list of available presentation displays in the background (without
pending request to start()), the PresentationAvailability object
be implemented in a controlling browsing context.

The PresentationConnection interface of the Presentation API
methods and properties for managing a single presentation. Each
connection is represented by a PresentationConnection object.
the controlling user agent and receiving user agent MUST implement

The PresentationConnectionAvailableEvent interface of the Presentation
is fired on a `web.PresentationRequest` when a connection associated
the object is created.

A PresentationRequest object is used to initiate or reconnect
a presentation made by a controlling browsing context. The PresentationRequest
MUST be implemented in a controlling browsing context provided
a controlling user agent.

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

The PromiseRejectionEvent interface represents events which are
to the global script context when JavaScript `web.Promise`s are

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`,
was created by the Web Authentication API extension to the Credential
API. Other interfaces that inherit from `web.Credential` are
and `web.FederatedCredential`.

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

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

The PushEvent interface of the Push API represents a push message
has been received. This event is sent to the global scope of
`web.ServiceWorker`. It contains the information sent from an
server to a `web.PushSubscription`.

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

The PushMessageData interface of the Push API provides methods
let you retrieve the push data sent by a server in various formats.

The PushSubscription interface of the Push API provides a subcription's
endpoint and allows unsubscription from a push service.

The RadioNodeList interface represents a collection of radio
in a `web.<form>` or a `web.<fieldset>` element.

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

The ReadableByteStreamController interface of the Streams API
a controller allowing control of a `web.ReadableStream`'s state
internal queue. Byte stream controllers are for byte streams.

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

The ReadableStreamDefaultReader interface of the Streams API
a BYOB (\"bring your own buffer\") reader that can be used to
stream data supplied by the developer (e.g. a custom `web.ReadableStream.ReadableStream()`

The ReadableStreamBYOBRequest interface of the Streams API represents
pull request into a `web.ReadableByteStreamController` view.

The ReadableStreamDefaultController interface of the Streams
represents a controller allowing control of a `web.ReadableStream`'s
and internal queue. Default controllers are for streams that
not byte streams.

The ReadableStreamDefaultReader interface of the Streams API
a default reader that can be used to read stream data supplied
a network (e.g. a fetch request).

The Report interface of the Reporting API represents a single

The ReportingObserver interface of the Reporting API allows you
collect and access reports.

The Request interface of the Fetch API represents a resource

The ResizeObserver interface reports changes to the content rectangle
an `web.Element` or the bounding box of an `svg.SVGElement`.
content rectangle is the box in which content can be placed,
the border box minus the padding. (See The box model for an explanation
borders and padding.)

The ResizeObserverEntry interface is the object passed to the
`web.ResizeObserver()` constructor.

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

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

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

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

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

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

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

The Sensor interface of the the Sensor APIs is the base class
all the other sensor interfaces. This interface cannot be used
Instead it provides properties, event handlers, and methods accessed
interfaces that inherit from it.

The SensorErrorEvent interface of the Sensor APIs provides information
errors thrown by a `web.Sensor` or related interface.

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

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

ServiceWorkerContainer Events.

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

ServiceWorkerGlobalScope Events.

The ServiceWorkerMessageEvent interface of the `web.ServiceWorker
contains information about an event sent to a `web.ServiceWorkerContainer`
This extends the default message event to allow setting a `web.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 ServiceWorkerRegistration interface of the ServiceWorker
represents the service worker registration. You register a service
to control one or more pages that share the same origin.

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

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