Namespace CSharpToJavaScript.APIs.JS
Classes
- AbortController
The
AbortControllerinterface represents a controller object that allows you to abort one or more Web requests as and when desired.
- AbortSignal
The
AbortSignalinterface represents a signal object that allows you to communicate with an asynchronous operation (such as a fetch request) and abort it if required via an AbortController object.
- AbsoluteOrientationSensor
The
AbsoluteOrientationSensorinterface of the Sensor APIs describes the device's physical orientation in relation to the Earth's reference coordinate system.
- AbstractRange
The
AbstractRangeabstract 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.
- Accelerometer
- The
NOTE
ExperimentalAccelerometerinterface of the Sensor APIs provides on each reading the acceleration applied to the device along all three axes.
- AesCbcParams
The
AesCbcParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Encrypt(Union187, CryptoKey, Union224), Decrypt(Union187, CryptoKey, Union224), WrapKey(KeyFormat, CryptoKey, CryptoKey, Union187), or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when using the AES-CBC algorithm.
- AesCtrParams
The
AesCtrParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Encrypt(Union187, CryptoKey, Union224), Decrypt(Union187, CryptoKey, Union224), WrapKey(KeyFormat, CryptoKey, CryptoKey, Union187), or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when using the AES-CTR algorithm.
- AesGcmParams
The
AesGcmParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Encrypt(Union187, CryptoKey, Union224), Decrypt(Union187, CryptoKey, Union224), WrapKey(KeyFormat, CryptoKey, CryptoKey, Union187), or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when using the AES-GCM algorithm.
- AesKeyGenParams
The
AesKeyGenParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into GenerateKey(Union187, bool, List<KeyUsage>), when generating an AES key: that is, when the algorithm is identified as any of AES-CBC, AES-CTR, AES-GCM, or AES-KW.
- AmbientLightSensor
- The
NOTE
ExperimentalAmbientLightSensorinterface of the Sensor APIs returns the current light level or illuminance of the ambient light around the hosting device.
- AnalyserNode
The
AnalyserNodeinterface 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.
- Animation
The
Animationinterface of the Web Animations API represents a single animation player and provides playback controls and a timeline for an animation node or source.
- AnimationEffect
The
AnimationEffectinterface of the Web Animations API is an interface representing animation effects.
- AnimationEvent
The
AnimationEventinterface represents events providing information related to animations.
- AnimationPlaybackEvent
The AnimationPlaybackEvent interface of the Web Animations API represents animation events.
- AnimationTimeline
The
AnimationTimelineinterface of the Web Animations API represents the timeline of an animation. This interface exists to define timeline features, inherited by other timeline types:
- Attr
The
Attrinterface represents one of an element's attributes as an object. In most situations, you will directly retrieve the attribute value as a string (e.g., GetAttribute(string)), but some cases may require interacting withAttrinstances (e.g., GetAttributeNode(string)).
- AudioBuffer
The
AudioBufferinterface represents a short audio asset residing in memory, created from an audio file using the BaseAudioContextdecodeAudioData method, or from raw data using BaseAudioContextcreateBuffer. Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode.
- AudioBufferSourceNode
The
AudioBufferSourceNodeinterface is an AudioScheduledSourceNode which represents an audio source consisting of in-memory audio data, stored in an AudioBuffer.
- AudioContext
The
AudioContextinterface represents an audio-processing graph built from audio modules linked together, each represented by an AudioNode.
- AudioData
The
AudioDatainterface of the WebCodecs API represents an audio sample.
- AudioDecoder
The
AudioDecoderinterface of the 'WebCodecs API' decodes chunks of audio.
- AudioDestinationNode
The
AudioDestinationNodeinterface 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 anOfflineAudioContext.
- AudioEncoder
The
AudioEncoderinterface of the WebCodecs API encodes AudioData objects.
- AudioListener
The
AudioListenerinterface represents the position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to theAudioListenerstored in the Listener attribute.
- AudioNode
The
AudioNodeinterface is a generic interface for representing an audio processing module.
- AudioParam
The Web Audio API's
AudioParaminterface represents an audio-related parameter, usually a parameter of an AudioNode (such as Gain).
- AudioParamDescriptor
The
AudioParamDescriptordictionary of the Web Audio API specifies properties for AudioParam objects.
- AudioParamMap
The
AudioParamMapinterface of the Web Audio API represents an iterable and read-only set of multiple audio parameters.
- AudioProcessingEvent
- The
IMPORTANT
DeprecatedAudioProcessingEventinterface of the Web Audio API represents events that occur when a ScriptProcessorNode input buffer is ready to be processed.
- AudioScheduledSourceNode
The
AudioScheduledSourceNodeinterface—part of the Web Audio API—is a parent interface for several types of audio source node interfaces which share the ability to be started and stopped, optionally at specified times. Specifically, this interface defines the Start(Number) and Stop(Number) methods, as well as the AudioScheduledSourceNode.Ended event.
- AudioSinkInfo
- The
NOTE
ExperimentalAudioSinkInfointerface of the {{domxref("Web Audio API", "Web Audio API", "", "nocode")}} represents information describing an AudioContext's sink ID, retrieved via SinkId.
- AudioTrack
The
AudioTrackinterface represents a single audio track from one of the HTML media elements, audio or video.
- AudioTrackList
The
AudioTrackListinterface is used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list.
- AudioWorklet
The
AudioWorkletinterface of the Web Audio API is used to supply custom audio processing scripts that execute in a separate thread to provide very low latency audio processing.
- AudioWorkletGlobalScope
The
AudioWorkletGlobalScopeinterface of the Web Audio API represents a global execution context for user-supplied code, which defines custom AudioWorkletProcessor-derived classes.
- AudioWorkletNode
NOTE
Although the interface is available outside secure contexts, the AudioWorklet property is not, thus custom AudioWorkletProcessors cannot be defined outside them.
- AudioWorkletProcessor
The
AudioWorkletProcessorinterface of the Web Audio API represents an audio processing code behind a custom AudioWorkletNode. It lives in the AudioWorkletGlobalScope and runs on the Web Audio rendering thread. In turn, an AudioWorkletNode based on it runs on the main thread.
- AuthenticatorAssertionResponse
The
AuthenticatorAssertionResponseinterface of the Web Authentication API contains a digital signature from the private key of a particular WebAuthn credential. The relying party's server can verify this signature to authenticate a user, for example when they sign in.
- AuthenticatorAttestationResponse
The
AuthenticatorAttestationResponseinterface of the Web Authentication API is the result of a WebAuthn credential registration. It contains information about the credential that the server needs to perform WebAuthn assertions, such as its credential ID and public key.
- AuthenticatorResponse
The
AuthenticatorResponseinterface of the Web Authentication API is the base interface for interfaces that provide a cryptographic root of trust for a key pair. The child interfaces include information from the browser such as the challenge origin and either may be returned from Response.
- BackgroundFetchEvent
- The
NOTE
ExperimentalBackgroundFetchEventinterface of the {{domxref('Background Fetch API', "", "", "nocode")}} is the event type for background fetch events dispatched on the {{domxref("ServiceWorkerGlobalScope", "service worker global scope", "", "nocode")}}.
- BackgroundFetchManager
- The
NOTE
ExperimentalBackgroundFetchManagerinterface of the 'Background Fetch API' is a map where the keys are background fetch IDs and the values are BackgroundFetchRegistration objects.
- BackgroundFetchRecord
- The
NOTE
ExperimentalBackgroundFetchRecordinterface of the 'Background Fetch API' represents an individual request and response.
- BackgroundFetchRegistration
- The
NOTE
ExperimentalBackgroundFetchRegistrationinterface of the 'Background Fetch API' represents an individual background fetch.
- BackgroundFetchUpdateUIEvent
- The
NOTE
ExperimentalBackgroundFetchUpdateUIEventinterface of the 'Background Fetch API' is an event type for the ServiceWorkerGlobalScope.Backgroundfetchsuccess and ServiceWorkerGlobalScope.Backgroundfetchfail events, and provides a method for updating the title and icon of the app to inform a user of the success or failure of a background fetch.
- BarProp
The
BarPropinterface of the Document Object Model represents the web browser user interface elements that are exposed to scripts in web pages. Each of the following interface elements are represented by aBarPropobject.
- BarcodeDetector
- The
NOTE
ExperimentalBarcodeDetectorinterface of the 'Barcode Detection API' allows detection of linear and two dimensional barcodes in images.
- BaseAudioContext
The
BaseAudioContextinterface of the Web Audio API acts as a base definition for online and offline audio-processing graphs, as represented by AudioContext and OfflineAudioContext respectively. You wouldn't useBaseAudioContextdirectly — you'd use its features via one of these two inheriting interfaces.
- BatteryManager
The
BatteryManagerinterface of the {{domxref("Battery Status API", "", "", "nocode")}} provides information about the system's battery charge level. The GetBattery() method returns a promise that resolves with aBatteryManagerinterface.
- BeforeInstallPromptEvent
- The
CAUTION
Non-standardBeforeInstallPromptEventis the interface of the Window.Beforeinstallprompt event fired at the Window object before a user is prompted to "install" a website to a home screen on mobile.
- BeforeUnloadEvent
The
BeforeUnloadEventinterface represents the event object for the Windowbeforeunload event, which is fired when the current window, contained document, and associated resources are about to be unloaded.
- BiquadFilterNode
The
BiquadFilterNodeinterface represents a simple low-order filter, and is created using the BaseAudioContextcreateBiquadFilter method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. ABiquadFilterNodealways has exactly one input and one output.
- Blob
The
Blobinterface represents a blob, which is 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.
- BlobEvent
The
BlobEventinterface of the MediaStream Recording API represents events associated with a Blob. These blobs are typically, but not necessarily, associated with media content.
- Bluetooth
- The
NOTE
ExperimentalBluetoothinterface of the Web Bluetooth API provides methods to query Bluetooth availability and request access to devices.
- BluetoothCharacteristicProperties
- The
NOTE
ExperimentalBluetoothCharacteristicPropertiesinterface of the Web Bluetooth API provides the operations that are valid on the given 'BluetoothRemoteGATTCharacteristic'.
- BluetoothDevice
- The BluetoothDevice interface of the Web Bluetooth API represents a Bluetooth device inside a particular script execution
NOTE
Experimental
environment.
- BluetoothRemoteGATTCharacteristic
- The
NOTE
ExperimentalBluetoothRemoteGattCharacteristicinterface of the Web Bluetooth API represents a GATT Characteristic, which is a basic data element that provides further information about a peripheral's service.
- BluetoothRemoteGATTDescriptor
- The
NOTE
ExperimentalBluetoothRemoteGATTDescriptorinterface of the Web Bluetooth API provides a GATT Descriptor,
which provides further information about a characteristic's value.
- BluetoothRemoteGATTServer
- The
NOTE
ExperimentalBluetoothRemoteGATTServerinterface of the Web Bluetooth API represents a GATT
Server on a remote device.
- BluetoothRemoteGATTService
- The
NOTE
ExperimentalBluetoothRemoteGATTServiceinterface of the Web Bluetooth API represents a
service provided by a GATT server, including a device, a list of referenced services,
and a list of the characteristics of this service.
- BluetoothUUID
The
BluetoothUUIDinterface of the Web Bluetooth API provides a way to look up Universally Unique Identifier (UUID) values by name in the
registry maintained by the Bluetooth SIG.
- BroadcastChannel
The
BroadcastChannelinterface represents a named channel that any {{glossary("browsing context")}} of a given {{glossary("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 BroadcastChannelmessage event fired at allBroadcastChannelobjects listening to the channel, except the object that sent the message.
- BrowserCaptureMediaStreamTrack
- The
NOTE
ExperimentalBrowserCaptureMediaStreamTrackinterface of the {{domxref("Screen Capture API", "Screen Capture API", "", "nocode")}} represents a single video track. It extends the MediaStreamTrack class with methods to limit the part of a self-capture stream (for example, a user's screen or window) that is captured.
- ByteLengthQueuingStrategy
The
ByteLengthQueuingStrategyinterface of the Streams API provides a built-in byte length queuing strategy that can be used when constructing streams.
- CDATASection
The
CDATASectioninterface represents a CDATA section
that can be used within XML to include extended portions of unescaped text.
When inside a CDATA section, the symbols<and&don't need escaping
as they normally do.
- CSPViolationReportBody
The
CSPViolationReportBodyinterface is an extension of the Reporting API that represents the body of a Content Security Policy (CSP) violation report.
- CSS
The
CSSinterface holds useful CSS-related methods. No objects with this interface are implemented: it contains only static methods and is therefore a utilitarian interface.
- CSSAnimation
The
CSSAnimationinterface of the 'Web Animations API' represents an Animation object.
- CSSConditionRule
An object implementing the
CSSConditionRuleinterface represents a single condition CSS at-rule, which consists of a condition and a statement block.
- CSSContainerRule
The
CSSContainerRuleinterface represents a single CSS @container rule.
- CSSCounterStyleRule
The
CSSCounterStyleRuleinterface represents an @counter-style at-rule.
- CSSFontFaceRule
The
CSSFontFaceRuleinterface represents an @font-face at-rule.
- CSSFontFeatureValuesRule
The
CSSFontFeatureValuesRuleinterface represents an @font-feature-values at-rule, letting developers assign for each font face a common name to specify features indices to be used in font-variant-alternates.
- CSSFontPaletteValuesRule
The
CSSFontPaletteValuesRuleinterface represents an @font-palette-values at-rule.
- CSSGroupingRule
The
CSSGroupingRuleinterface of the CSS Object Model represents any CSS at-rule that contains other rules nested within it.
- CSSImageValue
The
CSSImageValueinterface of the CSS Typed Object Model API represents values for properties that take an image, for example 'background-image', 'list-style-image', or 'border-image-source'.
- CSSKeyframeRule
The
CSSKeyframeRuleinterface describes an object representing a set of styles for a given keyframe. It corresponds to the contents of a single keyframe of a @keyframes at-rule.
- CSSKeyframesRule
The
CSSKeyframesRuleinterface describes an object representing a complete set of keyframes for a CSS animation. It corresponds to the contents of a whole @keyframes at-rule.
- CSSKeywordValue
The
CSSKeywordValueinterface of the CSS Typed Object Model API creates an object to represent CSS keywords and other identifiers.
- CSSLayerBlockRule
The
CSSLayerBlockRulerepresents a @layer block rule.
- CSSLayerStatementRule
The
CSSLayerStatementRulerepresents a {{cssxref("@layer")}} statement rule. Unlike CSSLayerBlockRule, it doesn't contain other rules and merely defines one or several layers by providing their names.
- CSSMathInvert
The
CSSMathInvertinterface of the CSS Typed Object Model API represents a CSS 'calc' used ascalc(1 / <value>). It inherits properties and methods from its parent 'CSSNumericValue'.
- CSSMathMax
The
CSSMathMaxinterface of the CSS Typed Object Model API represents the CSS {{CSSXref('max','max()')}} function. It inherits properties and methods from its parent 'CSSNumericValue'.
- CSSMathMin
The
CSSMathMininterface of the CSS Typed Object Model API represents the CSS {{CSSXref('min','min()')}} function. It inherits properties and methods from its parent 'CSSNumericValue'.
- CSSMathNegate
The
CSSMathNegateinterface of the CSS Typed Object Model API negates the value passed into it. It inherits properties and methods from its parent 'CSSNumericValue'.
- CSSMathProduct
The
CSSMathProductinterface of the CSS Typed Object Model API represents the result obtained by calling 'CSSNumericValue.Add', 'CSSNumericValue.Sub', or 'CSSNumericValue.ToSum' on 'CSSNumericValue'. It inherits properties and methods from its parent 'CSSNumericValue'.
- CSSMathSum
The
CSSMathSuminterface of the CSS Typed Object Model API represents the result obtained by calling 'CSSNumericValue.Add', 'CSSNumericValue.Sub', or 'CSSNumericValue.ToSum' on 'CSSNumericValue'.
- CSSMathValue
The
CSSMathValueinterface of the CSS Typed Object Model API a base class for classes representing complex numeric values.
- CSSMatrixComponent
The
CSSMatrixComponentinterface of the CSS Typed Object Model API represents the matrix() and matrix3d() values of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent 'CSSTransformValue'.
- CSSMediaRule
The
CSSMediaRuleinterface represents a single CSS @media rule.
- CSSNamespaceRule
The
CSSNamespaceRuleinterface describes an object representing a single CSS @namespace at-rule.
- CSSNestedDeclarations
The
CSSNestedDeclarationsinterface of the CSS Rule API is used to group nested CSSRules.
- CSSNumericArray
The
CSSNumericArrayinterface of the CSS Typed Object Model API contains a list of CSSNumericValue objects.
- CSSNumericValue
The
CSSNumericValueinterface of the CSS Typed Object Model API represents operations that all numeric values can perform.
- CSSPageDescriptors
The
CSSPageDescriptorsinterface represents a CSS declaration block for an @page at-rule.
- CSSPageRule
CSSPageRulerepresents a single CSS @page rule.
- CSSPerspective
The
CSSPerspectiveinterface of the CSS Typed Object Model API represents the perspective() value of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent 'CSSTransformValue'.
- CSSPositionTryDescriptors
The
CSSPositionTryDescriptorsinterface defines properties that represent the list of CSS descriptors that can be set in the body of a @position-try at-rule.
- CSSPositionTryRule
The
CSSPositionTryRuleinterface describes an object representing a @position-try at-rule.
- CSSPropertyRule
The
CSSPropertyRuleinterface of the CSS Properties and Values API represents a single CSS @property rule.
- CSSPseudoElement
- The
NOTE
ExperimentalCSSPseudoElementinterface represents a pseudo-element that may be the target of an event or animated using the 'Web Animations API'. Instances of this interface may be obtained by calling 'Element.Pseudo'.
- CSSRotate
The
CSSRotateinterface of the CSS Typed Object Model API represents the rotate value of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent 'CSSTransformValue'.
- CSSRule
The
CSSRuleinterface represents a single CSS rule. There are several types of rules which inherit properties fromCSSRule.
- CSSRuleList
A
CSSRuleListrepresents an ordered collection of read-only CSSRule objects.
- CSSScale
The
CSSScaleinterface of the CSS Typed Object Model API represents the scale() and scale3d() values of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent 'CSSTransformValue'.
- CSSScopeRule
The
CSSScopeRuleinterface of the CSS Object Model represents a CSS @scope at-rule.
- CSSSkew
The
CSSSkewinterface of the CSS Typed Object Model API is part of the 'CSSTransformValue' interface. It represents theskew()value of the individual 'transform' property in CSS.
- CSSSkewX
The
CSSSkewXinterface of the CSS Typed Object Model API represents theskewX()value of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent CSSTransformValue.
- CSSSkewY
The
CSSSkewYinterface of the CSS Typed Object Model API represents theskewY()value of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent CSSTransformValue.
- CSSStartingStyleRule
The
CSSStartingStyleRuleinterface of the CSS Object Model represents a CSS @starting-style at-rule.
- CSSStyleDeclaration
The
CSSStyleDeclarationinterface represents an object that is a CSS declaration block, and exposes style information and various style-related methods and properties.
- CSSStyleRule
The
CSSStyleRuleinterface represents a single CSS style rule.
- CSSStyleSheet
The
CSSStyleSheetinterface represents a single CSS stylesheet, and lets you inspect and modify the list of rules contained in the stylesheet. It inherits properties and methods from its parent, StyleSheet.
- CSSStyleValue
The
CSSStyleValueinterface of the CSS Typed Object Model API is the base class of all CSS values accessible through the Typed OM API. An instance of this class may be used anywhere a string is expected.
- CSSSupportsRule
The
CSSSupportsRuleinterface represents a single CSS @supports at-rule.
- CSSTransformComponent
The
CSSTransformComponentinterface of the CSS Typed Object Model API is part of the 'CSSTransformValue' interface.
- CSSTransformValue
The
CSSTransformValueinterface of the CSS Typed Object Model API representstransform-listvalues as used by the CSS 'transform' property.
- CSSTransition
The
CSSTransitioninterface of the 'Web Animations API' represents an Animation object used for a CSS Transition.
- CSSTranslate
The
CSSTranslateinterface of the CSS Typed Object Model API represents the translate() value of the individual {{CSSXRef('transform')}} property in CSS. It inherits properties and methods from its parent 'CSSTransformValue'.
- CSSUnitValue
The
CSSUnitValueinterface of the CSS Typed Object Model API represents values that contain a single unit type. For example, "42px" would be represented by aCSSNumericValue.
- CSSUnparsedValue
The
CSSUnparsedValueinterface of the CSS Typed Object Model API represents property values that reference custom properties. It consists of a list of string fragments and variable references.
- CSSVariableReferenceValue
The
CSSVariableReferenceValueinterface of the CSS Typed Object Model API allows you to create a custom name for a built-in CSS value. This object functionality is sometimes called a "CSS variable" and serves the same purpose as the var function. The custom name must begin with two dashes.
- Cache
The
Cacheinterface provides a persistent storage mechanism for Request / Response object pairs that are cached in long lived memory. How long aCacheobject lives is browser dependent, but a single origin's scripts can typically rely on the presence of a previously populatedCacheobject. Note that theCacheinterface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec.
- CacheStorage
The
CacheStorageinterface represents the storage for Cache objects.
- CanMakePaymentEvent
- The
NOTE
ExperimentalCanMakePaymentEventinterface of the {{domxref("Payment Handler API", "", "", "nocode")}} is the event object for the ServiceWorkerGlobalScope.Canmakepayment event, fired on a payment app's service worker to check whether it is ready to handle a payment. Specifically, it is fired when the merchant website calls the PaymentRequest(List<PaymentMethodData>, PaymentDetailsInit, PaymentOptions) constructor.
- CanvasCaptureMediaStreamTrack
The
CanvasCaptureMediaStreamTrackinterface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} represents the video track contained in a MediaStream being generated from a {{HTMLElement("canvas")}} following a call to CaptureStream(Number).
- CanvasGradient
The
CanvasGradientinterface represents an opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.CreateLinearGradient, CanvasRenderingContext2D.CreateConicGradient or CanvasRenderingContext2D.CreateRadialGradient.
- CanvasPattern
The
CanvasPatterninterface represents an opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.CreatePattern method.
- CanvasRenderingContext2D
The
CanvasRenderingContext2Dinterface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a canvas element.
It is used for drawing shapes, text, images, and other objects.
- CaptureController
- The
NOTE
ExperimentalCaptureControllerinterface provides methods that can be used to further manipulate a captured display surface (captured via GetDisplayMedia(DisplayMediaStreamOptions))
- CaretPosition
The
CaretPositioninterface represents the caret position, an indicator for the text insertion point.
You can get aCaretPositionusing the CaretPositionFromPoint(Number, Number, CaretPositionFromPointOptions) method.
- ChannelMergerNode
The
ChannelMergerNodeinterface, 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.
- ChannelSplitterNode
The
ChannelSplitterNodeinterface, 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.
- ChapterInformation
- The
NOTE
ExperimentalChapterInformationinterface of the {{domxref("Media Session API", "", "", "nocode")}} represents the metadata for an individual chapter of a media resource (i.e., a video or audio file).
- CharacterBoundsUpdateEvent
- The
NOTE
ExperimentalCharacterBoundsUpdateEventinterface is a DOM event that represents a request from the operating system to know the bounds of certain characters within an editable region that's attached to an EditContext instance.
- CharacterData
The
CharacterDataabstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any objects of typeCharacterData: it is implemented by other interfaces like Text, Comment, CDATASection, or ProcessingInstruction, which aren't abstract.
- Client
The
Clientinterface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can getClient/WindowClientobjects from methods such as MatchAll(ClientQueryOptions) and Get(string).
- Clients
The
Clientsinterface provides access to Client objects. Access it via{{domxref("ServiceWorkerGlobalScope", "self")}}.clientswithin a service worker.
- Clipboard
The
Clipboardinterface of the Clipboard API provides read and write access to the contents of the system clipboard.
This allows a web application to implement cut, copy, and paste features.
- ClipboardEvent
The
ClipboardEventinterface of the Clipboard API represents events providing information related to modification of the clipboard, that is Elementcut, Elementcopy, and Elementpaste events.
- ClipboardItem
The
ClipboardIteminterface of the Clipboard API represents a single item format, used when reading or writing clipboard data using Read(ClipboardUnsanitizedFormats) and Write(List<ClipboardItem>) respectively.
- CloseEvent
A
CloseEventis sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by theWebSocketobject'soncloseattribute.
- CloseWatcher
- The
NOTE
ExperimentalCloseWatcherinterface allows a custom UI component with open and close semantics to respond to device-specific close actions in the same way as a built-in component.
- Comment
The
Commentinterface represents textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.
- CompositionEvent
The DOM
CompositionEventrepresents events that occur due to the user indirectly entering text.
- CompressionStream
The
CompressionStreaminterface of the 'Compression Streams API' is an API for compressing a stream of data.
- ConstantSourceNode
The
ConstantSourceNodeinterface—part of the Web Audio API—represents an audio source (based upon AudioScheduledSourceNode) whose output is single unchanging value. This makes it useful for cases in which you need a constant value coming in from an audio source. In addition, it can be used like a constructible AudioParam by automating the value of its Offset or by connecting another node to it; see Controlling multiple parameters with ConstantSourceNode.
- ContactAddress
- The
NOTE
ExperimentalContactAddressinterface of the Contact Picker API represents a physical address. Instances of this interface are retrieved from theaddressproperty of the objects returned by GetProperties().
- ContactsManager
- The
NOTE
ExperimentalContactsManagerinterface of the Contact Picker API allows users to select entries from their contact list and share limited details of the selected entries with a website or application.
- ContentIndex
- The
NOTE
ExperimentalContentIndexinterface of the Content Index API allows developers to register their offline enabled content with the browser.
- ContentIndexEvent
- The
NOTE
ExperimentalContentIndexEventinterface of the content index defines the object used to represent the ServiceWorkerGlobalScope.Contentdelete event.
- ContentVisibilityAutoStateChangeEvent
The
ContentVisibilityAutoStateChangeEventinterface is the event object for the Elementcontentvisibilityautostatechange event, which fires on any element with {{cssxref("content-visibility", "content-visibility: auto")}} set on it when it starts or stops being relevant to the user and skipping its contents.
- ConvolverNode
The
ConvolverNodeinterface is an AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. AConvolverNodealways has exactly one input and one output.
- CookieChangeEvent
The
CookieChangeEventinterface of the {{domxref("Cookie Store API", "", "", "nocode")}} is the event type of the CookieStorechange event fired at a CookieStore when any cookies are created or deleted.
- CookieStore
The
CookieStoreinterface of the {{domxref("Cookie Store API", "", "", "nocode")}} provides methods for getting and setting cookies asynchronously from either a page or a service worker.
- CookieStoreManager
The
CookieStoreManagerinterface of the {{domxref("Cookie Store API", "", "", "nocode")}} allows service workers to subscribe to cookie change events. Call Subscribe(List<CookieStoreGetOptions>) on a particular service worker registration to receive change events.
- CountQueuingStrategy
The
CountQueuingStrategyinterface of the Streams API provides a built-in chunk counting queuing strategy that can be used when constructing streams.
- Credential
The
Credentialinterface of the Credential Management API provides information about an entity (usually a user) normally as a prerequisite to a trust decision.
- CredentialsContainer
The
CredentialsContainerinterface of the Credential Management API exposes methods to request credentials and notify the user agent when events such as successful sign in or sign out happen. This interface is accessible from 'Navigator.Credentials'.
- CropTarget
- The
NOTE
ExperimentalCropTargetinterface of the {{domxref("Screen Capture API", "Screen Capture API", "", "nocode")}} provides a static method, FromElement(Element), which returns aCropTargetinstance that can be used to crop a captured video track to the area in which a specified element is rendered.
- Crypto
The
Cryptointerface represents basic cryptography features available in the current context.
It allows access to a cryptographically strong random number generator and to cryptographic primitives.
- CryptoKey
The
CryptoKeyinterface of the Web Crypto API represents a cryptographic {{glossary("key")}} obtained from one of the SubtleCrypto methods GenerateKey(Union187, bool, List<KeyUsage>), DeriveKey(Union187, CryptoKey, Union187, bool, List<KeyUsage>), ImportKey(KeyFormat, Union188, Union187, bool, List<KeyUsage>), or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>).
- CryptoKeyPair
The
CryptoKeyPairdictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm.
- CustomElementRegistry
The
CustomElementRegistryinterface provides methods for registering custom elements and querying registered elements. To get an instance of it, use the CustomElements property.
- CustomEvent
The
CustomEventinterface can be used to attach custom data to an event generated by an application.
- CustomStateSet
The
CustomStateSetinterface of the Document Object Model stores a list of states for an autonomous custom element, and allows states to be added and removed from the set.
- DOMException
The
DOMExceptioninterface represents an abnormal event (called an exception) that occurs as a result of calling a method or accessing a property of a web API. This is how error conditions are described in web APIs.
- DOMImplementation
The
DOMImplementationinterface represents an object providing methods which are not dependent on any particular document. Such an object is returned by the Implementation property.
- DOMMatrix
The
DOMMatrixinterface represents 4×4 matrices, suitable for 2D and 3D operations including rotation and translation. It is a mutable version of the DOMMatrixReadOnly interface.
The interface is available inside web workers.
- DOMMatrixReadOnly
The
DOMMatrixReadOnlyinterface represents a read-only 4×4 matrix, suitable for 2D and 3D operations. The DOMMatrix interface — which is based uponDOMMatrixReadOnly—adds mutability, allowing you to alter the matrix after creating it.
- DOMParser
The
DOMParserinterface provides
the ability to parse XML or HTML source code from a
string into a DOM Document.
- DOMPoint
A
DOMPointobject represents a 2D or 3D point in a coordinate system; it includes values for the coordinates in up to three dimensions, as well as an optional perspective value.DOMPointis based on DOMPointReadOnly but allows its properties' values to be changed.
- DOMPointReadOnly
The
DOMPointReadOnlyinterface specifies the coordinate and perspective fields used by DOMPoint to define a 2D or 3D point in a coordinate system.
- DOMQuad
A
DOMQuadis a collection of fourDOMPoints defining the corners of an arbitrary quadrilateral. ReturningDOMQuads letsgetBoxQuads()return accurate information even when arbitrary 2D or 3D transforms are present. It has a handyboundsattribute returning aDOMRectReadOnlyfor those cases where you just want an axis-aligned bounding rectangle.
- DOMRect
A
DOMRectdescribes the size and position of a rectangle.
- DOMRectList
The
DOMRectListinterface represents a collection of DOMRect objects, typically used to hold the rectangles associated with a particular element, like bounding boxes returned by methods such as GetClientRects(). It provides access to each rectangle in the list via its index, along with alengthproperty that indicates the total number of rectangles in the list.
- DOMRectReadOnly
The
DOMRectReadOnlyinterface specifies the standard properties (also used by DOMRect) to define a rectangle whose properties are immutable.
- DOMStringList
The
DOMStringListinterface is a legacy type returned by some APIs and represents a non-modifiable list of strings (DOMString).
- DOMStringMap
The
DOMStringMapinterface is used for the HTMLElement.Dataset attribute, to represent data for custom attributes added to elements.
- DOMTokenList
The
DOMTokenListinterface represents a set of space-separated tokens. Such a set is returned by ClassList or RelList, and many others.
- DataTransfer
The
DataTransferobject is used to hold any data transferred between contexts, such as a drag and drop operation, or clipboard read/write. It may hold one or more data items, each of one or more data types.
- DataTransferItem
The
DataTransferItemobject represents one drag data item. During a drag operation, each DragEvent has a DataTransfer property which contains a DataTransferItemList of drag data items. Each item in the list is aDataTransferItemobject.
- DataTransferItemList
The
DataTransferItemListobject is a list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a DataTransfer property and that property is aDataTransferItemList.
- DecompressionStream
The
DecompressionStreaminterface of the 'Compression Streams API' is an API for decompressing a stream of data.
- DedicatedWorkerGlobalScope
The
DedicatedWorkerGlobalScopeobject (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.
- DelayNode
The
DelayNodeinterface 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.
- DelegatedInkTrailPresenter
- The
NOTE
ExperimentalDelegatedInkTrailPresenterinterface of the Ink API provides the ability to instruct the OS-level compositor to render ink strokes between pointer event dispatches.
- DeprecationReportBody
- The
NOTE
ExperimentalDeprecationReportBodyinterface of the Reporting API represents the body of a deprecation report.
- DeviceMotionEvent
The
DeviceMotionEventinterface of the {{domxref("Device Orientation Events", "", "", "nocode")}} provides web developers with information about the speed of changes for the device's position and orientation.
- DeviceMotionEventAcceleration
The
DeviceMotionEventAccelerationinterface of the {{domxref("Device Orientation Events", "", "", "nocode")}} provides information about the amount of acceleration the device is experiencing along all three axes.
- DeviceMotionEventRotationRate
A
DeviceMotionEventRotationRateinterface of the {{domxref("Device Orientation Events", "", "", "nocode")}} provides information about the rate at which the device is rotating around all three axes.
- DeviceOrientationEvent
The
DeviceOrientationEventinterface of the {{domxref("Device Orientation Events", "", "", "nocode")}} provides web developers with information from the physical orientation of the device running the web page.
- DevicePosture
- The
NOTE
ExperimentalDevicePostureinterface of the {{domxref("Device Posture API", "Device Posture API", "", "nocode")}} represents the device's posture, that is, whether the viewport is in a flat or folded state.
- Document
The
Documentinterface represents any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.
- DocumentFragment
The
DocumentFragmentinterface represents a minimal document object that has no parent.
- DocumentPictureInPicture
- The
NOTE
ExperimentalDocumentPictureInPictureinterface of the {{domxref("Document Picture-in-Picture API", "Document Picture-in-Picture API", "", "nocode")}} is the entry point for creating and handling document picture-in-picture windows.
- DocumentPictureInPictureEvent
- The
NOTE
ExperimentalDocumentPictureInPictureEventinterface of the {{domxref("Document Picture-in-Picture API", "Document Picture-in-Picture API", "", "nocode")}} is the event object for the DocumentPictureInPictureenter event, which fires when the Picture-in-Picture window is opened.
- DocumentTimeline
The
DocumentTimelineinterface of the Web Animations API represents animation timelines, including the default document timeline (accessed via Timeline).
- DocumentType
The
DocumentTypeinterface represents a Node containing a doctype.
- DragEvent
The
DragEventinterface is a DOM event that represents a drag and drop interaction. The user initiates a drag by placing a pointer device (such as a mouse) on the touch surface and then dragging the pointer to a new location (such as another DOM element). Applications are free to interpret a drag and drop interaction in an application-specific way.
- DynamicsCompressorNode
The
DynamicsCompressorNodeinterface 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.DynamicsCompressorNodeis an AudioNode that has exactly one input and one output.
- EcKeyGenParams
The
EcKeyGenParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into GenerateKey(Union187, bool, List<KeyUsage>), when generating any elliptic-curve-based key pair: that is, when the algorithm is identified as either of ECDSA or ECDH.
- EcKeyImportParams
The
EcKeyImportParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into ImportKey(KeyFormat, Union188, Union187, bool, List<KeyUsage>) or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when generating any elliptic-curve-based key pair: that is, when the algorithm is identified as either of ECDSA or ECDH.
- EcdhKeyDeriveParams
The
EcdhKeyDeriveParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into DeriveKey(Union187, CryptoKey, Union187, bool, List<KeyUsage>) and DeriveBits(Union187, CryptoKey, ulong?), when using the ECDH or X25519 algorithms.
- EcdsaParams
The
EcdsaParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Sign(Union187, CryptoKey, Union224) or Verify(Union187, CryptoKey, Union224, Union224) when using the ECDSA algorithm.
- EditContext
- The
NOTE
ExperimentalEditContextinterface represents the text edit context of an element that was made editable by using the {{domxref("EditContext API", "", "", "nocode")}}.
- Element
Elementis the most general base class from which all element objects (i.e., objects that represent elements) in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit fromElement.
- ElementInternals
The
ElementInternalsinterface of the Document Object Model gives web developers a way to allow custom elements to fully participate in HTML forms. It provides utilities for working with these elements in the same way you would work with any standard HTML form element, and also exposes the Accessibility Object Model to the element.
- EncodedAudioChunk
The
EncodedAudioChunkinterface of the 'WebCodecs API' represents a chunk of encoded audio data.
- EncodedVideoChunk
The
EncodedVideoChunkinterface of the 'WebCodecs API' represents a chunk of encoded video data.
- ErrorEvent
The
ErrorEventinterface represents events providing information related to errors in scripts or in files.
- Event
The
Eventinterface represents an event which takes place on anEventTarget.
- EventCounts
The
EventCountsinterface of the Performance API provides the number of events that have been dispatched for each event type.
- EventSource
The
EventSourceinterface is web content's interface to server-sent events.
- EventTarget
The
EventTargetinterface is implemented by objects that can receive events and may have listeners for them.
In other words, any target of events implements the three methods associated with this interface.
- ExtendableCookieChangeEvent
The
ExtendableCookieChangeEventinterface of the {{domxref("Cookie Store API", "", "", "nocode")}} is the event type passed to ServiceWorkerGlobalScopecookiechange event fired at the ServiceWorkerGlobalScope when any cookie changes occur which match the service worker's cookie change subscription list. A cookie change event consists of a cookie and a type (either "changed" or "deleted").
- ExtendableEvent
The
ExtendableEventinterface extends the lifetime of theinstallandactivateevents dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.
- ExtendableMessageEvent
The
ExtendableMessageEventinterface of the Service Worker API represents the event object of a ServiceWorkerGlobalScopemessage event fired on a service worker (when a message is received on the ServiceWorkerGlobalScope from another context) — extends the lifetime of such events.
- EyeDropper
- The
NOTE
ExperimentalEyeDropperinterface represents an instance of an eyedropper tool that can be opened and used by the user to select colors from the screen.
- FederatedCredential
- The
NOTE
ExperimentalFederatedCredentialinterface of the Credential Management API provides information about credentials from a federated identity provider. A federated identity provider is an entity that a website trusts to correctly authenticate a user, and that provides an API for that purpose. OpenID Connect is an example of a federated identity provider framework.
- FederatedCredentialInit
The
FederatedCredentialInitdictionary represents the object passed to Create(CredentialCreationOptions) as the value of thefederatedoption: that is, when creating a FederatedCredential object representing a credential associated with a federated identify provider.
- Fence
- The
NOTE
ExperimentalFenceinterface of the {{domxref("Fenced Frame API", "Fenced Frame API", "", "nocode")}} contains several functions relevant to fencedframe functionality.
- FencedFrameConfig
- The
NOTE
ExperimentalFencedFrameConfiginterface represents the navigation of a fencedframe, i.e., what content will be displayed in it.
- FetchEvent
This is the event type for
fetchevents dispatched on the {{domxref("ServiceWorkerGlobalScope", "service worker global scope", "", 1)}}. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the RespondWith(Task<Response>) method, which allows us to provide a response to this fetch.
- File
The
Fileinterface provides information about files and allows JavaScript in a web page to access their content.
- FileList
The
FileListinterface represents an object of this type returned by thefilesproperty 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.
- FileReader
The
FileReaderinterface lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read.
- FileReaderSync
The
FileReaderSyncinterface 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.
- FileSystem
The File and Directory Entries API interface
FileSystemis used to represent a file system. These objects can be obtained from the Filesystem property on any file system entry. Some browsers offer additional APIs to create and manage file systems, such as Chrome's Window.RequestFileSystem method.
- FileSystemDirectoryEntry
The
FileSystemDirectoryEntryinterface of the File and Directory Entries API represents a directory in a file system. It provides methods which make it possible to access and manipulate the files in a directory, as well as to access the entries within the directory.
- FileSystemDirectoryHandle
The
FileSystemDirectoryHandleinterface of the {{domxref("File System API", "File System API", "", "nocode")}} provides a handle to a file system directory.
- FileSystemDirectoryReader
The
FileSystemDirectoryReaderinterface of the File and Directory Entries API lets you access the FileSystemFileEntry-based objects (generally FileSystemFileEntry or FileSystemDirectoryEntry) representing each entry in a directory.
- FileSystemEntry
The
FileSystemEntryinterface of the File and Directory Entries API represents a single entry in a file system. The entry can be a file or a directory (directories are represented by the FileSystemDirectoryEntry interface). It includes methods for working with files—including copying, moving, removing, and reading files—as well as information about a file it points to—including the file name and its path from the root to the entry.
- FileSystemFileEntry
The
FileSystemFileEntryinterface of the File and Directory Entries API represents a file in a file system. It offers properties describing the file's attributes, as well as the File(FileCallback, ErrorCallback) method, which creates a File(FileCallback, ErrorCallback) object that can be used to read the file.
- FileSystemFileHandle
The
FileSystemFileHandleinterface of the {{domxref("File System API", "File System API", "", "nocode")}} represents a handle to a file system entry. The interface is accessed through the 'window.ShowOpenFilePicker' method.
- FileSystemHandle
The
FileSystemHandleinterface of the 'File System API' is an object which represents a file or directory entry. Multiple handles can represent the same entry. For the most part you do not work withFileSystemHandledirectly but rather its child interfaces 'FileSystemFileHandle' and 'FileSystemDirectoryHandle'.
- FileSystemSyncAccessHandle
The
FileSystemSyncAccessHandleinterface of the {{domxref("File System API", "File System API", "", "nocode")}} represents a synchronous handle to a file system entry.
- FileSystemWritableFileStream
The
FileSystemWritableFileStreaminterface of the {{domxref("File System API", "File System API", "", "nocode")}} is a 'WritableStream' object with additional convenience methods, which operates on a single file on disk. The interface is accessed through the 'FileSystemFileHandle.CreateWritable' method.
- FocusEvent
The
FocusEventinterface represents focus-related events, including Elementfocus, Elementblur, Elementfocusin, and Elementfocusout.
- FontData
- The
NOTE
ExperimentalFontDatainterface of the {{domxref("Local Font Access API", "Local Font Access API", "", "nocode")}} represents a single local font face.
- FontFace
The
FontFaceinterface of the CSS Font Loading API represents a single usable font face.
- FontFaceSet
The
FontFaceSetinterface of the CSS Font Loading API manages the loading of font-faces and querying of their download status.
- FontFaceSetLoadEvent
The
FontFaceSetLoadEventinterface of the CSS Font Loading API represents events fired at a FontFaceSet after it starts loading font faces.
- FormData
The
FormDatainterface provides a way to construct a set of key/value pairs representing form fields and their values, which can be sent using the Windowfetch, Send(Union236?) or SendBeacon(string, Union41?) methods. It uses the same format a form would use if the encoding type were set to"multipart/form-data".
- FormDataEvent
The
FormDataEventinterface represents aformdataevent — such an event is fired on an HTMLFormElement object after the entry list representing the form's data is constructed. This happens when the form is submitted, but can also be triggered by the invocation of a FormData(HTMLFormElement, HTMLElement?) constructor.
- FragmentDirective
The
FragmentDirectiveinterface is an object exposed to allow code to check whether or not a browser supports text fragments.
- GM.Info
An object that exposes various information about Greasemonkey and the running User Script. Compatibility: Greasemonkey 0.9.16+
- GM.Info.Script
An object containing data about the currently running script. See more detail below.
- GPU
The
GPUinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is the starting point for using WebGPU. It can be used to return a GPUAdapter from which you can request devices, configure features and limits, and more.
- GPUAdapter
The
GPUAdapterinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a GPU adapter. From this you can request a GPUDevice, adapter info, features, and limits.
- GPUAdapterInfo
The
GPUAdapterInfointerface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} contains identifying information about a GPUAdapter.
- GPUBindGroup
The
GPUBindGroupinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is based on a GPUBindGroupLayout and defines a set of resources to be bound together in a group and how those resources are used in shader stages.
- GPUBindGroupLayout
The
GPUBindGroupLayoutinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} defines the structure and purpose of related GPU resources such as buffers that will be used in a pipeline, and is used as a template when creating GPUBindGroups.
- GPUBuffer
The
GPUBufferinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a block of memory that can be used to store raw data to use in GPU operations.
- GPUCanvasContext
The
GPUCanvasContextinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents the WebGPU rendering context of a {{htmlelement("canvas")}} element, returned via an GetContext(string, dynamic) call with acontextTypeof"webgpu".
- GPUCommandBuffer
The
GPUCommandBufferinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a pre-recorded list of GPU commands that can be submitted to a GPUQueue for execution.
- GPUCommandEncoder
The
GPUCommandEncoderinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents an encoder that collects a sequence of GPU commands to be issued to the GPU.
- GPUCompilationInfo
The
GPUCompilationInfointerface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents an array of GPUCompilationMessage objects generated by the GPU shader module compiler to help diagnose problems with shader code.
- GPUCompilationMessage
The
GPUCompilationMessageinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a single informational, warning, or error message generated by the GPU shader module compiler.
- GPUComputePassEncoder
The
GPUComputePassEncoderinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder.
- GPUComputePipeline
The
GPUComputePipelineinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder.
- GPUDevice
The
GPUDeviceinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a logical GPU device. This is the main interface through which the majority of WebGPU functionality is accessed.
- GPUDeviceLostInfo
The
GPUDeviceLostInfointerface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents the object returned when the Lost {{jsxref("Promise")}} resolves. This provides information as to why a device has been lost.
- GPUError
The
GPUErrorinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is the base interface for errors surfaced by PopErrorScope() and the GPUDevice.Uncapturederror event.
- GPUExternalTexture
The
GPUExternalTextureinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a wrapper object containing an HTMLVideoElement snapshot that can be used as a texture in GPU rendering operations.
- GPUInternalError
The
GPUInternalErrorinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} describes an application error indicating that an operation failed for a system or implementation-specific reason, even when all validation requirements were satisfied.
- GPUOutOfMemoryError
The
GPUOutOfMemoryErrorinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} describes an out-of-memory (oom) error indicating that there was not enough free memory to complete the requested operation.
- GPUPipelineError
The
GPUPipelineErrorinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} describes a pipeline failure. This is the value received when a {{jsxref("Promise")}} returned by a CreateComputePipelineAsync(GPUComputePipelineDescriptor) or CreateRenderPipelineAsync(GPURenderPipelineDescriptor) call rejects.
- GPUPipelineLayout
The
GPUPipelineLayoutinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} defines the GPUBindGroupLayouts used by a pipeline. GPUBindGroups used with the pipeline during command encoding must have compatible GPUBindGroupLayouts.
- GPUQuerySet
The
GPUQuerySetinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is used to record the results of queries on passes, such as occlusion or timestamp queries.
- GPUQueue
The
GPUQueueinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} controls execution of encoded commands on the GPU.
- GPURenderBundle
The
GPURenderBundleinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a container for pre-recorded bundles of commands.
- GPURenderBundleEncoder
The
GPURenderBundleEncoderinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is used to pre-record bundles of commands.
- GPURenderPassEncoder
The
GPURenderPassEncoderinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} encodes commands related to controlling the vertex and fragment shader stages, as issued by a GPURenderPipeline. It forms part of the overall encoding activity of a GPUCommandEncoder.
- GPURenderPipeline
The
GPURenderPipelineinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a pipeline that controls the vertex and fragment shader stages and can be used in a GPURenderPassEncoder or GPURenderBundleEncoder.
- GPUSampler
The
GPUSamplerinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents an object that can control how shaders transform and filter texture resource data.
- GPUShaderModule
The
GPUShaderModuleinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents an internal shader module object, a container for WGSL shader code that can be submitted to the GPU for execution by a pipeline.
- GPUSupportedFeatures
The
GPUSupportedFeaturesinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is aSet-like object that describes additional functionality supported by a GPUAdapter.
- GPUSupportedLimits
The
GPUSupportedLimitsinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} describes the limits supported by a GPUAdapter.
- GPUTexture
The
GPUTextureinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a container used to store 1D, 2D, or 3D arrays of data, such as images, to use in GPU rendering operations.
- GPUTextureView
The
GPUTextureViewinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents a view into a subset of the texture resources defined by a particular GPUTexture.
- GPUUncapturedErrorEvent
The
GPUUncapturedErrorEventinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is the event object type for the GPUDevice GPUDevice.Uncapturederror event, used for telemetry and to report unexpected errors.
- GPUValidationError
The
GPUValidationErrorinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} describes an application error indicating that an operation did not pass the WebGPU API's validation constraints.
- GainNode
The
GainNodeinterface 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. AGainNodealways has exactly one input and one output, both with the same number of channels.
- Gamepad
The
Gamepadinterface of the Gamepad API defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id.
- GamepadButton
The
GamepadButtoninterface defines an individual button of a gamepad or other controller, allowing access to the current state of different types of buttons available on the control device.
- GamepadEvent
The GamepadEvent interface of the Gamepad API contains references to gamepads connected to the system, which is what the gamepad events Window.Gamepadconnected and Window.Gamepaddisconnected are fired in response to.
- GamepadHapticActuator
The
GamepadHapticActuatorinterface of the Gamepad API represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware.
- GamepadPose
- The
NOTE
ExperimentalGamepadPoseinterface of the Gamepad API represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information).
- Geolocation
The
Geolocationinterface represents an object able to obtain the position of the device programmatically. It gives Web content access to the location of the device. This allows a website or app to offer customized results based on the user's location.
- GeolocationCoordinates
The
GeolocationCoordinatesinterface represents the position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated.
The geographic position information is provided in terms of World Geodetic System coordinates (WGS84).
- GeolocationPosition
The
GeolocationPositioninterface represents the position of the concerned device at a given time. The position, represented by a GeolocationCoordinates object, comprehends the 2D position of the device, on a spheroid representing the Earth, but also its altitude and its speed.
- GeolocationPositionError
The
GeolocationPositionErrorinterface represents the reason of an error occurring when using the geolocating device.
- GravitySensor
The
GravitySensorinterface of the Sensor APIs provides on each reading the gravity applied to the device along all three axes.
- Gyroscope
The
Gyroscopeinterface of the Sensor APIs provides on each reading the angular velocity of the device along all three axes.
- HID
- The
NOTE
ExperimentalHIDinterface provides methods for connecting to HID devices, listing attached HID devices and event handlers for connected HID devices.
- HIDConnectionEvent
- The
NOTE
ExperimentalHIDConnectionEventinterface of the WebHID API represents HID connection events, and is the event type passed to HIDconnect and HIDdisconnect event handlers when a device's connection state changes.
- HIDDevice
- The
NOTE
ExperimentalHIDDeviceinterface of the WebHID API represents a HID Device. It provides properties for accessing information about the device, methods for opening and closing the connection, and the sending and receiving of reports.
- HIDInputReportEvent
- The
NOTE
ExperimentalHIDInputReportEventinterface of the WebHID API is passed to HIDDevice.Inputreport event ofHIDDevicewhen an input report is received from any associated HID device.
- HTMLAllCollection
The
HTMLAllCollectioninterface represents a collection of all of the document's elements, accessible by index (like an array) and by the element'sid. It is returned by the All property.
- HTMLAnchorElement
The
HTMLAnchorElementinterface represents hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface that they inherit from) for manipulating the layout and presentation of such elements. This interface corresponds to<a>element; not to be confused with<link>, which is represented byHTMLLinkElement.
- HTMLAreaElement
The
HTMLAreaElementinterface 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 {{HtmlElement("area")}} elements.
- HTMLAudioElement
The
HTMLAudioElementinterface provides access to the properties of audio elements, as well as methods to manipulate them.
- HTMLBRElement
The
HTMLBRElementinterface represents an HTML line break element ({{htmlelement("br")}}). It inherits from HTMLElement.
- HTMLBaseElement
The
HTMLBaseElementinterface contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface.
- HTMLBodyElement
The
HTMLBodyElementinterface provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating {{HtmlElement("body")}} elements.
- HTMLButtonElement
The
HTMLButtonElementinterface provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("button")}} elements.
- HTMLCanvasElement
The
HTMLCanvasElementinterface provides properties and methods for manipulating the layout and presentation of canvas elements. TheHTMLCanvasElementinterface also inherits the properties and methods of the HTMLElement interface.
- HTMLCollection
The
HTMLCollectioninterface represents a generic collection (array-like object similar to Functions/arguments) of elements (in document order) and offers methods and properties for selecting from the list.
- HTMLDListElement
The
HTMLDListElementinterface provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list ({{HtmlElement("dl")}}) elements.
- HTMLDataElement
The
HTMLDataElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("data")}} elements.
- HTMLDataListElement
The
HTMLDataListElementinterface provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate {{ HTMLElement("datalist") }} elements and their content.
- HTMLDetailsElement
The
HTMLDetailsElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("details")}} elements.
- HTMLDialogElement
The
HTMLDialogElementinterface provides methods to manipulate {{HTMLElement("dialog")}} elements. It inherits properties and methods from the HTMLElement interface.
- HTMLDivElement
The
HTMLDivElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HtmlElement("div")}} elements.
- HTMLElement
The
HTMLElementinterface represents any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it.
- HTMLEmbedElement
The
HTMLEmbedElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("embed")}} elements.
- HTMLFencedFrameElement
- The
NOTE
ExperimentalHTMLFencedFrameElementinterface represents a fencedframe element in JavaScript and provides configuration properties.
- HTMLFieldSetElement
The
HTMLFieldSetElementinterface 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 {{ HTMLElement("fieldset") }} elements.
- HTMLFontElement
- Implements the document object model (DOM) representation of the font element. The HTML Font Element font defines the font size, font face and color of text.
IMPORTANT
Deprecated
- HTMLFormControlsCollection
The
HTMLFormControlsCollectioninterface represents a collection of HTML form control elements, returned by the HTMLFormElement interface's Elements property.
- HTMLFormElement
The
HTMLFormElementinterface represents a form element in the DOM. It allows access to—and, in some cases, modification of—aspects of the form, as well as access to its component elements.
- HTMLFrameSetElement
- The
IMPORTANT
DeprecatedHTMLFrameSetElementinterface provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating {{HTMLElement("frameset")}} elements.
- HTMLHRElement
The
HTMLHRElementinterface provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("hr")}} elements.
- HTMLHeadElement
The
HTMLHeadElementinterface contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface.
- HTMLHeadingElement
The
HTMLHeadingElementinterface represents the different heading elements,<h1>through<h6>. It inherits methods and properties from the HTMLElement interface.
- HTMLHtmlElement
The
HTMLHtmlElementinterface serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface.
- HTMLIFrameElement
The
HTMLIFrameElementinterface 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.
- HTMLImageElement
The
HTMLImageElementinterface represents an HTML img element, providing the properties and methods used to manipulate image elements.
- HTMLInputElement
The
HTMLInputElementinterface provides special properties and methods for manipulating the options, layout, and presentation of input elements.
- HTMLLIElement
The
HTMLLIElementinterface exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements.
- HTMLLabelElement
The
HTMLLabelElementinterface gives access to properties specific to {{HTMLElement("label")}} elements. It inherits methods and properties from the base HTMLElement interface.
- HTMLLegendElement
The
HTMLLegendElementis an interface allowing to access properties of the {{HTMLElement("legend")}} elements. It inherits properties and methods from the HTMLElement interface.
- HTMLLinkElement
The
HTMLLinkElementinterface represents reference information for external resources and the relationship of those resources to a document and vice versa (corresponds to<link>element; not to be confused with<a>, which is represented byHTMLAnchorElement). This object inherits all of the properties and methods of the HTMLElement interface.
- HTMLMapElement
The
HTMLMapElementinterface 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.
- HTMLMarqueeElement
- The
IMPORTANT
DeprecatedHTMLMarqueeElementinterface provides methods to manipulate marquee elements.
- HTMLMediaElement
The
HTMLMediaElementinterface adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video.
- HTMLMenuElement
The
HTMLMenuElementinterface provides additional properties (beyond those inherited from the HTMLElement interface) for manipulating a {{HTMLElement("menu")}} element.<menu>is a semantic alternative to the ul element.
- HTMLMetaElement
The
HTMLMetaElementinterface contains descriptive metadata about a document provided in HTML as<meta>elements.
This interface inherits all of the properties and methods described in the HTMLElement interface.
- HTMLModElement
The
HTMLModElementinterface 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 {{HTMLElement("del")}} and {{HTMLElement("ins")}}.
- HTMLOListElement
The
HTMLOListElementinterface provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements.
- HTMLObjectElement
The
HTMLObjectElementinterface 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 {{HTMLElement("object")}} element, representing external resources.
- HTMLOptGroupElement
The
HTMLOptGroupElementinterface 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 {{HTMLElement("optgroup")}} elements.
- HTMLOptionElement
The
HTMLOptionElementinterface represents {{HTMLElement("option")}} elements and inherits all properties and methods of the HTMLElement interface.
- HTMLOptionsCollection
The
HTMLOptionsCollectioninterface represents a collection of<option>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 theoptionsproperty of select.
- HTMLOutputElement
The
HTMLOutputElementinterface provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of {{HTMLElement("output")}} elements.
- HTMLParagraphElement
The
HTMLParagraphElementinterface provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating {{HTMLElement("p")}} elements.
- HTMLParamElement
- The
IMPORTANT
DeprecatedHTMLParamElementinterface provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating {{HTMLElement("param")}} elements, representing a pair of a key and a value that acts as a parameter for an {{HTMLElement("object")}} element.
- HTMLPictureElement
The
HTMLPictureElementinterface represents a picture HTML element. It doesn't implement specific properties or methods.
- HTMLPreElement
The
HTMLPreElementinterface exposes specific properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating a block of preformatted text ({{HtmlElement("pre")}}).
- HTMLProgressElement
The
HTMLProgressElementinterface 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 {{HTMLElement("progress")}} elements.
- HTMLQuoteElement
The
HTMLQuoteElementinterface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like {{HTMLElement("blockquote")}} and {{HTMLElement("q")}}, but not the {{HTMLElement("cite")}} element.
- HTMLScriptElement
JavaScript files should be served with the
text/javascriptMIME type, but browsers are lenient and block them only if the script is served with an image type (image/), video type (video/), audio type (audio/*), ortext/csv. If the script is blocked, its element receives an HTMLElementerror event; otherwise, it receives a Windowload event.
- HTMLSelectElement
The
HTMLSelectElementinterface represents a {{HTMLElement("select")}} HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface.
- HTMLSlotElement
The
HTMLSlotElementinterface of the Shadow DOM API enables access to the name and assigned nodes of an HTML slot element.
- HTMLSourceElement
The
HTMLSourceElementinterface provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating {{htmlelement("source")}} elements.
- HTMLSpanElement
The
HTMLSpanElementinterface represents a {{HTMLElement("span")}} element and derives from the HTMLElement interface, but without implementing any additional properties or methods.
- HTMLStyleElement
The
HTMLStyleElementinterface represents a {{HTMLElement("style")}} element. It inherits properties and methods from its parent, HTMLElement.
- HTMLTableCaptionElement
The
HTMLTableCaptionElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table {{HTMLElement("caption")}} elements.
- HTMLTableCellElement
The
HTMLTableCellElementinterface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header cells ({{HTMLElement("th")}}) or data cells ({{HTMLElement("td")}}), in an HTML document.
- HTMLTableColElement
The
HTMLTableColElementinterface provides properties for manipulating single or grouped table column elements.
- HTMLTableElement
The
HTMLTableElementinterface 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.
- HTMLTableRowElement
The
HTMLTableRowElementinterface 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.
- HTMLTableSectionElement
The
HTMLTableSectionElementinterface 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 ({{HTMLElement("thead")}}, {{HTMLElement("tfoot")}}, and {{HTMLElement("tbody")}}, respectively) in an HTML table.
- HTMLTemplateElement
The
HTMLTemplateElementinterface enables access to the contents of an HTML template element.
- HTMLTextAreaElement
The
HTMLTextAreaElementinterface provides properties and methods for manipulating the layout and presentation of textarea elements.
- HTMLTimeElement
The
HTMLTimeElementinterface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating {{HTMLElement("time")}} elements.
- HTMLTitleElement
The
HTMLTitleElementinterface is implemented by a document's {{ HTMLElement( "title" )}}. This element inherits all of the properties and methods of the HTMLElement interface.
- HTMLTrackElement
The
HTMLTrackElementinterface represents an HTML {{HTMLElement("track")}} element within the DOM. This element can be used as a child of either {{HTMLElement("audio")}} or {{HTMLElement("video")}} to specify a text track containing information such as closed captions or subtitles.
- HTMLUListElement
The
HTMLUListElementinterface provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list ({{HTMLElement("ul")}}) elements.
- HTMLUnknownElement
The
HTMLUnknownElementinterface represents an invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods.
- HTMLVideoElement
The list of supported media formats varies from one browser to the other. You should either provide your video in a single format that all the relevant browsers supports, or provide multiple video sources in enough different formats that all the browsers you need to support are covered.
- HashChangeEvent
The
HashChangeEventinterface represents events that fire when the fragment identifier of the URL has changed.
- Headers
The
Headersinterface of the Fetch API allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing headers from the list of the request's headers.
- Highlight
The
Highlightinterface of the CSS Custom Highlight API is used to represent a collection of Range instances to be styled using the API.
- HighlightRegistry
The
HighlightRegistryinterface of the CSS Custom Highlight API is used to register Highlight objects to be styled using the API.
It is accessed via Highlights.
- History
The
Historyinterface of the {{domxref("History API", "", "", "nocode")}} allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in.
- HkdfParams
The
HkdfParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into DeriveKey(Union187, CryptoKey, Union187, bool, List<KeyUsage>), when using the HKDF algorithm.
- HmacImportParams
The
HmacImportParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into ImportKey(KeyFormat, Union188, Union187, bool, List<KeyUsage>) or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when generating a key for the HMAC algorithm.
- HmacKeyGenParams
The
HmacKeyGenParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into GenerateKey(Union187, bool, List<KeyUsage>), when generating a key for the HMAC algorithm.
- IDBCursor
NOTE
Not to be confused with IDBCursorWithValue which is just anIDBCursorinterface with an additionalvalueproperty.
- IDBCursorWithValue
The
IDBCursorWithValueinterface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes thevalueproperty.
- IDBDatabase
The
IDBDatabaseinterface of the IndexedDB API provides a connection to a database; you can use anIDBDatabaseobject to open a transaction on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database.
- IDBFactory
The
IDBFactoryinterface of the IndexedDB API lets applications asynchronously access the indexed databases. The object that implements the interface iswindow.indexedDB. You open — that is, create and access — and delete a database with this object, and not directly withIDBFactory.
- IDBIndex
IDBIndexinterface of the IndexedDB API provides asynchronous access to an index in a database. An index is a kind of object store for looking up records in another object store, called the referenced object store. You use this interface to retrieve data.
- IDBKeyRange
The
IDBKeyRangeinterface of the IndexedDB API represents a continuous interval over some data type that is used for keys. Records can be retrieved from IDBObjectStore and IDBIndex objects using keys or a range of keys. You can limit the range using lower and upper bounds. For example, you can iterate over all values of a key in the value range A–Z.
- IDBObjectStore
The
IDBObjectStoreinterface of the IndexedDB API represents an object store in a database. Records within an object store are sorted according to their keys. This sorting enables fast insertion, look-up, and ordered retrieval.
- IDBOpenDBRequest
The
IDBOpenDBRequestinterface of the IndexedDB API provides access to the results of requests to open or delete databases (performed using Open(string, ulong) and DeleteDatabase(string)), using specific event handler attributes.
- IDBRequest
The
IDBRequestinterface of the IndexedDB API provides access to results of asynchronous requests to databases and database objects using event handler attributes. Each reading and writing operation on a database is done using a request.
- IDBTransaction
The
IDBTransactioninterface of the IndexedDB API provides a static, asynchronous transaction on a database using event handler attributes. All reading and writing of data is done within transactions. You use IDBDatabase to start transactions,IDBTransactionto set the mode of the transaction (e.g., is itreadonlyorreadwrite), and you access an IDBObjectStore to make a request. You can also use anIDBTransactionobject to abort transactions.
- IDBVersionChangeEvent
The
IDBVersionChangeEventinterface of the IndexedDB API indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.Upgradeneeded event handler function.
- IIRFilterNode
The
IIRFilterNodeinterface of the Web Audio API is a AudioNode processor which implements a general infinite impulse response (IIR) filter; this type of filter can be used to implement tone control devices and graphic equalizers as well. It lets the parameters of the filter response be specified, so that it can be tuned as needed.
- IdentityCredential
- The
NOTE
ExperimentalIdentityCredentialinterface of the Federated Credential Management API (FedCM) represents a user identity credential arising from a successful federated sign-in.
- IdentityCredentialRequestOptions
- The
NOTE
ExperimentalIdentityCredentialRequestOptionsdictionary represents the object passed to Get(CredentialRequestOptions) as the value of theidentityoption.
- IdentityProvider
- The
NOTE
ExperimentalIdentityProviderinterface of the Federated Credential Management (FedCM) API represents an Identity provider and provides access to related information and functionality.
- IdleDeadline
The
IdleDeadlineinterface is used as the data type of the input parameter to idle callbacks established by calling RequestIdleCallback(IdleRequestCallback, IdleRequestOptions). It offers a method, TimeRemaining(), which lets you determine how much longer the user agent estimates it will remain idle and a property, DidTimeout, which lets you determine if your callback is executing because its timeout duration expired.
- IdleDetector
- The
NOTE
ExperimentalIdleDetectorinterface of the 'idle_detection_api' provides methods and events for detecting user activity on a device or screen.
- ImageBitmap
The
ImageBitmapinterface represents a bitmap image which can be drawn to a {{HTMLElement("canvas")}} without undue latency. It can be created from a variety of source objects using the Window.CreateImageBitmap or WorkerGlobalScope.CreateImageBitmap factory method.ImageBitmapprovides an asynchronous and resource efficient pathway to prepare textures for rendering in WebGL.
- ImageBitmapRenderingContext
The
ImageBitmapRenderingContextinterface is a canvas rendering context that provides the functionality to replace the canvas's contents with the given ImageBitmap. Its context id (the first argument to GetContext(string, dynamic) or GetContext(OffscreenRenderingContextId, dynamic)) is"bitmaprenderer".
- ImageCapture
The
ImageCaptureinterface of the MediaStream Image Capture API provides methods to enable the capture of images or photos from a camera or other photographic device. It provides an interface for capturing images from a photographic device referenced through a valid MediaStreamTrack.
- ImageData
The
ImageDatainterface represents the underlying pixel data of an area of a canvas element.
- ImageDecoder
The
ImageDecoderinterface of the 'WebCodecs API' provides a way to unpack and decode encoded image data.
- ImageTrack
The
ImageTrackinterface of the 'WebCodecs API' represents an individual image track.
- ImageTrackList
The
ImageTrackListinterface of the 'WebCodecs API' represents a list of image tracks.
- Ink
- The
NOTE
ExperimentalInkinterface of the Ink API provides access to DelegatedInkTrailPresenter objects for the application to use to render ink strokes.
- InputDeviceCapabilities
- The
NOTE
ExperimentalInputDeviceCapabilitiesinterface of the {{domxref("InputDeviceCapabilities API", "Input Device Capabilities API", "", "nocode")}} provides information about the physical device or a group of related devices responsible for generating input events. Events caused by the same physical input device get the same instance of this object, but the converse isn't true. For example, two mice with the same capabilities in a system may appear as a singleInputDeviceCapabilitiesinstance.
- InputDeviceInfo
The
InputDeviceInfointerface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} gives access to the capabilities of the input device that it represents.
- InputEvent
The
InputEventinterface represents an event notifying the user of editable content changes.
- InstallEvent
The parameter passed into an ServiceWorkerGlobalScope.Install event handler function, the
InstallEventinterface represents an install action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. As a child of ExtendableEvent, it ensures that functional events such as FetchEvent are not dispatched during installation.
- IntersectionObserver
The
IntersectionObserverinterface of the Intersection Observer API provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or with a top-level document's 'viewport'. The ancestor element or viewport is referred to as the root.
- IntersectionObserverEntry
The
IntersectionObserverEntryinterface of the Intersection Observer API describes the intersection between the target element and its root container at a specific moment of transition.
- InterventionReportBody
- The
NOTE
ExperimentalInterventionReportBodyinterface of the Reporting API represents the body of an intervention report.
- Keyboard
- The
NOTE
ExperimentalKeyboardinterface of the {{domxref("Keyboard API", "", "", "nocode")}} provides functions that retrieve keyboard layout maps and toggle capturing of key presses from the physical keyboard.
- KeyboardEvent
KeyboardEventobjects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard. The event type (Elementkeydown, Elementkeypress, or Elementkeyup) identifies what kind of keyboard activity occurred.
- KeyboardLayoutMap
- The
NOTE
ExperimentalKeyboardLayoutMapinterface of the {{domxref("Keyboard API", "", "", "nocode")}} is a read-only object with functions for retrieving the string associated with specific physical keys.
- KeyframeEffect
The
KeyframeEffectinterface of the Web Animations API lets us create sets of animatable properties and values, called keyframes. These can then be played using the Animation(AnimationEffect?, AnimationTimeline?) constructor.
- LargestContentfulPaint
The
LargestContentfulPaintinterface provides timing information about the largest image or text paint before user input on a web page.
- LaunchParams
- The
NOTE
ExperimentalLaunchParamsinterface of the {{domxref("Launch Handler API", "Launch Handler API", "", "nocode")}} is used when implementing custom launch navigation handling in a PWA. When SetConsumer(LaunchConsumer) is invoked to set up the launch navigation handling functionality, the callback function insidesetConsumer()is passed aLaunchParamsobject instance.
- LaunchQueue
- The
NOTE
ExperimentalLaunchQueueinterface of the {{domxref("Launch Handler API", "Launch Handler API", "", "nocode")}} is available via the LaunchQueue property. When a progressive web app (PWA) is launched with alaunch_handlerclient_modevalue offocus-existing,navigate-new, ornavigate-existing,LaunchQueueprovides access to functionality that allows custom launch navigation handling to be implemented in the PWA. This functionality is controlled by the properties of the LaunchParams object passed into the SetConsumer(LaunchConsumer) callback function.
- LayoutShift
- The
NOTE
ExperimentalLayoutShiftinterface of the Performance API provides insights into the layout stability of web pages based on movements of the elements on the page.
- LayoutShiftAttribution
- The
NOTE
ExperimentalLayoutShiftAttributioninterface provides debugging information about elements which have shifted.
- LinearAccelerationSensor
The
LinearAccelerationSensorinterface of the Sensor APIs provides on each reading the acceleration applied to the device along all three axes, but without the contribution of gravity.
- Location
The
Locationinterface represents the location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linkedLocation, accessible via Location and Location respectively.
- Lock
The
Lockinterface of the Web Locks API provides the name and mode of a lock.
This may be a newly requested lock that is received in the callback to 'LockManager.Request', or a record of an active or queued lock returned by 'LockManager.Query'.
- LockManager
The
LockManagerinterface of the Web Locks API provides methods for requesting a new 'Lock' object and querying for an existingLockobject. To get an instance ofLockManager, call 'navigator.Locks'.
- MIDIAccess
The
MIDIAccessinterface of the Web MIDI API provides methods for listing MIDI input and output devices, and obtaining access to those devices.
- MIDIConnectionEvent
The
MIDIConnectionEventinterface of the Web MIDI API is the event passed to the MIDIAccess.Statechange event of the MIDIAccess interface and the MIDIPort.Statechange event of the MIDIPort interface. This occurs any time a new port becomes available, or when a previously available port becomes unavailable. For example, this event is fired whenever a MIDI device is either plugged in to or unplugged from a computer.
- MIDIInput
The
MIDIInputinterface of the Web MIDI API receives messages from a MIDI input port.
- MIDIInputMap
The
MIDIInputMapread-only interface of the Web MIDI API provides the set of MIDI input ports that are currently available.
- MIDIMessageEvent
The
MIDIMessageEventinterface of the Web MIDI API represents the event passed to the MIDIInput.Midimessage event of the MIDIInput interface. Amidimessageevent is fired every time a MIDI message is sent from a device represented by a MIDIInput, for example when a MIDI keyboard key is pressed, a knob is tweaked, or a slider is moved.
- MIDIOutput
The
MIDIOutputinterface of the 'Web MIDI API' provides methods to add messages to the queue of an output device, and to clear the queue of messages.
- MIDIOutputMap
The
MIDIOutputMapread-only interface of the Web MIDI API provides the set of MIDI output ports that are currently available.
- MIDIPort
The
MIDIPortinterface of the 'Web MIDI API' represents a MIDI input or output port.
- Magnetometer
- The
NOTE
ExperimentalMagnetometerinterface of the Sensor APIs provides information about the magnetic field as detected by the device's primary magnetometer sensor.
- MathMLElement
The
MathMLElementinterface represents any MathML element.
- MediaCapabilities
The
MediaCapabilitiesinterface of the Media Capabilities API provides information about the decoding abilities of the device, system and browser. The API can be used to query the browser about the decoding abilities of the device based on codecs, profile, resolution, and bitrates. The information can be used to serve optimal media streams to the user and determine if playback should be smooth and power efficient.
- MediaDeviceInfo
The
MediaDeviceInfointerface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} contains information that describes a single media input or output device.
- MediaDevices
The
MediaDevicesinterface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} provides access to connected media input devices like cameras and microphones, as well as screen sharing. In essence, it lets you obtain access to any hardware source of media data.
- MediaElementAudioSourceNode
The
MediaElementAudioSourceNodeinterface represents an audio source consisting of an HTML {{ htmlelement("audio") }} or {{ htmlelement("video") }} element. It is an AudioNode that acts as an audio source.
- MediaEncryptedEvent
The
MediaEncryptedEventinterface of the Encrypted Media Extensions API contains the information associated with an HTMLMediaElementencrypted event sent to a HTMLMediaElement when some initialization data is encountered in the media.
- MediaError
The
MediaErrorinterface represents an error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as {{HTMLElement("audio")}} or {{HTMLElement("video")}}.
- MediaKeyMessageEvent
The
MediaKeyMessageEventinterface of the Encrypted Media Extensions API contains the content and related data when the content decryption module generates a message for the session.
- MediaKeySession
The
MediaKeySessioninterface of the Encrypted Media Extensions API represents a context for message exchange with a content decryption module (CDM).
- MediaKeyStatusMap
The
MediaKeyStatusMapinterface of the Encrypted Media Extensions API is a read-only map of media key statuses by key IDs.
- MediaKeySystemAccess
The
MediaKeySystemAccessinterface of the Encrypted Media Extensions API provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the RequestMediaKeySystemAccess(string, List<MediaKeySystemConfiguration>) method.
- MediaKeys
The
MediaKeysinterface of Encrypted Media Extensions API represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback.
- MediaList
The
MediaListinterface represents the media queries of a stylesheet, e.g., those set using a link element'smediaattribute.
- MediaMetadata
The
MediaMetadatainterface of the {{domxref("Media Session API", "", "", "nocode")}} allows a web page to provide rich media metadata for display in a platform UI.
- MediaQueryList
A
MediaQueryListobject stores information on a media query applied to a document, with support for both immediate and event-driven matching against the state of the document.
- MediaQueryListEvent
The
MediaQueryListEventobject stores information on the changes that have happened to a MediaQueryList object — instances are available as the event object on a function referenced by a MediaQueryList.Change event.
- MediaRecorder
The
MediaRecorderinterface of the MediaStream Recording API provides functionality to easily record media. It is created using the MediaRecorder(MediaStream, MediaRecorderOptions) constructor.
- MediaSession
The
MediaSessioninterface of the {{domxref("Media Session API", "", "", "nocode")}} allows a web page to provide custom behaviors for standard media playback interactions, and to report metadata that can be sent by the user agent to the device or operating system for presentation in standardized user interface elements.
- MediaSource
The
MediaSourceinterface of the {{domxref("Media Source Extensions API", "Media Source Extensions API", "", "nocode")}} represents a source of media data for an HTMLMediaElement object. AMediaSourceobject can be attached to a HTMLMediaElement to be played in the user agent.
- MediaSourceHandle
The
MediaSourceHandleinterface of the {{domxref("Media Source Extensions API", "Media Source Extensions API", "", "nocode")}} is a proxy for a MediaSource that can be transferred from a dedicated worker back to the main thread and attached to a media element via its SrcObject property.MediaSourceobjects are not transferable because they are event targets, hence the need forMediaSourceHandles.
- MediaStream
The
MediaStreaminterface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} represents a stream of media content. A stream consists of several tracks, such as video or audio tracks. Each track is specified as an instance of MediaStreamTrack.
- MediaStreamAudioDestinationNode
The
MediaStreamAudioDestinationNodeinterface represents an audio destination consisting of a WebRTC MediaStream with a singleAudioMediaStreamTrack, which can be used in a similar way to aMediaStreamobtained from GetUserMedia(MediaStreamConstraints).
- MediaStreamAudioSourceNode
The
MediaStreamAudioSourceNodeinterface is a type of AudioNode which operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs.
- MediaStreamTrack
The
MediaStreamTrackinterface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} represents a single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well.
- MediaStreamTrackAudioSourceNode
The
MediaStreamTrackAudioSourceNodeinterface is a type of AudioNode which represents a source of audio data taken from a specific MediaStreamTrack obtained through the WebRTC or Media Capture and Streams APIs.
- MediaStreamTrackEvent
The
MediaStreamTrackEventinterface of the {{domxref("Media Capture and Streams API", "", "", "nocode")}} represents events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Capture and Streams API methods. These events are sent to the stream when these changes occur.
- MediaStreamTrackProcessor
WARNING
Browsers differ on which global context they expose this interface in (e.g., only window in some browsers and only dedicated worker in others), making them incompatible. Keep this in mind when comparing support.
- MediaTrackConstraints
The
MediaTrackConstraintsdictionary is used to describe a set of capabilities and the value or values each can take on. A constraints dictionary is passed into ApplyConstraints(MediaTrackConstraints) to allow a script to establish a set of exact (required) values or ranges and/or preferred values or ranges of values for the track, and the most recently-requested set of custom constraints can be retrieved by calling GetConstraints().
- MediaTrackSettings
The
MediaTrackSettingsdictionary is used to return the current values configured for each of a MediaStreamTrack's settings. These values will adhere as closely as possible to any constraints previously described using a MediaTrackConstraints object and set using ApplyConstraints(MediaTrackConstraints), and will adhere to the default constraints for any properties whose constraints haven't been changed, or whose customized constraints couldn't be matched.
- MediaTrackSupportedConstraints
The
MediaTrackSupportedConstraintsdictionary establishes the list of constrainable properties recognized by the {{Glossary("user agent")}} or browser in its implementation of the MediaStreamTrack object. An object conforming toMediaTrackSupportedConstraintsis returned by GetSupportedConstraints().
- MessageChannel
The
MessageChannelinterface of the Channel Messaging API allows us to create a new message channel and send data through it via its two MessagePort properties.
- MessageEvent
The
MessageEventinterface represents a message received by a target object.
- MessagePort
The
MessagePortinterface of the Channel Messaging API represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other.
- MimeType
- The
IMPORTANT
DeprecatedMimeTypeinterface provides contains information about a MIME type associated with a particular plugin. Navigator.MimeTypes returns an array of this object.
- MimeTypeArray
- The
IMPORTANT
DeprecatedMimeTypeArrayinterface returns an array of 'MimeType' instances, each of which contains information about a supported browser plugins. This object is returned by the deprecated Navigator.MimeTypes property.
- MouseEvent
The
MouseEventinterface represents events that occur due to the user interacting with a pointing device (such as a mouse).
Common events using this interface include Elementclick, Elementdblclick, Elementmouseup, Elementmousedown.
- MutationObserver
The
MutationObserverinterface provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature, which was part of the DOM3 Events specification.
- MutationRecord
The
MutationRecordis a read-only interface that represents an individual DOM mutation observed by a MutationObserver. It is the object inside the array passed to the callback of a MutationObserver.
- NDEFMessage
- The
NOTE
ExperimentalNDEFMessageinterface of the Web NFC API represents the content of an NDEF message that has been read from or could be written to an NFC tag. An instance is acquired by calling theNDEFMessage()constructor or from the Message property, which is passed to the NDEFReader.Reading event.
- NDEFReader
- The
NOTE
ExperimentalNDEFReaderinterface of the Web NFC API is used to read from and write data to compatible NFC devices, e.g., NFC tags supporting NDEF, when these devices are within the reader's magnetic induction field.
- NDEFReadingEvent
- The
NOTE
ExperimentalNDEFReadingEventinterface of the Web NFC API represents events dispatched on new NFC readings obtained by NDEFReader.
- NDEFRecord
- The
NOTE
ExperimentalNDEFRecordinterface of the Web NFC API provides data that can be read from, or written to, compatible NFC devices, e.g., NFC tags supporting NDEF.
- NamedNodeMap
The
NamedNodeMapinterface represents a collection of Attr objects. Objects inside aNamedNodeMapare not in any particular order, unlike NodeList, although they may be accessed by an index as in an array.
- NavigateEvent
- The
NOTE
ExperimentalNavigateEventinterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} is the event object for the Navigationnavigate event, which fires when any type of navigation is initiated (this includes usage of {{domxref("History API", "History API", "", "nocode")}} features like Go(long)).NavigateEventprovides access to information about that navigation, and allows developers to intercept and control the navigation handling.
- Navigation
- The
NOTE
ExperimentalNavigationinterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} allows control over all navigation actions for the currentwindowin one central place, including initiating navigations programmatically, examining navigation history entries, and managing navigations as they happen.
- NavigationActivation
- The
NOTE
ExperimentalNavigationActivationinterface of the Navigation API represents a recent cross-document navigation. It contains the navigation type and outgoing and inbound document history entries.
- NavigationCurrentEntryChangeEvent
- The
NOTE
ExperimentalNavigationCurrentEntryChangeEventinterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} is the event object for the Navigationcurrententrychange event, which fires when the CurrentEntry has changed.
- NavigationDestination
- The
NOTE
ExperimentalNavigationDestinationinterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} represents the destination being navigated to in the current navigation.
- NavigationHistoryEntry
- The
NOTE
ExperimentalNavigationHistoryEntryinterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} represents a single navigation history entry.
- NavigationPreloadManager
The
NavigationPreloadManagerinterface of the Service Worker API provides methods for managing the preloading of resources in parallel with service worker bootup.
- NavigationTransition
- The
NOTE
ExperimentalNavigationTransitioninterface of the {{domxref("Navigation API", "Navigation API", "", "nocode")}} represents an ongoing navigation, that is, a navigation that hasn't yet reached the Navigationnavigatesuccess or Navigationnavigateerror stage.
- Navigator
The
Navigatorinterface represents the state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities.
- NavigatorLogin
The
NavigatorLogininterface of the Federated Credential Management (FedCM) API defines login functionality for federated identity providers (IdPs). Specifically, it enables a federated identity provider (IdP) to set its login status when a user signs into or out of the IdP.
- NavigatorUAData
- The
NOTE
ExperimentalNavigatorUADatainterface of the {{domxref("User-Agent Client Hints API", "", "", "nocode")}} returns information about the browser and operating system of a user.
- NetworkInformation
The
NetworkInformationinterface of the Network Information API provides information about the connection a device is using to communicate with the network and provides a means for scripts to be notified if the connection type changes.
TheNetworkInformationinterface cannot be instantiated. It is instead accessed through theconnectionproperty of the Navigator interface or the WorkerNavigator interface.
- Node
In addition, every kind of DOM node is represented by an interface based on
Node. These include Attr, CharacterData
(which Text, Comment, CDATASection and
ProcessingInstruction are all based on), and DocumentType.
- NodeIterator
The
NodeIteratorinterface represents an iterator to traverse nodes of a DOM subtree in document order.
- NodeList
NodeListobjects are collections of nodes, usually returned by properties such as ChildNodes and methods such as Document.QuerySelectorAll.
- NotRestoredReasonDetails
- The
NOTE
ExperimentalNotRestoredReasonDetailsinterface of the {{domxref("Performance API", "Performance API", "", "nocode")}} represents a single reason why a navigated page was blocked from using the back/forward cache (bfcache).
- NotRestoredReasons
- The
NOTE
ExperimentalNotRestoredReasonsinterface of the {{domxref("Performance API", "Performance API", "", "nocode")}} provides report data containing reasons why the current document was blocked from using the back/forward cache (bfcache) on navigation.
- Notification
The
Notificationinterface of the {{domxref("Notifications API", "", "", "nocode")}} is used to configure and display desktop notifications to the user.
- NotificationEvent
The
NotificationEventinterface of the {{domxref("Notifications API", "", "", "nocode")}} represents a notification event dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.
- OTPCredential
- The
NOTE
ExperimentalOTPCredentialinterface of the 'WebOTP API' is returned when a WebOTP Get(CredentialRequestOptions) call (i.e., invoked with anotpoption) fulfills. It includes acodeproperty that contains the retrieved one-time password (OTP).
- OfflineAudioCompletionEvent
The Web Audio API
OfflineAudioCompletionEventinterface represents events that occur when the processing of an OfflineAudioContext is terminated. The OfflineAudioContextcomplete event uses this interface.
- OfflineAudioContext
The
OfflineAudioContextinterface is an AudioContext interface representing an audio-processing graph built from linked together AudioNodes. In contrast with a standard AudioContext, anOfflineAudioContextdoesn't render the audio to the device hardware; instead, it generates it, as fast as it can, and outputs the result to an AudioBuffer.
- OffscreenCanvas
The
OffscreenCanvasinterface provides a canvas that can be rendered off screen, decoupling the DOM and the Canvas API so that the canvas element is no longer entirely dependent on the DOM.
Rendering operations can also be run inside a worker context, allowing you to run some tasks in a separate thread and avoid heavy work on the main thread.
- OffscreenCanvasRenderingContext2D
The
OffscreenCanvasRenderingContext2Dinterface is a CanvasRenderingContext2D rendering context for drawing to the bitmap of anOffscreenCanvasobject.
It is similar to theCanvasRenderingContext2Dobject, with the following differences:
- OrientationSensor
The
OrientationSensorinterface of the Sensor APIs is the base class for orientation sensors. This interface cannot be used directly. Instead it provides properties and methods accessed by interfaces that inherit from it.
- OscillatorNode
The
OscillatorNodeinterface represents a periodic waveform, such as a sine wave. It is an AudioScheduledSourceNode audio-processing module that causes a specified frequency of a given wave to be created—in effect, a constant tone.
- OverconstrainedError
The
OverconstrainedErrorinterface of the Media Capture and Streams API indicates that the set of desired capabilities for the current 'MediaStreamTrack' cannot currently be met. When this event is thrown on a MediaStreamTrack, it is muted until either the current constraints can be established or until satisfiable constraints are applied.
- PageRevealEvent
The
PageRevealEventevent object is made available inside handler functions for the Window.Pagereveal event.
- PageSwapEvent
The
PageSwapEventevent object is made available inside handler functions for the Window.Pageswap event.
- PageTransitionEvent
The
PageTransitionEventevent object is available inside handler functions for thepageshowandpagehideevents, fired when a document is being loaded or unloaded.
- PaintRenderingContext2D
The
PaintRenderingContext2Dinterface of the CSS Painting API is the API's rendering context for drawing to the bitmap. It implements a subset of the CanvasRenderingContext2D API, with the following exceptions:
- PaintSize
The
PaintSizeinterface of the CSS Painting API represents the size of the output bitmap that the author should draw.
- PaintWorkletGlobalScope
- The
NOTE
ExperimentalPaintWorkletGlobalScopeinterface of the CSS Painting API represents the global object available inside a paint Worklet.
- PannerNode
The
PannerNodeinterface defines an audio-processing object that represents the location, direction, and behavior of an audio source signal in a simulated physical space. This AudioNode uses right-hand Cartesian coordinates to describe the source's position as a vector and its orientation as a 3D directional cone.
- PasswordCredential
- The
NOTE
ExperimentalPasswordCredentialinterface of the Credential Management API provides information about a username/password pair. In supporting browsers an instance of this class may be passed in thecredentialmember of theinitobject for global Windowfetch.
- Path2D
The
Path2Dinterface of the Canvas 2D API is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of theCanvasRenderingContext2Dinterface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired.
- PaymentManager
- The
NOTE
ExperimentalPaymentManagerinterface of the {{domxref("Payment Handler API", "Payment Handler API", "", "nocode")}} is used to manage various aspects of payment app functionality.
- PaymentMethodChangeEvent
The
PaymentMethodChangeEventinterface of the Payment Request API describes the PaymentRequestpaymentmethodchange event which is fired by some payment handlers when the user switches payment instruments (e.g., a user selects a "store" card to make a purchase while using Apple Pay).
- PaymentRequest
The Payment Request API's
PaymentRequestinterface is the primary access point into the API, and lets web content and apps accept payments from the end user on behalf of the operator of the site or the publisher of the app.
- PaymentRequestEvent
- The
NOTE
ExperimentalPaymentRequestEventinterface of the {{domxref("Payment Handler API", "", "", "nocode")}} is the object passed to a payment handler when a PaymentRequest is made.
- PaymentRequestUpdateEvent
The
PaymentRequestUpdateEventinterface is used for events sent to a PaymentRequest instance when changes are made to shipping-related information for a pending PaymentRequest. Those events are:
- PaymentResponse
The
PaymentResponseinterface of the Payment Request API is returned after a user selects a payment method and approves a payment request.
- Pbkdf2Params
The
Pbkdf2Paramsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into DeriveKey(Union187, CryptoKey, Union187, bool, List<KeyUsage>), when using the PBKDF2 algorithm.
- Performance
The
Performanceinterface provides access to performance-related information for the current page.
- PerformanceElementTiming
- The
NOTE
ExperimentalPerformanceElementTiminginterface contains render timing information for image and text node elements the developer annotated with anelementtimingattribute for observation.
- PerformanceEntry
The
PerformanceEntryobject encapsulates a single performance metric that is part of the browser's performance timeline.
- PerformanceEventTiming
The
PerformanceEventTiminginterface of the Event Timing API provides insights into the latency of certain event types triggered by user interaction.
- PerformanceLongAnimationFrameTiming
- The
NOTE
ExperimentalPerformanceLongAnimationFrameTiminginterface is specified in the Long Animation Frames API and provides metrics on long animation frames (LoAFs) that occupy rendering and block other tasks from being executed.
- PerformanceLongTaskTiming
- The
NOTE
ExperimentalPerformanceLongTaskTiminginterface provides information about tasks that occupy the UI thread for 50 milliseconds or more.
- PerformanceMark
PerformanceMarkis an interface for PerformanceEntry objects with an EntryType of"mark".
- PerformanceMeasure
PerformanceMeasureis an abstract interface for PerformanceEntry objects with an EntryType of"measure". Entries of this type are created by calling Measure(string, Union158, string) to add a named Number (the measure) between two marks to the browser's performance timeline.
- PerformanceNavigation
- The legacy
IMPORTANT
DeprecatedPerformanceNavigationinterface represents information about how the navigation to the current document was done.
- PerformanceNavigationTiming
The
PerformanceNavigationTiminginterface provides methods and properties to store and retrieve metrics regarding the browser's document navigation events. For example, this interface can be used to determine how much time it takes to load or unload a document.
- PerformanceObserver
The
PerformanceObserverinterface is used to observe performance measurement events and be notified of new PerformanceEntry as they are recorded in the browser's performance timeline.
- PerformanceObserverEntryList
The
PerformanceObserverEntryListinterface is a list of PerformanceEntry that were explicitly observed via the Observe(PerformanceObserverInit) method.
- PerformancePaintTiming
The
PerformancePaintTiminginterface provides timing information about "paint" (also called "render") operations during web page construction. "Paint" refers to conversion of the render tree to on-screen pixels.
- PerformanceResourceTiming
The
PerformanceResourceTiminginterface enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources. An application can use the timing metrics to determine, for example, the length of time it takes to fetch a specific resource, such as an XMLHttpRequest, {{SVGElement("SVG","SVG element")}}, image, or script.
- PerformanceScriptTiming
- The
NOTE
ExperimentalPerformanceScriptTiminginterface is specified in the Long Animation Frames API and provides metrics on individual scripts that contribute to long animation frames (LoAFs).
- PerformanceServerTiming
The
PerformanceServerTiminginterface surfaces server metrics that are sent with the response in the Server-Timing HTTP header.
- PerformanceTiming
IMPORTANT
DeprecatedWARNING
This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
- PeriodicSyncEvent
- The
NOTE
ExperimentalPeriodicSyncEventinterface of the 'Web Periodic Background Synchronization API' provides a way to run tasks in the service worker with network connectivity.
- PeriodicSyncManager
- The
NOTE
ExperimentalPeriodicSyncManagerinterface of the 'Web Periodic Background Synchronization API' provides a way to register tasks to be run in a service worker at periodic intervals with network connectivity. These tasks are referred to as periodic background sync requests. AccessPeriodicSyncManagerthrough the 'ServiceWorkerRegistration.PeriodicSync'.
- PeriodicWave
The
PeriodicWaveinterface defines a periodic waveform that can be used to shape the output of an OscillatorNode.
- PermissionStatus
The
PermissionStatusinterface of the Permissions API provides the state of an object and an event handler for monitoring changes to said state.
- Permissions
The
Permissionsinterface of the Permissions API provides the core Permission API functionality, such as methods for querying and revoking permissions
- PictureInPictureEvent
The
PictureInPictureEventinterface represents picture-in-picture-related events, including HTMLVideoElemententerpictureinpicture, HTMLVideoElementleavepictureinpicture and PictureInPictureWindowresize.
- PictureInPictureWindow
The
PictureInPictureWindowinterface represents an object able to programmatically obtain thewidthandheightandresize eventof the floating video window.
- Plugin
- The
IMPORTANT
DeprecatedPlugininterface provides information about a browser plugin.
- PluginArray
- The
IMPORTANT
DeprecatedPluginArrayinterface is used to store a list of Plugin objects; it's returned by the Navigator.Plugins property. ThePluginArrayis not a JavaScript array, but has thelengthproperty and supports accessing individual items using bracket notation (plugins[2]), as well as viaitem(index)andnamedItem("name")methods.
- PointerEvent
The
PointerEventinterface represents the state of a DOM event produced by a pointer such as the geometry of the contact point, the device type that generated the event, the amount of pressure that was applied on the contact surface, etc.
- PopStateEvent
PopStateEventis an interface for the Windowpopstate event.
- Presentation
- The
NOTE
ExperimentalPresentationcan be defined as two possible user agents in the context: Controlling user agent and Receiving user agent.
- PresentationAvailability
- A
NOTE
ExperimentalPresentationAvailabilityobject is associated with available presentation displays and represents the presentation display availability for a presentation request. If the controlling user agent can monitor the list of available presentation displays in the background (without a pending request tostart()), thePresentationAvailabilityobject MUST be implemented in a controlling browsing context.
- PresentationConnection
- The
NOTE
ExperimentalPresentationConnectioninterface of the Presentation API provides methods and properties for managing a single presentation. Each presentation connection is represented by aPresentationConnectionobject. Both the controlling user agent and receiving user agent MUST implementPresentationConnection.
- PresentationConnectionAvailableEvent
- The
NOTE
ExperimentalPresentationConnectionAvailableEventinterface of the Presentation API is fired on a PresentationRequest when a connection associated with the object is created.
- PresentationConnectionCloseEvent
- The
NOTE
ExperimentalPresentationConnectionCloseEventinterface of the Presentation API is fired on a PresentationConnection when it is closed.
- PresentationConnectionList
NOTE
ExperimentalPresentationConnectionListis the collection of incoming presentation connections.
- PresentationReceiver
- The
NOTE
ExperimentalPresentationReceiverinterface of the Presentation API provides a means for a receiving browsing context to access controlling browsing contexts and communicate with them.
- PresentationRequest
- A
NOTE
ExperimentalPresentationRequestobject is used to initiate or reconnect to a presentation made by a controlling browsing context. ThePresentationRequestobject MUST be implemented in a controlling browsing context provided by a controlling user agent.
- PressureObserver
- The
NOTE
ExperimentalPressureObserverinterface is part of the Compute Pressure API and is used to observe the pressure changes of system resources such as the CPU.
- PressureRecord
- The
NOTE
ExperimentalPressureRecordinterface is part of the Compute Pressure API and describes the pressure trend of a source at a specific moment of transition.
- ProcessingInstruction
The
ProcessingInstructioninterface represents a processing instruction; that is, a Node which embeds an instruction targeting a specific application but that can be ignored by any other applications which don't recognize the instruction.
- Profiler
- The
NOTE
ExperimentalProfilerinterface of the JS Self-Profiling API enables you to create a profile of some part of your web application's execution.
- ProgressEvent
The
ProgressEventinterface represents events that measure the progress of an underlying process, like an HTTP request (e.g., anXMLHttpRequest, or the loading of the underlying resource of an img, audio, video, style or link).
- PromiseRejectionEvent
The
PromiseRejectionEventinterface represents events which are sent to the global script context when JavaScript Promises are rejected. These events are particularly useful for telemetry and debugging purposes.
- PublicKeyCredential
The
PublicKeyCredentialinterface provides information about a public key / private key pair, which is a credential for logging in to a service using an un-phishable and data-breach resistant asymmetric key pair instead of a password. It inherits from Credential, and is part of the Web Authentication API extension to the Credential Management API.
- PublicKeyCredentialCreationOptions
The
PublicKeyCredentialCreationOptionsdictionary represents the object passed to Create(CredentialCreationOptions) as the value of thepublicKeyoption: that is, when usingcreate()to create a public key credential using the Web Authentication API.
- PublicKeyCredentialRequestOptions
The
PublicKeyCredentialRequestOptionsdictionary represents the object passed to Get(CredentialRequestOptions) as the value of thepublicKeyoption.
- PushEvent
The
PushEventinterface of the Push API represents a push message that has been received. This event is sent to the global scope of a ServiceWorker. It contains the information sent from an application server to a PushSubscription.
- PushManager
The
PushManagerinterface of the Push API provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
- PushMessageData
The
PushMessageDatainterface of the Push API provides methods which let you retrieve the push data sent by a server in various formats.
- PushSubscription
The
PushSubscriptioninterface of the Push API provides a subscription's URL endpoint along with the public key and secrets that should be used for encrypting push messages to this subscription.
This information must be passed to the application server, using any desired application-specific method.
- PushSubscriptionOptions
The
PushSubscriptionOptionsinterface of the 'Push API' represents the options associated with a push subscription.
- RTCAudioSourceStats
The
RTCAudioSourceStatsdictionary of the WebRTC API provides statistics information about an audio track (MediaStreamTrack) that is attached to one or more senders (RTCRtpSender).
- RTCCertificate
The
RTCCertificateinterface of the WebRTC API provides an object representing a certificate that an RTCPeerConnection uses to authenticate.
- RTCCertificateStats
The
RTCCertificateStatsdictionary of the WebRTC API is used to report information about a certificate used by an RTCDtlsTransport and its underlying RTCIceTransport.
- RTCCodecStats
The
RTCCodecStatsdictionary of the WebRTC API provides statistics about a codec used by {{Glossary("RTP")}} streams that are being sent or received by the associated RTCPeerConnection object.
- RTCDTMFSender
The
RTCDTMFSenderinterface provides a mechanism for transmitting DTMF codes on a WebRTC RTCPeerConnection. You gain access to the connection'sRTCDTMFSenderthrough the Dtmf property on the audio track you wish to send DTMF with.
- RTCDTMFToneChangeEvent
The
RTCDTMFToneChangeEventinterface represents events sent to indicate that DTMF tones have started or finished playing. This interface is used by thetonechangeevent.
- RTCDataChannel
The
RTCDataChannelinterface represents a network channel which can be used for bidirectional peer-to-peer transfers of arbitrary data. Every data channel is associated with an RTCPeerConnection, and each peer connection can have up to a theoretical maximum of 65,534 data channels (the actual limit may vary from browser to browser).
- RTCDataChannelEvent
The
RTCDataChannelEventinterface
represents an event related to a specific RTCDataChannel.
- RTCDataChannelStats
The
RTCDataChannelStatsdictionary of the WebRTC API provides statistics related to one RTCDataChannel object on the connection.
- RTCDtlsTransport
The
RTCDtlsTransportinterface provides access to information about the Datagram Transport Layer Security (DTLS) transport over which a RTCPeerConnection's {{Glossary("RTP")}} and {{Glossary("RTCP")}} packets are sent and received by its RTCRtpSender and RTCRtpReceiver objects.
- RTCEncodedAudioFrame
The
RTCEncodedAudioFrameof the WebRTC API represents an encoded audio frame in the WebRTC receiver or sender pipeline, which may be modified using a WebRTC Encoded Transform.
- RTCEncodedVideoFrame
The
RTCEncodedVideoFrameof the WebRTC API represents an encoded video frame in the WebRTC receiver or sender pipeline, which may be modified using a WebRTC Encoded Transform.
- RTCError
The
RTCErrorinterface describes an error which has occurred while handling WebRTC operations. It's based upon the standard DOMException interface that describes general DOM errors.
- RTCErrorEvent
The WebRTC API's
RTCErrorEventinterface represents an error sent to a WebRTC object. It's based on the standard Event interface, but adds RTC-specific information describing the error, as shown below.
- RTCIceCandidate
The
RTCIceCandidateinterface—part of the WebRTC API—represents a candidate Interactive Connectivity Establishment ({{Glossary("ICE")}}) configuration which may be used to establish an RTCPeerConnection.
- RTCIceCandidatePair
The
RTCIceCandidatePairdictionary describes a pair of ICE candidates which together comprise a description of a viable connection between two WebRTC endpoints. It is used as the return value from GetSelectedCandidatePair() to identify the currently-selected candidate pair identified by the ICE agent.
- RTCIceCandidatePairStats
The
RTCIceCandidatePairStatsdictionary of the WebRTC API is used to report statistics that provide insight into the quality and performance of an RTCPeerConnection while connected and configured as described by the specified pair of {{Glossary("ICE")}} candidates.
- RTCIceCandidateStats
The
RTCIceCandidateStatsdictionary of the WebRTC API is used to report statistics related to an RTCIceCandidate.
- RTCIceParameters
The
RTCIceParametersdictionary specifies the username fragment and password assigned to an ICE session.
- RTCIceTransport
The
RTCIceTransportinterface provides access to information about the ICE transport layer over which the data is being sent and received.
This is particularly useful if you need to access state information about the connection.
- RTCIdentityAssertion
- The
NOTE
ExperimentalRTCIdentityAssertioninterface of the WebRTC API represents the identity of a remote peer of the current connection. If no peer has yet been set and verified, then this interface returnsnull. Once set it can't be changed.
- RTCInboundRtpStreamStats
The
RTCInboundRtpStreamStatsdictionary of the WebRTC API is used to report statistics related to the receiving end of an RTP stream on the local end of the RTCPeerConnection.
- RTCOutboundRtpStreamStats
The
RTCOutboundRtpStreamStatsdictionary of the WebRTC API is used to report metrics and statistics related to an outbound {{Glossary("RTP")}} stream being sent by an RTCRtpSender.
- RTCPeerConnection
The
RTCPeerConnectioninterface represents a WebRTC connection between the local computer and a remote peer.
It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed.
- RTCPeerConnectionIceErrorEvent
The
RTCPeerConnectionIceErrorEventinterface—based upon the Event interface—provides details pertaining to an {{Glossary("ICE")}} error announced by sending an RTCPeerConnection.Icecandidateerror event to the RTCPeerConnection object.
- RTCPeerConnectionIceEvent
The
RTCPeerConnectionIceEventinterface represents events that occur in relation to {{Glossary("ICE")}} candidates with the target, usually an RTCPeerConnection.
- RTCPeerConnectionStats
The
RTCPeerConnectionStatsdictionary of the WebRTC API provides information about the high level peer connection (RTCPeerConnection).
- RTCRemoteInboundRtpStreamStats
The
RTCRemoteInboundRtpStreamStatsdictionary of the WebRTC API is used to report statistics from the remote endpoint about a particular incoming RTP stream.
These will correspond to an outgoing RTP stream at the local end of the RTCPeerConnection.
- RTCRemoteOutboundRtpStreamStats
The
RTCRemoteOutboundRtpStreamStatsdictionary of the WebRTC API is used to report statistics from a remote endpoint about its outbound RTP stream.
This will correspond to an inbound stream that is currently being received by the local RTCPeerConnection object.
- RTCRtpReceiver
The
RTCRtpReceiverinterface of the WebRTC API manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection.
- RTCRtpScriptTransform
The
RTCRtpScriptTransforminterface of the WebRTC API is used to insert a WebRTC Encoded Transform (a TransformStream running in a worker thread) into the WebRTC sender and receiver pipelines.
- RTCRtpScriptTransformer
The
RTCRtpScriptTransformerinterface of the WebRTC API provides a worker-side Stream API interface that a WebRTC Encoded Transform can use to modify encoded media frames in the incoming and outgoing WebRTC pipelines.
- RTCRtpSender
The
RTCRtpSenderinterface provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer.
- RTCRtpTransceiver
The WebRTC interface
RTCRtpTransceiverdescribes a permanent pairing of an RTCRtpSender and an RTCRtpReceiver, along with some shared state.
- RTCSctpTransport
The
RTCSctpTransportinterface provides information which describes a Stream Control Transmission Protocol (SCTP) transport. This provides information about limitations of the transport, but also provides a way to access the underlying Datagram Transport Layer Security (DTLS) transport over which SCTP packets for all of an RTCPeerConnection's data channels are sent and received.
- RTCSessionDescription
The
RTCSessionDescriptioninterface describes one end of a connection—or potential connection—and how it's configured. EachRTCSessionDescriptionconsists of a description Type indicating which part of the offer/answer negotiation process it describes and of the {{Glossary("SDP")}} descriptor of the session.
- RTCStatsReport
The
RTCStatsReportinterface of the WebRTC API provides a statistics report for a RTCPeerConnection, RTCRtpSender, or RTCRtpReceiver.
- RTCTrackEvent
The WebRTC API interface
RTCTrackEventrepresents the RTCPeerConnection.Track event, which is sent when a new MediaStreamTrack is added to an RTCRtpReceiver which is part of the RTCPeerConnection.
- RTCTransformEvent
The
RTCTransformEventof the WebRTC API represent an event that is fired in a dedicated worker when an encoded frame has been queued for processing by a WebRTC Encoded Transform.
- RTCTransportStats
The
RTCTransportStatsdictionary of the WebRTC API provides information about the transport (RTCDtlsTransport and its underlying RTCIceTransport) used by a particular candidate pair.
- RTCVideoSourceStats
The
RTCVideoSourceStatsdictionary of the WebRTC API provides statistics information about a video track (MediaStreamTrack) that is attached to one or more senders (RTCRtpSender).
- RadioNodeList
The
RadioNodeListinterface represents a collection of elements in a {{HTMLElement("form")}} returned by a call to HTMLFormControlsCollection.NamedItem.
- Range
The
Rangeinterface represents a fragment of a document that can contain nodes and parts of text nodes.
- ReadableByteStreamController
The
ReadableByteStreamControllerinterface of the Streams API represents a controller for a readable byte stream.
It allows control of the state and internal queue of a ReadableStream with an underlying byte source, and enables efficient zero-copy transfer of data from the underlying source to a consumer when the stream's internal queue is empty.
- ReadableStream
The
ReadableStreaminterface of the Streams API represents a readable stream of byte data. The Fetch API offers a concrete instance of aReadableStreamthrough the Response.Body property of a Response object.
- ReadableStreamBYOBReader
The
ReadableStreamBYOBReaderinterface of the Streams API defines a reader for a ReadableStream that supports zero-copy reading from an underlying byte source.
It is used for efficient copying from underlying sources where the data is delivered as an "anonymous" sequence of bytes, such as files.
- ReadableStreamBYOBRequest
The
ReadableStreamBYOBRequestinterface of the Streams API represents a "pull request" for data from an underlying source that will made as a zero-copy transfer to a consumer (bypassing the stream's internal queues).
- ReadableStreamDefaultController
The
ReadableStreamDefaultControllerinterface of the Streams API represents a controller allowing control of a ReadableStream's state and internal queue. Default controllers are for streams that are not byte streams.
- ReadableStreamDefaultReader
The
ReadableStreamDefaultReaderinterface of the Streams API represents a default reader that can be used to read stream data supplied from a network (such as a fetch request).
- RelativeOrientationSensor
The
RelativeOrientationSensorinterface of the Sensor APIs describes the device's physical orientation without regard to the Earth's reference coordinate system.
- RemotePlayback
The
RemotePlaybackinterface of the 'Remote Playback API' allows the page to detect availability of remote playback devices, then connect to and control playing on these devices.
- Report
The
Reportinterface of the Reporting API represents a single report.
- ReportBody
The
ReportBodyinterface of the 'Reporting API' represents the body of a report. Individual report types inherit from this interface, adding specific attributes relevant to the particular report.
- ReportingObserver
The
ReportingObserverinterface of the Reporting API allows you to collect and access reports.
- ResizeObserver
The
ResizeObserverinterface reports changes to the dimensions of an 'Element''s content or border box, or the bounding box of an 'SVGElement'.
- ResizeObserverEntry
The
ResizeObserverEntryinterface represents the object passed to the 'ResizeObserver.ResizeObserver' constructor's callback function, which allows you to access the new dimensions of the Element or SVGElement being observed.
- ResizeObserverSize
The
ResizeObserverSizeinterface of the Resize Observer API is used by the ResizeObserverEntry interface to access the box sizing properties of the element being observed.
- RestrictionTarget
- The
NOTE
ExperimentalRestrictionTargetinterface of the {{domxref("Screen Capture API", "Screen Capture API", "", "nocode")}} provides a static method, FromElement(Element), which returns aRestrictionTargetinstance that can be used to restrict a captured video track to a specified DOM element.
- RsaHashedImportParams
The
RsaHashedImportParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into ImportKey(KeyFormat, Union188, Union187, bool, List<KeyUsage>) or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when importing any RSA-based key pair: that is, when the algorithm is identified as any of RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP.
- RsaHashedKeyGenParams
The
RsaHashedKeyGenParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into GenerateKey(Union187, bool, List<KeyUsage>), when generating any RSA-based key pair: that is, when the algorithm is identified as any of RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP.
- RsaOaepParams
The
RsaOaepParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Encrypt(Union187, CryptoKey, Union224), Decrypt(Union187, CryptoKey, Union224), WrapKey(KeyFormat, CryptoKey, CryptoKey, Union187), or UnwrapKey(KeyFormat, Union224, CryptoKey, Union187, Union187, bool, List<KeyUsage>), when using the RSA_OAEP algorithm.
- RsaPssParams
The
RsaPssParamsdictionary of the Web Crypto API represents the object that should be passed as thealgorithmparameter into Sign(Union187, CryptoKey, Union224) or Verify(Union187, CryptoKey, Union224, Union224), when using the RSA-PSS algorithm.
- SVGAElement
The
SVGAElementinterface provides access to the properties of an a element, as well as methods to manipulate them.
- SVGAngle
The
SVGAngleinterface is used to represent a value that can be an {{cssxref("<angle>")}} or {{cssxref("<number>")}} value.
- SVGAnimateElement
The
SVGAnimateElementinterface corresponds to the animate element.
- SVGAnimateMotionElement
The
SVGAnimateMotionElementinterface corresponds to the animateMotion element.
- SVGAnimateTransformElement
The
SVGAnimateTransformElementinterface corresponds to the animateTransform element.
- SVGAnimatedAngle
The
SVGAnimatedAngleinterface is used for attributes of basic type <angle> which can be animated.
- SVGAnimatedBoolean
The
SVGAnimatedBooleaninterface is used for attributes of type boolean which can be animated.
- SVGAnimatedEnumeration
The
SVGAnimatedEnumerationinterface describes attribute values which are constants from a particular enumeration and which can be animated.
- SVGAnimatedInteger
The
SVGAnimatedIntegerinterface is used for attributes of basic type <integer> which can be animated.
- SVGAnimatedLength
The
SVGAnimatedLengthinterface represents attributes of type <length> which can be animated.
- SVGAnimatedLengthList
The
SVGAnimatedLengthListinterface is used for attributes of type SVGLengthList which can be animated.
- SVGAnimatedNumber
The
SVGAnimatedNumberinterface represents attributes of type <number> which can be animated.
- SVGAnimatedNumberList
The
SVGAnimatedNumberListinterface represents a list of attributes of type <number> which can be animated.
- SVGAnimatedPreserveAspectRatio
The
SVGAnimatedPreserveAspectRatiointerface represents attributes of type SVGPreserveAspectRatio which can be animated.
- SVGAnimatedRect
The
SVGAnimatedRectinterface represents an SVGRect attribute that can be animated.
- SVGAnimatedString
The
SVGAnimatedStringinterface represents string attributes which can be animated from each SVG declaration. You need to create SVG attribute before doing anything else, everything should be declared inside this.
- SVGAnimatedTransformList
The
SVGAnimatedTransformListinterface represents attributes which take a list of numbers and which can be animated.
- SVGAnimationElement
The
SVGAnimationElementinterface is the base interface for all of the animation element interfaces: SVGAnimateElement, SVGSetElement, SVGAnimateColorElement, SVGAnimateMotionElement and SVGAnimateTransformElement.
- SVGClipPathElement
The
SVGClipPathElementinterface provides access to the properties of clipPath elements, as well as methods to manipulate them.
- SVGComponentTransferFunctionElement
The
SVGComponentTransferFunctionElementinterface represents a base interface used by the component transfer function interfaces.
- SVGDefsElement
The
SVGDefsElementinterface corresponds to the defs element.
- SVGDescElement
The
SVGDescElementinterface corresponds to the desc element.
- SVGDiscardElement
- The
IMPORTANT
DeprecatedSVGDiscardElementinterface is an interface for the deprecated<discard>element.
- SVGElement
All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the
SVGElementinterface.
- SVGEllipseElement
The
SVGEllipseElementinterface provides access to the properties of ellipse elements.
- SVGFEBlendElement
The
SVGFEBlendElementinterface corresponds to the feBlend element.
- SVGFEColorMatrixElement
The
SVGFEColorMatrixElementinterface corresponds to the feColorMatrix element.
- SVGFEComponentTransferElement
The
SVGFEComponentTransferElementinterface corresponds to the feComponentTransfer element.
- SVGFECompositeElement
The
SVGFECompositeElementinterface corresponds to the feComposite element.
- SVGFEConvolveMatrixElement
The
SVGFEConvolveMatrixElementinterface corresponds to the feConvolveMatrix element.
- SVGFEDiffuseLightingElement
The
SVGFEDiffuseLightingElementinterface corresponds to the feDiffuseLighting element.
- SVGFEDisplacementMapElement
The
SVGFEDisplacementMapElementinterface corresponds to the feDisplacementMap element.
- SVGFEDistantLightElement
The
SVGFEDistantLightElementinterface corresponds to the feDistantLight element.
- SVGFEDropShadowElement
The
SVGFEDropShadowElementinterface corresponds to the feDropShadow element.
- SVGFEFloodElement
The
SVGFEFloodElementinterface corresponds to the feFlood element.
- SVGFEFuncAElement
The
SVGFEFuncAElementinterface corresponds to the feFuncA element.
- SVGFEFuncBElement
The
SVGFEFuncBElementinterface corresponds to the feFuncB element.
- SVGFEFuncGElement
The
SVGFEFuncGElementinterface corresponds to the feFuncG element.
- SVGFEFuncRElement
The
SVGFEFuncRElementinterface corresponds to the feFuncR element.
- SVGFEGaussianBlurElement
The
SVGFEGaussianBlurElementinterface corresponds to the feGaussianBlur element.
- SVGFEImageElement
The
SVGFEImageElementinterface corresponds to the feImage element.
- SVGFEMergeElement
The
SVGFEMergeElementinterface corresponds to the feMerge element.
- SVGFEMergeNodeElement
The
SVGFEMergeNodeElementinterface corresponds to the feMergeNode element.
- SVGFEMorphologyElement
The
SVGFEMorphologyElementinterface corresponds to the feMorphology element.
- SVGFEOffsetElement
The
SVGFEOffsetElementinterface corresponds to the feOffset element.
- SVGFEPointLightElement
The
SVGFEPointLightElementinterface corresponds to the fePointLight element.
- SVGFESpecularLightingElement
The
SVGFESpecularLightingElementinterface corresponds to the feSpecularLighting element.
- SVGFESpotLightElement
The
SVGFESpotLightElementinterface corresponds to the feSpotLight element.
- SVGFETileElement
The
SVGFETileElementinterface corresponds to the feTile element.
- SVGFETurbulenceElement
The
SVGFETurbulenceElementinterface corresponds to the feTurbulence element.
- SVGFilterElement
The
SVGFilterElementinterface provides access to the properties of filter elements, as well as methods to manipulate them.
- SVGForeignObjectElement
The
SVGForeignObjectElementinterface provides access to the properties of foreignObject elements, as well as methods to manipulate them.
- SVGGElement
The
SVGGElementinterface corresponds to the g element.
- SVGGeometryElement
The
SVGGeometryElementinterface represents SVG elements whose rendering is defined by geometry with an equivalent path, and which can be filled and stroked. This includes paths and the basic shapes.
- SVGGradientElement
The
SVGGradientinterface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement.
- SVGGraphicsElement
The
SVGGraphicsElementinterface represents SVG elements whose primary purpose is to directly render graphics into a group.
- SVGImageElement
The
SVGImageElementinterface corresponds to the image element.
- SVGLength
The
SVGLengthinterface correspond to the <length> basic data type.
- SVGLengthList
The
SVGLengthListinterface defines a list of SVGLength objects. It is used for the BaseVal and AnimVal properties of SVGAnimatedLengthList.
- SVGLineElement
The
SVGLineElementinterface provides access to the properties of line elements, as well as methods to manipulate them.
- SVGLinearGradientElement
The
SVGLinearGradientElementinterface corresponds to the linearGradient element.
- SVGMPathElement
The
SVGMPathElementinterface corresponds to the mpath element.
- SVGMarkerElement
The
SVGMarkerElementinterface provides access to the properties of marker elements, as well as methods to manipulate them. The marker element defines the graphics used for drawing marks on a shape.
- SVGMaskElement
The
SVGMaskElementinterface provides access to the properties of mask elements, as well as methods to manipulate them.
- SVGMetadataElement
The
SVGMetadataElementinterface corresponds to the metadata element.
- SVGNumber
The
SVGNumberinterface corresponds to the {{cssxref("<number>")}} basic data type.
- SVGNumberList
The
SVGNumberListinterface defines a list of numbers.
- SVGPathElement
The
SVGPathElementinterface corresponds to the path element.
- SVGPatternElement
The
SVGPatternElementinterface corresponds to the pattern element.
- SVGPointList
The
SVGPointListinterface represents a list of DOMPoint objects.
- SVGPolygonElement
The
SVGPolygonElementinterface provides access to the properties of polygon elements, as well as methods to manipulate them.
- SVGPolylineElement
The
SVGPolylineElementinterface provides access to the properties of polyline elements, as well as methods to manipulate them.
- SVGPreserveAspectRatio
The
SVGPreserveAspectRatiointerface corresponds to the preserveAspectRatio attribute.
- SVGRadialGradientElement
The
SVGRadialGradientElementinterface corresponds to the RadialGradient element.
- SVGRectElement
The
SVGRectElementinterface provides access to the properties of rect elements, as well as methods to manipulate them.
- SVGSVGElement
The
SVGSVGElementinterface provides access to the properties of svg elements, as well as methods to manipulate them. This interface contains also various miscellaneous commonly-used utility methods, such as matrix operations and the ability to control the time of redraw on visual rendering devices.
- SVGScriptElement
The
SVGScriptElementinterface corresponds to the SVG script element.
- SVGSetElement
The
SVGSetElementinterface corresponds to the set element.
- SVGStopElement
The
SVGStopElementinterface corresponds to the stop element.
- SVGStringList
The
SVGStringListinterface defines a list of strings.
- SVGStyleElement
The
SVGStyleElementinterface corresponds to the SVG style element.
- SVGSwitchElement
The
SVGSwitchElementinterface corresponds to the switch element.
- SVGSymbolElement
The
SVGSymbolElementinterface corresponds to the symbol element.
- SVGTSpanElement
The
SVGTSpanElementinterface represents a tspan element.
- SVGTextContentElement
The
SVGTextContentElementinterface is implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, and SVGTextPathElement.
- SVGTextElement
The
SVGTextElementinterface corresponds to the text elements.
- SVGTextPathElement
The
SVGTextPathElementinterface corresponds to the textPath element.
- SVGTextPositioningElement
The
SVGTextPositioningElementinterface is implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement and SVGTSpanElement.
- SVGTitleElement
The
SVGTitleElementinterface corresponds to the title element.
- SVGTransform
The
SVGTransforminterface reflects one of the component transformations within an SVGTransformList; thus, anSVGTransformobject corresponds to a single component (e.g.,scale(…)ormatrix(…)) within a transform attribute.
- SVGTransformList
The
SVGTransformListinterface defines a list of SVGTransform objects.
- SVGUnitTypes
The
SVGUnitTypesinterface defines a commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes.
- SVGViewElement
The
SVGViewElementinterface provides access to the properties of view elements, as well as methods to manipulate them.
- Sanitizer
- The
NOTE
ExperimentalSanitizerinterface of the HTML Sanitizer API defines a configuration object that specifies what elements, attributes and comments are allowed or should be removed when inserting strings of HTML into an Element or ShadowRoot, or when parsing an HTML string into a Document.
- SanitizerConfig
- The
NOTE
ExperimentalSanitizerConfigdictionary of the HTML Sanitizer API represents a sanitizer configuration object.
The configuration specifies what elements, attributes and comments are allowed or should be removed when inserting strings of HTML into an Element or ShadowRoot, or when parsing an HTML string into a Document.
- Scheduler
The
Schedulerinterface of the Prioritized Task Scheduling API provides methods for scheduling prioritized tasks.
- Scheduling
- The
NOTE
ExperimentalSchedulingobject provides methods and properties to control scheduling tasks within the current document.
- Screen
The
Screeninterface represents a screen, usually the one on which the current window is being rendered, and is obtained using Screen.
- ScreenDetailed
- The
NOTE
ExperimentalScreenDetailedinterface of the Window Management API represents detailed information about one specific screen available to the user's device.
- ScreenDetails
- The
NOTE
ExperimentalScreenDetailsinterface of the Window Management API represents the details of all the screens available to the user's device.
- ScreenOrientation
The
ScreenOrientationinterface of the Screen Orientation API provides information about the current orientation of the document.
- ScriptProcessorNode
- The
IMPORTANT
DeprecatedScriptProcessorNodeinterface allows the generation, processing, or analyzing of audio using JavaScript.
- ScrollTimeline
The
ScrollTimelineinterface of the {{domxref("Web Animations API", "Web Animations API", "", "nocode")}} represents a scroll progress timeline (see CSS scroll-driven animations for more details).
- SecurePaymentConfirmationRequest
The
SecurePaymentConfirmationRequestdictionary describes input to the Payment Request API when used to authenticate a user during an e-commerce transaction using SPC with Payment Request API.
- SecurityPolicyViolationEvent
The
SecurityPolicyViolationEventinterface inherits from Event, and represents the event object of asecuritypolicyviolationevent sent on an Elementsecuritypolicyviolation, Documentsecuritypolicyviolation, or {{domxref("WorkerGlobalScope/securitypolicyviolation_event", "worker","","nocode")}} when its Content Security Policy (CSP) is violated.
- Selection
A
Selectionobject represents the range of text selected by the user or the current position of the caret. Each Document is associated with a unique selection object, which can be retrieved by GetSelection() or GetSelection() and then be examined and modified.
- Sensor
The
Sensorinterface of the Sensor APIs is the base class for all the other sensor interfaces. This interface cannot be used directly. Instead it provides properties, event handlers, and methods accessed by interfaces that inherit from it.
- SensorErrorEvent
The
SensorErrorEventinterface of the Sensor APIs provides information about errors thrown by a 'Sensor' or derived interface.
- Serial
- The
NOTE
ExperimentalSerialinterface of the Web Serial API provides attributes and methods for finding and connecting to serial ports from a web page.
- SerialPort
- The
NOTE
ExperimentalSerialPortinterface of the Web Serial API provides access to a serial port on the host device.
- ServiceWorker
The
ServiceWorkerinterface of the Service Worker API provides a reference to a service worker. Multiple browsing context (e.g., pages, workers, etc.) can be associated with the same service worker, each through a uniqueServiceWorkerobject.
- ServiceWorkerContainer
The
ServiceWorkerContainerinterface of the Service Worker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.
- ServiceWorkerGlobalScope
The
ServiceWorkerGlobalScopeinterface of the Service Worker API represents the global execution context of a service worker.
- ServiceWorkerRegistration
The
ServiceWorkerRegistrationinterface of the Service Worker API represents the service worker registration. You register a service worker to control one or more pages that share the same origin.
- ShadowRoot
The
ShadowRootinterface of the Shadow DOM API is the root node of a DOM subtree that is rendered separately from a document's main DOM tree.
- SharedStorage
- The
NOTE
ExperimentalSharedStorageinterface of the {{domxref("Shared Storage API", "Shared Storage API", "", "nocode")}} represents the shared storage for a particular origin, defining methods to write data to the shared storage.
- SharedStorageWorklet
- The
NOTE
ExperimentalSharedStorageWorkletinterface of the {{domxref("Shared Storage API", "Shared Storage API", "", "nocode")}} represents the shared storage worklet for the current origin.
- SharedStorageWorkletGlobalScope
- The
NOTE
ExperimentalSharedStorageWorkletGlobalScopeinterface of the {{domxref("Shared Storage API", "Shared Storage API", "", "nocode")}} represents the global scope of a SharedStorageWorklet module.
- SharedWorker
The
SharedWorkerinterface represents a specific kind of worker that can be accessed from several browsing contexts, such as several windows, iframes or even workers. They implement an interface different than dedicated workers and have a different global scope, SharedWorkerGlobalScope.
- SharedWorkerGlobalScope
The
SharedWorkerGlobalScopeobject (the SharedWorker global scope) is accessible through the Self keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the JavaScript Reference. See the complete list of functions available to workers.
- SnapEvent
- The
NOTE
ExperimentalSnapEventinterface defines the event object for the Elementscrollsnapchanging and Elementscrollsnapchange events. Respectively, these fire on a scroll container when the browser determines that a new scroll snap target is pending (will be selected when the current scroll gesture ends), and when a new snap target is selected.
- SourceBuffer
The
SourceBufferinterface represents a chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object. This can be made up of one or several media segments.
- SourceBufferList
The
SourceBufferListinterface represents a simple container list for multiple SourceBuffer objects.
- SpeechGrammar
- The
IMPORTANT
DeprecatedSpeechGrammarinterface of the Web Speech API represents a set of words or patterns of words that we want the recognition service to recognize.
- SpeechGrammarList
- The
NOTE
ExperimentalSpeechGrammarListinterface of the Web Speech API represents a list of SpeechGrammar objects containing words or patterns of words that we want the recognition service to recognize.
- SpeechRecognition
The
SpeechRecognitioninterface of the Web Speech API is the controller interface for the recognition service; this also handles the SpeechRecognitionEvent sent from the recognition service.
- SpeechRecognitionAlternative
The
SpeechRecognitionAlternativeinterface of the Web Speech API represents a single word that has been recognized by the speech recognition service.
- SpeechRecognitionErrorEvent
The
SpeechRecognitionErrorEventinterface of the Web Speech API represents error messages from the recognition service.
- SpeechRecognitionEvent
The
SpeechRecognitionEventinterface of the Web Speech API represents the event object for the SpeechRecognition.Result and SpeechRecognition.Nomatch events, and contains all the data associated with an interim or final speech recognition result.
- SpeechRecognitionResult
The
SpeechRecognitionResultinterface of the Web Speech API represents a single recognition match, which may contain multiple SpeechRecognitionAlternative objects.
- SpeechRecognitionResultList
The
SpeechRecognitionResultListinterface of the Web Speech API represents a list of SpeechRecognitionResult objects, or a single one if results are being captured in Continuous mode.
- SpeechSynthesis
The
SpeechSynthesisinterface of the Web Speech API is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides.
- SpeechSynthesisErrorEvent
The
SpeechSynthesisErrorEventinterface of the Web Speech API contains information about any errors that occur while processing SpeechSynthesisUtterance objects in the speech service.
- SpeechSynthesisEvent
The
SpeechSynthesisEventinterface of the Web Speech API contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service.
- SpeechSynthesisUtterance
The
SpeechSynthesisUtteranceinterface of the Web Speech API represents a speech request.
It contains the content the speech service should read and information about how to read it (e.g., language, pitch and volume.)
- SpeechSynthesisVoice
The
SpeechSynthesisVoiceinterface of the Web Speech API represents a voice that the system supports.
EverySpeechSynthesisVoicehas its own relative speech service including information about language, name and URI.
- StaticRange
The DOM
StaticRangeinterface extends AbstractRange to provide a method to specify a range of content in the DOM whose contents don't update to reflect changes which occur within the DOM tree.
- StereoPannerNode
The
StereoPannerNodeinterface of the Web Audio API represents a simple stereo panner node that can be used to pan an audio stream left or right. It is an AudioNode audio-processing module that positions an incoming audio stream in a stereo image using a low-cost equal-power panning algorithm.
- Storage
The
Storageinterface of the Web Storage API provides access to a particular domain's session or local storage. It allows, for example, the addition, modification, or deletion of stored data items.
- StorageAccessHandle
The
StorageAccessHandleinterface represents access to unpartitioned state granted by a call to RequestStorageAccess().
- StorageEvent
The
StorageEventinterface is implemented by the Windowstorage event, which is
sent to a window
when a storage area the window has access to is changed within the context of another document.
- StorageManager
The
StorageManagerinterface of the Storage API provides an interface for managing persistence permissions and estimating available storage. You can get a reference to this interface using either Navigator.Storage or WorkerNavigator.Storage.
- StylePropertyMap
The
StylePropertyMapinterface of the CSS Typed Object Model API provides a representation of a CSS declaration block that is an alternative to CSSStyleDeclaration.
- StylePropertyMapReadOnly
The
StylePropertyMapReadOnlyinterface of the CSS Typed Object Model API provides a read-only representation of a CSS declaration block that is an alternative to CSSStyleDeclaration. Retrieve an instance of this interface using 'Element.ComputedStyleMap'.
- StyleSheet
An object implementing the
StyleSheetinterface represents a single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface.
- StyleSheetList
The
StyleSheetListinterface represents a list of CSSStyleSheet objects. An instance of this object can be returned by Document.StyleSheets.
- SubmitEvent
The
SubmitEventinterface defines the object used to represent an {{Glossary("HTML")}} form's Submit() event. This event is fired at the {{HTMLElement("form")}} when the form's submit action is invoked.
- SubtleCrypto
The
SubtleCryptointerface of the Web Crypto API provides a number of low-level cryptographic functions.
- SyncEvent
The
SyncEventinterface of the {{domxref("Background Synchronization API", "", "", "nocode")}} represents a sync action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.
- SyncManager
The
SyncManagerinterface of the {{domxref("Background Synchronization API", "", "", "nocode")}} provides an interface for registering and listing sync registrations.
- TaskAttributionTiming
- The
NOTE
ExperimentalTaskAttributionTiminginterface returns information about the work involved in a long task and its associate frame context. The frame context, also called the container, is the iframe, embed or object that is being implicated, on the whole, for a long task.
- TaskController
The
TaskControllerinterface of the Prioritized Task Scheduling API represents a controller object that can be used to both abort and change the priority of one or more prioritized tasks.
If there is no need to change task priorities, then AbortController can be used instead.
- TaskPriorityChangeEvent
The
TaskPriorityChangeEventis the interface for theprioritychangeevent.
- TaskSignal
The
TaskSignalinterface of the Prioritized Task Scheduling API represents a signal object that allows you to communicate with a prioritized task, and abort it or change the priority (if required) via a 'TaskController' object.
- TextDecoder
The
TextDecoderinterface represents a decoder for a specific text encoding, such asUTF-8,ISO-8859-2, orGBK. A decoder takes an array of bytes as input and returns a JavaScript string.
- TextDecoderStream
The
TextDecoderStreaminterface of the 'Encoding API' converts a stream of text in a binary encoding, such as UTF-8 etc., to a stream of strings.
It is the streaming equivalent of TextDecoder.
- TextEncoder
The
TextEncoderinterface enables you to character encoding a JavaScript string using UTF-8.
- TextEncoderStream
The
TextEncoderStreaminterface of the 'Encoding API' converts a stream of strings into bytes in the UTF-8 encoding. It is the streaming equivalent of TextEncoder.
- TextEvent
- The
IMPORTANT
DeprecatedTextEventinterface is a legacy UI event interface for reporting changes to text UI elements.
- TextFormat
- The
NOTE
ExperimentalTextFormatinterface represents specific formatting that should be applied to a range of text in an editable text region that's attached to an EditContext instance. The text formatting is requested by the {{glossary("Input Method Editor")}} (IME) window that the user is composing text with.
- TextFormatUpdateEvent
- The
NOTE
ExperimentalTextFormatUpdateEventinterface is a DOM event that represents a list of text formats that an {{glossary("Input Method Editor")}} (IME) window wants to apply to the text being composed in an editable region that's attached to an EditContext instance.
- TextMetrics
The
TextMetricsinterface represents the dimensions of a piece of text in the canvas; aTextMetricsinstance can be retrieved using the CanvasRenderingContext2D.MeasureText method.
- TextTrack
The
TextTrackinterface of the WebVTT API represents a text track associated with a media element.
- TextTrackCue
The
TextTrackCueinterface of the WebVTT API is the abstract base class for the various derived cue types, such as VTTCue; you will work with these derived types rather than the base class.
- TextTrackCueList
The
TextTrackCueListinterface of the WebVTT API is an array-like object that represents a dynamically updating list of TextTrackCue objects.
- TextTrackList
The
TextTrackListinterface is used to represent a list of the text tracks defined for the associated video or audio element, with each track represented by a separate TextTrack object in the list.
- TextUpdateEvent
- The
NOTE
ExperimentalTextUpdateEventinterface is a DOM event that represents a text or selection update in an editable text region that's attached to an EditContext instance.
- TimeEvent
The
TimeEventinterface, a part of SVG SMIL animation, provides specific contextual information associated with Time events.
- TimeRanges
A
TimeRangesobject includes one or more ranges of time, each specified by a starting time offset and an ending time offset. You reference each time range by using thestart()andend()methods, passing the index number of the time range you want to retrieve.
- ToggleEvent
The
ToggleEventinterface represents an event notifying the user an Element's state has changed.
- Touch
The
Touchinterface represents a single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad.
- TouchEvent
The
TouchEventinterface represents an UIEvent which is sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth.
- TouchList
The
TouchListinterface represents a list of contact points on a touch surface. For example, if the user has three fingers on the touch surface (such as a screen or trackpad), the correspondingTouchListobject would have one Touch object for each finger, for a total of three entries.
- TrackEvent
The
TrackEventinterface of the HTML DOM API is used for events which represent changes to a set of available tracks on an HTML media element; these events areaddtrackandremovetrack.
- TransformStream
The
TransformStreaminterface of the Streams API represents a concrete implementation of the pipe chain transform stream concept.
- TransformStreamDefaultController
The
TransformStreamDefaultControllerinterface of the Streams API provides methods to manipulate the associated ReadableStream and WritableStream.
- TransitionEvent
The
TransitionEventinterface represents events providing information related to transitions.
- TreeWalker
The
TreeWalkerobject represents the nodes of a document subtree and a position within them.
- TrustedHTML
The
TrustedHTMLinterface of the {{domxref("Trusted Types API", "", "", "nocode")}} represents a string that a developer can insert into an injection sink that will render it as HTML. These objects are created via CreateHTML(string, params dynamic[]) and therefore have no constructor.
- TrustedScript
The
TrustedScriptinterface of the {{domxref("Trusted Types API", "", "", "nocode")}} represents a string with an uncompiled script body that a developer can insert into an injection sink that might execute the script. These objects are created via CreateScript(string, params dynamic[]) and therefore have no constructor.
- TrustedScriptURL
The
TrustedScriptURLinterface of the {{domxref("Trusted Types API", "", "", "nocode")}} represents a string that a developer can insert into an injection sink that will parse it as a URL of an external script. These objects are created via CreateScriptURL(string, params dynamic[]) and therefore have no constructor.
- TrustedTypePolicy
The
TrustedTypePolicyinterface of the {{domxref("Trusted Types API", "", "", "nocode")}} defines a group of functions which createTrustedTypeobjects.
- TrustedTypePolicyFactory
The
TrustedTypePolicyFactoryinterface of the {{domxref("Trusted Types API", "", "", "nocode")}} creates policies and allows the verification of Trusted Type objects against created policies.
- UIEvent
The
UIEventinterface represents simple user interface events. It is part of the UI Events API, which includes various event types and interfaces related to user interactions.
- URL
The
URLinterface is used to parse, construct, normalize, and encode URL. It works by providing properties which allow you to easily read and modify the components of a URL.
- URLPattern
The
URLPatterninterface of the {{domxref("URL Pattern API", "", "", "nocode")}} matches URLs or parts of URLs against a pattern. The pattern can contain capturing groups that extract parts of the matched URL.
- URLSearchParams
The
URLSearchParamsinterface defines utility methods to work with the query string of a URL.
- USB
- The
NOTE
ExperimentalUSBinterface of the WebUSB API provides attributes and methods for finding and connecting USB devices from a web page.
- USBAlternateInterface
- The
NOTE
ExperimentalUSBAlternateInterfaceinterface of the WebUSB API provides information about a particular configuration of an interface provided by the USB device. An interface includes one or more alternate settings which can configure a set of endpoints based on the operating mode of the device.
- USBConfiguration
- The
NOTE
ExperimentalUSBConfigurationinterface of the WebUSB API provides information about a particular configuration of a USB device and the interfaces that it supports.
- USBConnectionEvent
- The
NOTE
ExperimentalUSBConnectionEventinterface of the 'WebUSB API' is the event type passed toUSBUSB.Connect and USB.Disconnect events when the user agent detects that a new USB device has been connected or disconnected.
- USBDevice
- The
NOTE
ExperimentalUSBDeviceinterface of the WebUSB API provides access to metadata about a paired USB device and methods for controlling it.
- USBEndpoint
- The
NOTE
ExperimentalUSBEndpointinterface of the WebUSB API provides information about an endpoint provided by the USB device. An endpoint represents a unidirectional data stream into or out of a device.
- USBInTransferResult
- The
NOTE
ExperimentalUSBInTransferResultinterface of the WebUSB API provides the result from a call to thetransferIn()andcontrolTransferIn()methods of theUSBDeviceinterface. It represents the result from requesting a transfer of data from the USB device to the USB host.
- USBInterface
- The
NOTE
ExperimentalUSBInterfaceinterface of the WebUSB API provides information about an interface provided by the USB device. An interface represents a feature of the device which implements a particular protocol and may contain endpoints for bidirectional communication.
- USBIsochronousInTransferPacket
- The
NOTE
ExperimentalUSBIsochronousInTransferPacketinterface of the WebUSB API is part of the response from a call to theisochronousTransferIn()method of theUSBDeviceinterface. It represents the status of an individual packet from a request to transfer data from the USB device to the USB host over an isochronous endpoint.
- USBIsochronousInTransferResult
- The
NOTE
ExperimentalUSBIsochronousInTransferResultinterface of the WebUSB API provides the result from a call to theisochronousTransferIn()method of theUSBDeviceinterface. It represents the result from requesting a transfer of data from the USB device to the USB host.
- USBIsochronousOutTransferPacket
- The
NOTE
ExperimentalUSBIsochronousOutTransferPacketinterface of the WebUSB API is part of the response from a call to theisochronousTransferOut()method of theUSBDeviceinterface. It represents the status of an individual packet from a request to transfer data from the USB host to the USB device over an isochronous endpoint.
- USBIsochronousOutTransferResult
- The
NOTE
ExperimentalUSBIsochronousOutTransferResultinterface of the WebUSB API provides the result from a call to theisochronousTransferOut()method of theUSBDeviceinterface. It represents the result from requesting a transfer of data from the USB host to the USB device.
- USBOutTransferResult
- The
NOTE
ExperimentalUSBOutTransferResultinterface of the WebUSB API provides the result from a call to thetransferOut()andcontrolTransferOut()methods of theUSBDeviceinterface. It represents the result from requesting a transfer of data from the USB host to the USB device.
- UserActivation
The
UserActivationinterface provides information about whether a user is currently interacting with the page, or has completed an interaction since page load.
- VTTCue
The
VTTCueinterface of the WebVTT API represents a cue that can be added to the text track associated with a particular video (or other media).
- VTTRegion
The
VTTRegioninterface of the WebVTT API describes a portion of the video to render a VTTCue onto.
- ValidityState
The
ValidityStateinterface represents the validity states that an element can be in, with respect to constraint validation. Together, they help explain why an element's value fails to validate, if it's not valid.
- VideoColorSpace
The
VideoColorSpaceinterface of the 'WebCodecs API' represents the color space of a video.
- VideoDecoder
The
VideoDecoderinterface of the 'WebCodecs API' decodes chunks of video.
- VideoEncoder
The
VideoEncoderinterface of the 'WebCodecs API' encodes VideoFrame objects into EncodedVideoChunks.
- VideoFrame
The
VideoFrameinterface of the Web Codecs API represents a frame of a video.
- VideoPlaybackQuality
A
VideoPlaybackQualityobject is returned by the GetVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video.
- VideoTrack
The
VideoTrackinterface represents a single video track from a video element.
- VideoTrackGenerator
- The
NOTE
ExperimentalVideoTrackGeneratorinterface of the Insertable Streams for MediaStreamTrack API has a WritableStream property that acts as a MediaStreamTrack source, by consuming a stream of VideoFrames as input.
- VideoTrackList
The
VideoTrackListinterface is used to represent a list of the video tracks contained within a {{HTMLElement("video")}} element, with each track represented by a separate VideoTrack object in the list.
- ViewTimeline
The
ViewTimelineinterface of the {{domxref("Web Animations API", "Web Animations API", "", "nocode")}} represents a view progress timeline (see CSS scroll-driven animations for more details).
- ViewTransition
The
ViewTransitioninterface of the {{domxref("View Transition API", "View Transition API", "", "nocode")}} represents an active view transition, and provides functionality to react to the transition reaching different states (e.g., ready to run the animation, or animation finished) or skip the transition altogether.
- VirtualKeyboard
- The
NOTE
ExperimentalVirtualKeyboardinterface of the VirtualKeyboard API is useful on devices that have on-screen virtual keyboards, such as tablets, mobile phones, or other devices where a hardware keyboard may not be available.
- VisibilityStateEntry
- The
NOTE
ExperimentalVisibilityStateEntryinterface provides timings of page visibility state changes, i.e., when a tab changes from the foreground to the background or vice versa.
- VisualViewport
The
VisualViewportinterface of the {{domxref("Visual Viewport API", "", "", "nocode")}} represents the visual viewport for a given window. For a page containing iframes, each iframe, as well as the containing page, will have a unique window object. Each window on a page will have a uniqueVisualViewportrepresenting the properties associated with that window.
- WGSLLanguageFeatures
The
WGSLLanguageFeaturesinterface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is a setlike object that reports the WGSL language extensions supported by the WebGPU implementation.
- WakeLock
The
WakeLockinterface of the Screen Wake Lock API can be used to request a lock that prevents device screens from dimming or locking when an application needs to keep running.
- WakeLockSentinel
The
WakeLockSentinelinterface of the Screen Wake Lock API can be used to monitor the status of the platform screen wake lock, and manually release the lock when needed.
- WaveShaperNode
The
WaveShaperNodeinterface represents a non-linear distorter.
- WebGL2RenderingContext
The WebGL2RenderingContext interface provides the OpenGL ES 3.0 rendering context for the drawing surface of an HTML canvas element.
- WebGLActiveInfo
The WebGLActiveInfo interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.GetActiveAttrib and WebGLRenderingContext.GetActiveUniform methods.
- WebGLBuffer
The WebGLBuffer interface is part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.
- WebGLContextEvent
The WebGLContextEvent interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context.
- WebGLFramebuffer
The WebGLFramebuffer interface is part of the WebGL API and represents a collection of buffers that serve as a rendering destination.
- WebGLObject
- The
NOTE
ExperimentalWebGLObjectis part of the WebGL API and is the parent interface for all WebGL objects.
- WebGLProgram
The
WebGLProgramis part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL).
- WebGLQuery
The
WebGLQueryinterface is part of the WebGL 2 API and provides ways to asynchronously query for information. By default, occlusion queries and primitive queries are available.
- WebGLRenderbuffer
The WebGLRenderbuffer interface is part of the WebGL API and represents a buffer that can contain an image, or that can be a source or target of a rendering operation.
- WebGLRenderingContext
The
WebGLRenderingContextinterface provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML canvas element.
- WebGLSampler
The
WebGLSamplerinterface is part of the WebGL 2 API and stores sampling parameters for WebGLTexture access inside of a shader.
- WebGLShader
The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders.
- WebGLShaderPrecisionFormat
The WebGLShaderPrecisionFormat interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.GetShaderPrecisionFormat method.
- WebGLSync
The
WebGLSyncinterface is part of the WebGL 2 API and is used to synchronize activities between the GPU and the application.
- WebGLTexture
The WebGLTexture interface is part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.
- WebGLTransformFeedback
The
WebGLTransformFeedbackinterface is part of the WebGL 2 API and enables transform feedback, which is the process of capturing primitives generated by vertex processing. It allows to preserve the post-transform rendering state of an object and resubmit this data multiple times.
- WebGLUniformLocation
The WebGLUniformLocation interface is part of the WebGL API and represents the location of a uniform variable in a shader program.
- WebGLVertexArrayObject
The
WebGLVertexArrayObjectinterface is part of the WebGL 2 API, represents vertex array objects (VAOs) pointing to vertex array data, and provides names for different sets of vertex data.
- WebSocket
The
WebSocketobject provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
- WebTransport
The
WebTransportinterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} provides functionality to enable a user agent to connect to an HTTP/3 server, initiate reliable and unreliable transport in either or both directions, and close the connection once it is no longer needed.
- WebTransportBidirectionalStream
The
WebTransportBidirectionalStreaminterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} represents a bidirectional stream created by a server or a client that can be used for reliable transport. Provides access to a WebTransportReceiveStream for reading incoming data, and a WebTransportSendStream for writing outgoing data.
- WebTransportDatagramDuplexStream
The
WebTransportDatagramDuplexStreaminterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} represents a duplex stream that can be used for unreliable transport of datagrams between client and server. Provides access to a ReadableStream for reading incoming datagrams, a WritableStream for writing outgoing datagrams, and various settings and statistics related to the stream.
- WebTransportError
The
WebTransportErrorinterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} represents an error related to the API, which can arise from server errors, network connection problems, or client-initiated abort operations (for example, arising from a Abort(dynamic) call).
- WebTransportReceiveStream
- The
NOTE
ExperimentalWebTransportReceiveStreaminterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} is a ReadableStream that can be used to read from an incoming unidirectional or bidirectional WebTransport stream.
- WebTransportSendStream
- The
NOTE
ExperimentalWebTransportSendStreaminterface of the {{domxref("WebTransport API", "WebTransport API", "", "nocode")}} is a specialized WritableStream that is used to send outbound data in both unidirectional or bidirectional WebTransport streams.
- WheelEvent
The
WheelEventinterface represents events that occur due to the user moving a mouse wheel or similar input device.
- Window
The
Windowinterface represents a window containing a DOM document; thedocumentproperty points to the DOM document loaded in that window.
- WindowClient
The
WindowClientinterface of the ServiceWorker API represents the scope of a service worker client that is a document in a browsing context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.
- WindowControlsOverlay
- The
NOTE
ExperimentalWindowControlsOverlayinterface of the Window Controls Overlay API exposes information about the geometry
of the title bar area in desktop Progressive Web Apps, and an event to know whenever it changes. This interface is accessible from 'Navigator.WindowControlsOverlay'.
- WindowControlsOverlayGeometryChangeEvent
- The
NOTE
ExperimentalWindowControlsOverlayGeometryChangeEventinterface of the Window Controls Overlay API is passed to WindowControlsOverlaygeometrychange when the size or visibility of a desktop Progress Web App's title bar region changes.
- Worker
The
Workerinterface of the Web Workers API represents a background task that can be created via script, which can send messages back to its creator.
- WorkerGlobalScope
The
WorkerGlobalScopeinterface of the Web Workers API is an interface representing the scope of any worker. Workers have no browsing context; this scope contains the information usually conveyed by Window objects — in this case event handlers, the console or the associated WorkerNavigator object. EachWorkerGlobalScopehas its own event loop.
- WorkerLocation
The
WorkerLocationinterface defines the absolute location of the script executed by the Worker. Such an object is initialized for each worker and is available via the Location property obtained by callingself.location.
- WorkerNavigator
The
WorkerNavigatorinterface represents a subset of the Navigator interface allowed to be accessed from a Worker. Such an object is initialized for each worker and is available via the Navigator property.
- Worklet
The
Workletinterface is a lightweight version of Web Workers and gives developers access to low-level parts of the rendering pipeline.
- WorkletGlobalScope
The
WorkletGlobalScopeinterface is an abstract class that specific worklet scope classes inherit from. EachWorkletGlobalScopedefines a new global environment.
- WritableStream
The
WritableStreaminterface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.
This object comes with built-in backpressure and queuing.
- WritableStreamDefaultController
The
WritableStreamDefaultControllerinterface of the Streams API represents a controller allowing control of a WritableStream's state. When constructing aWritableStream, the underlying sink is given a correspondingWritableStreamDefaultControllerinstance to manipulate.
- WritableStreamDefaultWriter
The
WritableStreamDefaultWriterinterface of the Streams API is the object returned by GetWriter() and once created locks the writer to theWritableStreamensuring that no other streams can write to the underlying sink.
- XMLDocument
The XMLDocument interface represents an XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents.
- XMLHttpRequest
XMLHttpRequest(XHR) objects are used to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.
- XMLHttpRequestEventTarget
XMLHttpRequestEventTargetis the interface that describes the event handlers shared on XMLHttpRequest and XMLHttpRequestUpload.
- XMLHttpRequestUpload
The
XMLHttpRequestUploadinterface represents the upload process for a specific XMLHttpRequest. It is an opaque object that represents the underlying, browser-dependent, upload process. It is an XMLHttpRequestEventTarget and can be obtained by calling Upload.
- XMLSerializer
The
XMLSerializerinterface provides the SerializeToString(Node) method to construct an XML string representing a {{Glossary("DOM")}} tree.
- XPathEvaluator
The
XPathEvaluatorinterface allows to compile and evaluate XPath expressions.
- XPathExpression
This is useful when an expression will be reused in an application, because it is just compiled once and all namespace prefixes which occur within the expression are preresolved.
- XPathResult
The
XPathResultinterface represents the results generated by evaluating an XPath expression within the context of a given node.
- XRAnchor
- The
NOTE
ExperimentalXRAnchorinterface creates anchors which keep track of the pose that is fixed relative to the real world. With anchors, you can specify poses in the world that need to be updated to correctly reflect the evolving understanding of the world, such that the poses remain aligned with the same place in the physical world. That helps to build an illusion that the placed objects are really present in the user's environment.
- XRAnchorSet
- The
NOTE
ExperimentalXRAnchorSetinterface exposes a collection of anchors. Its instances are returned by TrackedAnchors and areSet-like objects.
- XRBoundedReferenceSpace
- The WebXR Device API's
NOTE
ExperimentalXRBoundedReferenceSpaceinterface describes a virtual world reference space which has preset boundaries. This extends XRReferenceSpace, which describes an essentially unrestricted space around the viewer's position. These bounds are defined using an array of points, each of which defines a vertex in a polygon inside which the user is allowed to move.
- XRCPUDepthInformation
- The
NOTE
ExperimentalXRCPUDepthInformationinterface contains depth information from the CPU (returned by GetDepthInformation(XRView)).
- XRCompositionLayer
- The
NOTE
ExperimentalXRCompositionLayerinterface of the WebXR Device API is a base class that defines a set of common properties and behaviors for WebXR layer types. It is not constructable on its own.
- XRCubeLayer
- The
NOTE
ExperimentalXRCubeLayerinterface of the WebXR Device API is a layer that renders directly from a cubemap and projects it onto the inside faces of a cube.
- XRCylinderLayer
- The
NOTE
ExperimentalXRCylinderLayerinterface of the WebXR Device API is a layer that takes up a curved rectangular space in the virtual environment. Only the front of the layer is visible.
- XRDepthInformation
- The
NOTE
ExperimentalXRDepthInformationinterface contains information about the distance from the user's device to the real-world geometry in the user's environment.
- XREquirectLayer
- The
NOTE
ExperimentalXREquirectLayerinterface of the WebXR Device API is a layer that maps equirectangular coded data onto the inside of a sphere.
- XRFrame
- A WebXR Device API
NOTE
ExperimentalXRFrameobject is passed into the RequestAnimationFrame(XRFrameRequestCallback) callback function and provides access to the information needed in order to render a single frame of animation for an XRSession describing a VR or AR scene. Events which communicate the tracking state of objects also provide anXRFramereference as part of their structure.
- XRHand
The
XRHandinterface is pair iterator (an ordered map) with the key being the hand joints and the value being an XRJointSpace.
- XRHitTestResult
- The
NOTE
ExperimentalXRHitTestResultinterface of the WebXR Device API contains a single result of a hit test. You can get an array ofXRHitTestResultobjects for a frame by calling GetHitTestResults(XRHitTestSource).
- XRHitTestSource
- The
NOTE
ExperimentalXRHitTestSourceinterface of the WebXR Device API handles hit test subscriptions. You can get anXRHitTestSourceobject by using the RequestHitTestSource(XRHitTestOptionsInit) method.
- XRInputSource
The WebXR Device API's
XRInputSourceinterface describes a single source of control input which is part of the user's WebXR-compatible virtual or augmented reality system. The device is specific to the platform being used, but provides the direction in which it is being aimed and optionally may generate events if the user triggers performs actions using the device.
- XRInputSourceArray
- The interface
NOTE
ExperimentalXRInputSourceArrayrepresents a live list of WebXR input sources, and is used as the return value of the XRSession property InputSources. Each entry is an XRInputSource representing one input device connected to the WebXR system.
- XRInputSourceEvent
The WebXR Device API's
XRInputSourceEventinterface describes an event which has occurred on a WebXR user input device such as a hand controller, gaze tracking system, or motion tracking system. More specifically, they represent a change in the state of an XRInputSource.
- XRInputSourcesChangeEvent
The WebXR Device API interface
XRInputSourcesChangeEventis used to represent the XRSession.Inputsourceschange event sent to an XRSession when the set of available WebXR input controllers changes.
- XRJointPose
The
XRJointPoseinterface is an XRPose with additional information about the size of the skeleton joint it represents.
- XRJointSpace
The
XRJointSpaceinterface is an XRSpace and represents the position and orientation of an XRHand joint.
- XRLayer
- The
NOTE
ExperimentalXRLayerinterface of the WebXR Device API is the base class for WebXR layer types. It inherits methods from EventTarget.
- XRLayerEvent
- The
NOTE
ExperimentalXRLayerEventinterface of the WebXR Device API is the event type for events related to a change of state of an XRLayer object. These events occur, for example, when the layer needs to be redrawn.
- XRLightEstimate
- The
NOTE
ExperimentalXRLightEstimateinterface of the WebXR Device API provides the estimated lighting values for an XRLightProbe at the time represented by an XRFrame.
- XRLightProbe
- The
NOTE
ExperimentalXRLightProbeinterface of the WebXR Device API contains lighting information at a given point in the user's environment. You can get anXRLightingobject using the RequestLightProbe(XRLightProbeInit) method.
- XRMediaBinding
- The
NOTE
ExperimentalXRMediaBindinginterface is used to create layers that display the content of an HTMLVideoElement.
- XRPose
XRPoseis a WebXR API interface representing a position and orientation in the 3D space, relative to the XRSpace within which it resides. TheXRSpace—which is either an XRReferenceSpace or an XRBoundedReferenceSpace—defines the coordinate system used for the pose and, in the case of an XRViewerPose, its underlying views.
- XRProjectionLayer
- The
NOTE
ExperimentalXRProjectionLayerinterface of the WebXR Device API is a layer that fills the entire view of the observer and is refreshed close to the device's native frame rate.
- XRQuadLayer
- The
NOTE
ExperimentalXRQuadLayerinterface of the WebXR Device API is a layer that takes up a flat rectangular space in the virtual environment. AnXRQuadLayerhas no thickness. It is a two-dimensional object positioned and oriented in 3D space. The position of a quad refers to the center of the quad. Only the front of the layer is visible.
- XRRay
- The
NOTE
ExperimentalXRRayinterface of the WebXR Device API is a geometric ray described by an origin point and a direction vector.
- XRReferenceSpace
The WebXR Device API's
XRReferenceSpaceinterface describes the coordinate system for a specific tracked entity or object within the virtual world using a specified tracking behavior. The tracking behavior is defined by the selected reference space type. It expands upon the base class, XRSpace, by adding support for several different tracking behaviors as well as to request a new reference space which describes the offset transform between the tracked object and another location in the world.
- XRReferenceSpaceEvent
The WebXR Device API interface
XRReferenceSpaceEventrepresents an event sent to an XRReferenceSpace. Currently, the only event that uses this type is the XRReferenceSpace.Reset event.
- XRRenderState
- The
NOTE
ExperimentalXRRenderStateinterface of the WebXR Device API contains configurable values which affect how the imagery generated by an XRSession gets composited. These properties include the range of distances from the viewer within which content should be rendered, the vertical field of view (for inline presentations), and a reference to the XRWebGLLayer being used as the target for rendering the scene prior to it being presented on the XR device's display or displays.
- XRRigidTransform
The
XRRigidTransformis a WebXR API interface that represents the 3D geometric transform described by a position and orientation.
- XRSession
- The
NOTE
ExperimentalXRSessioninterface of the WebXR Device API represents an ongoing XR session, providing methods and properties used to interact with and control the session. To open a WebXR session, use the XRSystem interface's RequestSession(XRSessionMode, XRSessionInit) method.
- XRSessionEvent
The WebXR Device API's
XRSessionEventinterface describes an event which indicates the change of the state of an XRSession. These events occur, for example, when the session ends or the visibility of its context changes.
- XRSpace
The
XRSpaceinterface of the WebXR Device API is an abstract interface providing a common basis for every class which represents a virtual coordinate system within the virtual world, in which its origin corresponds to a physical location. Spatial data in WebXR is always expressed relative to an object based upon one of the descendant interfaces ofXRSpace, at the time at which a given XRFrame takes place.
- XRSubImage
- The
NOTE
ExperimentalXRSubImageinterface of the WebXR Device API represents what viewport of the GPU texture to use for rendering.
- XRSystem
- The WebXR Device API interface
NOTE
ExperimentalXRSystemprovides methods which let you get access to an XRSession object representing a WebXR session. With thatXRSessionin hand, you can use it to interact with the Augmented Reality (AR) or Virtual Reality (VR) device.
- XRTransientInputHitTestResult
- The
NOTE
ExperimentalXRTransientInputHitTestResultinterface of the WebXR Device API contains an array of results of a hit test for transient input, grouped by input source.
- XRTransientInputHitTestSource
- The
NOTE
ExperimentalXRTransientInputHitTestSourceinterface of the WebXR Device API handles transient input hit test subscriptions. You can get anXRTransientInputHitTestSourceobject by calling the RequestHitTestSourceForTransientInput(XRTransientInputHitTestOptionsInit).
- XRView
- The WebXR Device API's
NOTE
ExperimentalXRViewinterface describes a single view into the XR scene for a specific frame, providing orientation and position information for the viewpoint. You can think of it as a description of a specific eye or camera and how it views the world. A 3D frame will involve two views, one for each eye, separated by an appropriate distance which approximates the distance between the viewer's eyes. This allows the two views, when projected in isolation into the appropriate eyes, to simulate a 3D world.
- XRViewerPose
The WebXR Device API interface
XRViewerPoserepresents the pose (the position and orientation) of a viewer's point of view on the scene. EachXRViewerPosecan have multiple views to represent, for example, the slight separation between the left and right eye.
- XRViewport
The WebXR Device API's
XRViewportinterface provides properties used to describe the size and position of the current viewport within the XRWebGLLayer being used to render the 3D scene.
- XRWebGLBinding
- The
NOTE
ExperimentalXRWebGLBindinginterface is used to create layers that have a GPU backend.
- XRWebGLDepthInformation
- The
NOTE
ExperimentalXRWebGLDepthInformationinterface contains depth information from the GPU/WebGL (returned by GetDepthInformation(XRView)).
- XRWebGLLayer
- The
NOTE
ExperimentalXRWebGLLayerinterface of the WebXR Device API provides a linkage between the WebXR device (or simulated XR device, in the case of an inline session) and a WebGL context used to render the scene for display on the device. In particular, it provides access to the WebGL framebuffer and viewport to ease access to the context.
- XRWebGLSubImage
- The
NOTE
ExperimentalXRWebGLSubImageinterface is used during rendering of WebGL layers.
- XSLTProcessor
An
XSLTProcessorapplies an XSLT stylesheet transformation to an XML document to
produce a new XML document as output. It has methods to load the XSLT stylesheet, to
manipulate<xsl:param>parameter values, and to apply the
transformation to documents.
- console
The
consoleobject provides access to the debugging console (e.g., the Web console in Firefox).
Structs
- Union160
double or CSSNumericValue or string
- Union189
ImageBitmap or ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement or OffscreenCanvas or VideoFrame
- Union217
ImageBitmap or ImageData or HTMLImageElement or HTMLVideoElement or VideoFrame or HTMLCanvasElement or OffscreenCanvas
- Union22
Text or Element or CSSPseudoElement or Document
- Union223
Int8Array or Int16Array or Int32Array or Uint8Array or Uint16Array or Uint32Array or Uint8ClampedArray or BigInt64Array or BigUint64Array or Unsupported /Float16Array/ or Float32Array or Float64Array or DataView
- Union48
Union224 or Blob or string or WriteParams
- Union63
MediaStream or MediaSource or Blob
- Union64
VideoTrack or AudioTrack or TextTrack
- Union65
VideoTrack or AudioTrack or TextTrack
- Union70
CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext or GPUCanvasContext
- Union72
Union71 or HTMLVideoElement or HTMLCanvasElement or ImageBitmap or OffscreenCanvas or VideoFrame
- Union75
double or DOMPointInit or List<T>
- Union79
OffscreenCanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext or GPUCanvasContext
- Union84
string or Function or TrustedScript
Interfaces
- ChildNode
Elementis the most general base class from which all element objects (i.e., objects that represent elements) in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit fromElement.
- NonElementParentNode
The
Documentinterface represents any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.
- ParentNode
Elementis the most general base class from which all element objects (i.e., objects that represent elements) in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit fromElement.
Enums
- RequestCache
The
cacheread-only property of the Request interface contains the cache mode of the request. It controls how the request will interact with the browser's HTTP cache.
- RequestCredentials
The
credentialsread-only property of the Request interface reflects the value given to the Request(Union42, RequestInit) constructor in thecredentialsoption. It determines whether or not the browser sends credentials with the request, as well as whether anySet-Cookieresponse headers are respected.
- RequestDestination
The
destinationread-only property of the Request interface returns a string describing the type of content being requested.
- RequestDuplex
- The
NOTE
Experimentalduplexread-only property of the Request interface returns the duplex mode of the request, which determines whether the browser must send the entire request before processing the response.
- RequestMode
The
moderead-only property of the Request
interface contains the mode of the request (e.g.,cors,no-cors,same-origin, ornavigate.) This is used
to determine if cross-origin requests lead to valid responses, and which properties of the response are readable.
- RequestRedirect
The
redirectread-only property of the Request interface contains the mode for how redirects are handled.