x/evt@v1.11.2

­čĺžEventEmitter's typesafe replacement
GitHub Stars
363
Latest
hooks/
lib/
test/
tools/
import * as evt from "https://deno.land/x/evt@v1.11.2/mod.ts";

Functions

compose
invokeOperator

Invoke any type of stateless operator and return as if it was a f╬╗. Intended to be used alongside Evt.prototype.getStatelessOp()

matchVoid

Unlike undefined or null, testing o !== void will not restrict the type.

Interfaces

Ctx

https://docs.evt.land/api/ctx

CtxLike

Minimal interface that an object must implement to be a valid context argument ( for interop between mismatching EVT versions )

dom.AbortController

A controller object that allows you to abort one or more DOM requests as and when desired.

dom.AbortSignal

A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object.

dom.AbortSignalEventMap
dom.AbstractRange
dom.AbstractWorker
dom.AbstractWorkerEventMap
dom.Account
dom.AddEventListenerOptions
dom.AesCbcParams
dom.AesCfbParams
dom.AesCmacParams
dom.AesCtrParams
dom.AesDerivedKeyParams
dom.AesGcmParams
dom.AesKeyAlgorithm
dom.AesKeyGenParams
dom.Algorithm
dom.AnalyserNode

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.

dom.AnalyserOptions
dom.ANGLE_instanced_arrays

The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type.

dom.Animatable
dom.Animation
dom.AnimationEffect
dom.AnimationEvent

Events providing information related to animations.

dom.AnimationEventInit
dom.AnimationEventMap
dom.AnimationFrameProvider
dom.AnimationPlaybackEvent
dom.AnimationPlaybackEventInit
dom.AnimationTimeline
dom.ApplicationCache
dom.ApplicationCacheEventMap
dom.AssertionOptions
dom.AssignedNodesOptions
dom.Attr

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

dom.AudioBuffer

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

dom.AudioBufferOptions
dom.AudioBufferSourceNode

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

dom.AudioBufferSourceOptions
dom.AudioContext

An audio-processing graph built from audio modules linked together, each represented by an AudioNode.

dom.AudioContextInfo
dom.AudioContextOptions
dom.AudioDestinationNode

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

dom.AudioListener

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 the AudioListener stored in the BaseAudioContext.listener attribute.

dom.AudioNode

A generic interface for representing an audio processing module. Examples include:

dom.AudioNodeOptions
dom.AudioParam

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

dom.AudioParamDescriptor
dom.AudioParamMap
dom.AudioProcessingEvent

The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed.

dom.AudioProcessingEventInit
dom.AudioScheduledSourceNode
dom.AudioScheduledSourceNodeEventMap
dom.AudioTimestamp
dom.AudioTrack

A single audio track from one of the HTML media elements, or .

dom.AudioTrackList

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.

dom.AudioTrackListEventMap
dom.AudioWorklet
dom.AudioWorkletNode
dom.AudioWorkletNodeEventMap
dom.AudioWorkletNodeOptions
dom.AuthenticationExtensionsClientInputs
dom.AuthenticationExtensionsClientOutputs
dom.AuthenticatorAssertionResponse
dom.AuthenticatorAttestationResponse
dom.AuthenticatorResponse
dom.AuthenticatorSelectionCriteria
dom.BarProp
dom.BaseAudioContext
dom.BaseAudioContextEventMap
dom.BeforeUnloadEvent

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

dom.BhxBrowser
dom.BiquadFilterNode

A simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers.

dom.BiquadFilterOptions
dom.Blob

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

dom.BlobCallback
dom.BlobPropertyBag
dom.Body
dom.BroadcastChannel
dom.BroadcastChannelEventMap
dom.ByteLengthChunk
dom.ByteLengthQueuingStrategy

This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.

dom.Cache

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

dom.CacheQueryOptions
dom.CacheStorage

The storage for Cache objects.

dom.CanvasCompositing
dom.CanvasDrawImage
dom.CanvasDrawPath
dom.CanvasFillStrokeStyles
dom.CanvasFilters
dom.CanvasGradient

An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient().

dom.CanvasImageData
dom.CanvasImageSmoothing
dom.CanvasPath
dom.CanvasPathDrawingStyles
dom.CanvasPattern

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

dom.CanvasRect
dom.CanvasRenderingContext2D

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

dom.CanvasRenderingContext2DSettings
dom.CanvasShadowStyles
dom.CanvasState
dom.CanvasText
dom.CanvasTextDrawingStyles
dom.CanvasTransform
dom.CanvasUserInterface
dom.CaretPosition
dom.CDATASection

A CDATA section that can be used within XML to include extended portions of unescaped text. The symbols < and & donÔÇÖt need escaping as they normally do when inside a CDATA section.

dom.ChannelMergerNode

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

dom.ChannelMergerOptions
dom.ChannelSplitterNode

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

dom.ChannelSplitterOptions
dom.CharacterData

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

dom.ChildNode
dom.ClientData
dom.ClientQueryOptions
dom.ClientRect
dom.ClientRectList
dom.Clipboard
dom.ClipboardEvent

Events providing information related to modification of the clipboard, that is cut, copy, and paste events.

dom.ClipboardEventInit
dom.CloseEvent

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

dom.CloseEventInit
dom.Comment

Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.

dom.CompositionEvent

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

dom.CompositionEventInit
dom.ComputedEffectTiming
dom.ComputedKeyframe
dom.ConcatParams
dom.ConfirmSiteSpecificExceptionsInformation
dom.Console

Provides access to the browser's debugging console (e.g. the Web Console in Firefox). The specifics of how it works varies from browser to browser, but there is a de facto set of features that are typically provided.

dom.ConstantSourceNode
dom.ConstantSourceOptions
dom.ConstrainBooleanParameters
dom.ConstrainDOMStringParameters
dom.ConstrainDoubleRange
dom.ConstrainULongRange
dom.ConstrainVideoFacingModeParameters
dom.ConvolverNode

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

dom.ConvolverOptions
dom.Coordinates

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

dom.CountQueuingStrategy

This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams.

dom.Credential
dom.CredentialCreationOptions
dom.CredentialRequestOptions
dom.CredentialsContainer
dom.Crypto

Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.

dom.CryptoKey

The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.

dom.CryptoKeyPair

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

dom.CSS

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

dom.CSSConditionRule

A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule.

dom.CSSFontFaceRule
dom.CSSGroupingRule

Any CSS at-rule that contains other rules nested within it.

dom.CSSImportRule
dom.CSSKeyframeRule

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

dom.CSSKeyframesRule

An object representing a complete set of keyframes for a CSS animation. It corresponds to the contains of a whole @keyframes at-rule. It implements the CSSRule interface with a type value of 7 (CSSRule.KEYFRAMES_RULE).

dom.CSSMediaRule

A single CSS @media rule. It implements the CSSConditionRule interface, and therefore the CSSGroupingRule and the CSSRule interface with a type value of 4 (CSSRule.MEDIA_RULE).

dom.CSSNamespaceRule

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

dom.CSSPageRule

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

dom.CSSRule

A single CSS rule. There are several types of rules, listed in the Type constants section below.

dom.CSSRuleList

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

dom.CSSStyleDeclaration

An object that is a CSS declaration block, and exposes style information and various style-related methods and properties.

dom.CSSStyleRule

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

dom.CSSStyleSheet

A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet.

dom.CSSSupportsRule

An object representing a single CSS @supports at-rule. It implements the CSSConditionRule interface, and therefore the CSSRule and CSSGroupingRule interfaces with a type value of 12 (CSSRule.SUPPORTS_RULE).

dom.CustomElementConstructor
dom.CustomElementRegistry
dom.CustomEvent
dom.CustomEventInit
dom.DataCue
dom.DataTransfer

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

dom.DataTransferItem

One drag data item. During a drag operation, each drag event has a dataTransfer property which contains a list of drag data items. Each item in the list is a DataTransferItem object.

dom.DataTransferItemList

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

dom.DecodeErrorCallback
dom.DecodeSuccessCallback
dom.DeferredPermissionRequest
dom.DelayNode

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.

dom.DelayOptions
dom.DeviceAcceleration

Provides information about the amount of acceleration the device is experiencing along all three axes.

dom.DeviceLightEvent

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

dom.DeviceLightEventInit
dom.DeviceMotionEvent

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

dom.DeviceMotionEventAcceleration
dom.DeviceMotionEventAccelerationInit
dom.DeviceMotionEventInit
dom.DeviceMotionEventRotationRate
dom.DeviceMotionEventRotationRateInit
dom.DeviceOrientationEvent

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

dom.DeviceOrientationEventInit
dom.DevicePermissionDescriptor
dom.DeviceRotationRate

Provides information about the rate at which the device is rotating around all three axes.

dom.DhImportKeyParams
dom.DhKeyAlgorithm
dom.DhKeyDeriveParams
dom.DhKeyGenParams
dom.Document

Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.

dom.DocumentAndElementEventHandlers
dom.DocumentAndElementEventHandlersEventMap
dom.DocumentEvent
dom.DocumentEventMap
dom.DocumentFragment

A minimal document object that has no parent. It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document. The key difference is that because the document fragment isn't part of the active document tree structure, changes made to the fragment don't affect the document, cause reflow, or incur any performance impact that can occur when changes are made.

dom.DocumentOrShadowRoot
dom.DocumentTimeline
dom.DocumentTimelineOptions
dom.DocumentType

A Node containing a doctype.

dom.DOMError

An error object that contains an error name.

dom.DOMException

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

dom.DOMImplementation

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

dom.DOML2DeprecatedColorProperty
dom.DOMMatrix
dom.DOMMatrix2DInit
dom.DOMMatrixInit
dom.DOMMatrixReadOnly
dom.DOMParser

Provides the ability to parse XML or HTML source code from a string into a DOM Document.

dom.DOMPoint
dom.DOMPointInit
dom.DOMPointReadOnly
dom.DOMQuad
dom.DOMQuadInit
dom.DOMRect
dom.DOMRectInit
dom.DOMRectList
dom.DOMRectReadOnly
dom.DOMSettableTokenList
dom.DOMStringList

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

dom.DOMStringMap

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

dom.DOMTokenList

A set of space-separated tokens. Such a set is returned by Element.classList, HTMLLinkElement.relList, HTMLAnchorElement.relList, HTMLAreaElement.relList, HTMLIframeElement.sandbox, or HTMLOutputElement.htmlFor. It is indexed beginning with 0 as with JavaScript Array objects. DOMTokenList is always case-sensitive.

dom.DoubleRange
dom.DragEvent

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.

dom.DragEventInit
dom.DynamicsCompressorNode

Inherits properties from its parent, AudioNode.

dom.DynamicsCompressorOptions
dom.EcdhKeyDeriveParams
dom.EcdsaParams
dom.EcKeyAlgorithm
dom.EcKeyGenParams
dom.EcKeyImportParams
dom.EffectTiming
dom.Element

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

dom.ElementContentEditable
dom.ElementCreationOptions
dom.ElementCSSInlineStyle
dom.ElementDefinitionOptions
dom.ElementEventMap
dom.ErrorEvent

Events providing information related to errors in scripts or in files.

dom.ErrorEventInit
dom.Event

An event which takes place in the DOM.

dom.EventHandlerNonNull
dom.EventInit
dom.EventListener
dom.EventListenerObject
dom.EventListenerOptions
dom.EventModifierInit
dom.EventSource
dom.EventSourceEventMap
dom.EventSourceInit
dom.EventTarget

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

dom.ExceptionInformation
dom.EXT_blend_minmax
dom.EXT_frag_depth

The EXT_frag_depth extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader.

dom.EXT_shader_texture_lod
dom.EXT_sRGB
dom.EXT_texture_filter_anisotropic

The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF).

dom.ExtensionScriptApis
dom.External
dom.File

Provides information about files and allows JavaScript in a web page to access their content.

dom.FileList

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

dom.FilePropertyBag
dom.FileReader

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.

dom.FileReaderEventMap
dom.FocusEvent

Focus-related events like focus, blur, focusin, or focusout.

dom.FocusEventInit
dom.FocusNavigationEvent
dom.FocusNavigationEventInit
dom.FocusNavigationOrigin
dom.FocusOptions
dom.ForEachCallback
dom.FormData

Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using the XMLHttpRequest.send() method. It uses the same format a form would use if the encoding type were set to "multipart/form-data".

dom.FrameRequestCallback
dom.FullscreenOptions
dom.FunctionStringCallback
dom.GainNode

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

dom.GainOptions
dom.Gamepad

This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id.

dom.GamepadButton

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.

dom.GamepadEvent

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

dom.GamepadEventInit
dom.GamepadHapticActuator

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

dom.GamepadPose

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

dom.GenericTransformStream
dom.Geolocation

An object able to programmatically obtain the position of the device. It gives Web content access to the location of the device. This allows a Web site or app to offer customized results based on the user's location.

dom.GetNotificationOptions
dom.GetRootNodeOptions
dom.GlobalEventHandlers
dom.GlobalEventHandlersEventMap
dom.HashChangeEvent

Events that fire when the fragment identifier of the URL has changed.

dom.HashChangeEventInit
dom.Headers

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

dom.History

Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in.

dom.HkdfCtrParams
dom.HkdfParams
dom.HmacImportParams
dom.HmacKeyAlgorithm
dom.HmacKeyGenParams
dom.HTMLAllCollection
dom.HTMLAnchorElement

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.

dom.HTMLAppletElement
dom.HTMLAreaElement

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

dom.HTMLAudioElement

Provides access to the properties of elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface.

dom.HTMLBaseElement

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

dom.HTMLBaseFontElement

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

dom.HTMLBodyElement

Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating elements.

dom.HTMLBodyElementEventMap
dom.HTMLBRElement

A HTML line break element (). It inherits from HTMLElement.

dom.HTMLButtonElement

Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating elements.

dom.HTMLCanvasElement

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

dom.HTMLCollection
dom.HTMLCollectionBase

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

dom.HTMLCollectionOf
dom.HTMLDataElement

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

dom.HTMLDataListElement

Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate elements and their content.

dom.HTMLDetailsElement
dom.HTMLDialogElement
dom.HTMLDirectoryElement
dom.HTMLDivElement

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

dom.HTMLDListElement

Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list () elements.

dom.HTMLDocument

The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object.

dom.HTMLElement

Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it.

dom.HTMLElementDeprecatedTagNameMap
dom.HTMLElementEventMap
dom.HTMLElementTagNameMap
dom.HTMLEmbedElement

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

dom.HTMLFieldSetElement

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

dom.HTMLFontElement

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

dom.HTMLFormControlsCollection

A collection of HTML form control elements.

dom.HTMLFormElement

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

dom.HTMLFrameElement
dom.HTMLFrameSetElement

Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating elements.

dom.HTMLFrameSetElementEventMap
dom.HTMLHeadElement

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

dom.HTMLHeadingElement

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

dom.HTMLHRElement

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

dom.HTMLHtmlElement

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

dom.HTMLHyperlinkElementUtils
dom.HTMLIFrameElement

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.

dom.HTMLImageElement

Provides special properties and methods for manipulating elements.

dom.HTMLInputElement

Provides special properties and methods for manipulating the options, layout, and presentation of elements.

dom.HTMLLabelElement

Gives access to properties specific to elements. It inherits methods and properties from the base HTMLElement interface.

dom.HTMLLegendElement

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

dom.HTMLLIElement

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

dom.HTMLLinkElement

Reference information for external resources and the relationship of those resources to a document and vice-versa. This object inherits all of the properties and methods of the HTMLElement interface.

dom.HTMLMapElement

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.

dom.HTMLMarqueeElement

Provides methods to manipulate elements.

dom.HTMLMarqueeElementEventMap
dom.HTMLMediaElement

Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video.

dom.HTMLMediaElementEventMap
dom.HTMLMenuElement
dom.HTMLMetaElement

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

dom.HTMLMeterElement

The HTML elements expose the HTMLMeterElement interface, which provides special properties and methods (beyond the HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of elements.

dom.HTMLModElement

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

dom.HTMLObjectElement

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 element, representing external resources.

dom.HTMLOListElement

Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements.

dom.HTMLOptGroupElement

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

dom.HTMLOptionElement
dom.HTMLOptionsCollection

HTMLOptionsCollection is an interface representing a collection of HTML option elements (in document order) and offers methods and properties for traversing the list as well as optionally altering its items. This type is returned solely by the "options" property of select.

dom.HTMLOrSVGElement
dom.HTMLOutputElement

Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of elements.

dom.HTMLParagraphElement

Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating elements.

dom.HTMLParamElement

Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating elements, representing a pair of a key and a value that acts as a parameter for an element.

dom.HTMLPictureElement

A HTML element. It doesn't implement specific properties or methods.

dom.HTMLPreElement

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

dom.HTMLProgressElement

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

dom.HTMLQuoteElement

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like and , but not the element.

dom.HTMLScriptElement

HTML elements expose the HTMLScriptElement interface, which provides special properties and methods for manipulating the behavior and execution of elements (beyond the inherited HTMLElement interface).

dom.HTMLSelectElement

A HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface.

dom.HTMLSlotElement
dom.HTMLSourceElement

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

dom.HTMLSpanElement

A element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

dom.HTMLStyleElement

A element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle.

dom.HTMLTableCaptionElement

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

dom.HTMLTableCellElement

Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header or data cells, in an HTML document.

dom.HTMLTableColElement

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

dom.HTMLTableDataCellElement
dom.HTMLTableElement

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.

dom.HTMLTableHeaderCellElement
dom.HTMLTableRowElement

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.

dom.HTMLTableSectionElement

Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies, in an HTML table.

dom.HTMLTemplateElement

Enables access to the contents of an HTML element.

dom.HTMLTextAreaElement

Provides special properties and methods for manipulating the layout and presentation of elements.

dom.HTMLTimeElement

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

dom.HTMLTitleElement

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

dom.HTMLTrackElement

The HTMLTrackElement

dom.HTMLUListElement

Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements.

dom.HTMLUnknownElement

An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods.

dom.HTMLVideoElement

Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement.

dom.HTMLVideoElementEventMap
dom.IDBArrayKey
dom.IDBCursor

This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database.

dom.IDBCursorWithValue

This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property.

dom.IDBDatabase

This IndexedDB API interface provides a connection to a database; you can use an IDBDatabase object 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.

dom.IDBDatabaseEventMap
dom.IDBFactory

In the following code snippet, we make a request to open a database, and include handlers for the success and error cases. For a full working example, see our To-do Notifications app (view example live.)

dom.IDBIndex

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

dom.IDBIndexParameters
dom.IDBKeyRange

A key range can be a single value or a range with upper and lower bounds or endpoints. If the key range has both upper and lower bounds, then it is bounded; if it has no bounds, it is unbounded. A bounded key range can either be open (the endpoints are excluded) or closed (the endpoints are included). To retrieve all keys within a certain range, you can use the following code constructs:

dom.IDBObjectStore

This example shows a variety of different uses of object stores, from updating the data structure with IDBObjectStore.createIndex inside an onupgradeneeded function, to adding a new item to our object store with IDBObjectStore.add. For a full working example, see our To-do Notifications app (view example live.)

dom.IDBObjectStoreParameters
dom.IDBOpenDBRequest

Also inherits methods from its parents IDBRequest and EventTarget.

dom.IDBOpenDBRequestEventMap
dom.IDBRequest

The request object does not initially contain any information about the result of the operation, but once information becomes available, an event is fired on the request, and the information becomes available through the properties of the IDBRequest instance.

dom.IDBRequestEventMap
dom.IDBTransaction
dom.IDBTransactionEventMap
dom.IDBVersionChangeEvent

This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function.

dom.IDBVersionChangeEventInit
dom.IIRFilterNode

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

dom.IIRFilterOptions
dom.ImageBitmap
dom.ImageBitmapOptions
dom.ImageBitmapRenderingContext
dom.ImageBitmapRenderingContextSettings
dom.ImageData

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

dom.ImageEncodeOptions
dom.InnerHTML
dom.InputDeviceInfo
dom.InputEvent
dom.InputEventInit
dom.IntersectionObserver

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

dom.IntersectionObserverCallback
dom.IntersectionObserverEntry

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

dom.IntersectionObserverEntryInit
dom.IntersectionObserverInit
dom.JsonWebKey
dom.KeyAlgorithm
dom.KeyboardEvent

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

dom.KeyboardEventInit
dom.Keyframe
dom.KeyframeAnimationOptions
dom.KeyframeEffect
dom.KeyframeEffectOptions
dom.LinkStyle
dom.ListeningStateChangedEvent
dom.Location

The location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linked Location, accessible via Document.location and Window.location respectively.

dom.MediaDeviceInfo

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

dom.MediaDevices

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.

dom.MediaDevicesEventMap
dom.MediaElementAudioSourceNode

A MediaElementSourceNode has no inputs and exactly one output, and is created using the AudioContext.createMediaElementSource method. The amount of channels in the output equals the number of channels of the audio referenced by the HTMLMediaElement used in the creation of the node, or is 1 if the HTMLMediaElement has no audio.

dom.MediaElementAudioSourceOptions
dom.MediaEncryptedEvent
dom.MediaEncryptedEventInit
dom.MediaError

An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as or .

dom.MediaKeyMessageEvent

This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session.

dom.MediaKeyMessageEventInit
dom.MediaKeys

This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback.

dom.MediaKeySession

This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM).

dom.MediaKeySessionEventMap
dom.MediaKeyStatusMap

This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs.

dom.MediaKeySystemAccess

This EncryptedMediaExtensions API interface provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the Navigator.requestMediaKeySystemAccess method.

dom.MediaKeySystemConfiguration
dom.MediaKeySystemMediaCapability
dom.MediaList
dom.MediaQueryList

Stores information on a media query applied to a document, and handles sending notifications to listeners when the media query state change (i.e. when the media query test starts or stops evaluating to true).

dom.MediaQueryListEvent
dom.MediaQueryListEventInit
dom.MediaQueryListEventMap
dom.MediaSource

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

dom.MediaSourceEventMap
dom.MediaStream

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.

dom.MediaStreamAudioDestinationNode
dom.MediaStreamAudioSourceNode

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.

dom.MediaStreamAudioSourceOptions
dom.MediaStreamConstraints
dom.MediaStreamError
dom.MediaStreamErrorEvent
dom.MediaStreamErrorEventInit
dom.MediaStreamEvent

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

dom.MediaStreamEventInit
dom.MediaStreamEventMap
dom.MediaStreamTrack

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

dom.MediaStreamTrackAudioSourceNode
dom.MediaStreamTrackAudioSourceOptions
dom.MediaStreamTrackEvent

Events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Stream API methods. These events are sent to the stream when these changes occur.

dom.MediaStreamTrackEventInit
dom.MediaStreamTrackEventMap
dom.MediaTrackCapabilities
dom.MediaTrackConstraints
dom.MediaTrackConstraintSet
dom.MediaTrackSettings
dom.MediaTrackSupportedConstraints
dom.MessageChannel

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

dom.MessageEvent

A message received by a target object.

dom.MessageEventInit
dom.MessagePort

This Channel Messaging API interface 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.

dom.MessagePortEventMap
dom.MidiPermissionDescriptor
dom.MimeType

Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object.

dom.MimeTypeArray

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

dom.MouseEvent

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

dom.MouseEventInit
dom.MSAssertion
dom.MSBlobBuilder
dom.MSFIDOCredentialAssertion
dom.MSFIDOSignature
dom.MSFIDOSignatureAssertion
dom.MSFileSaver
dom.MSGesture
dom.MSGestureEvent

The MSGestureEvent is a proprietary interface specific to Internet Explorer and Microsoft Edge which represents events that occur due to touch gestures. Events using this interface include MSGestureStart, MSGestureEnd, MSGestureTap, MSGestureHold, MSGestureChange, and MSInertiaStart.

dom.MSGraphicsTrust

The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback.

dom.MSInputMethodContext
dom.MSInputMethodContextEventMap
dom.MSLaunchUriCallback
dom.MSMediaKeyError
dom.MSMediaKeyMessageEvent
dom.MSMediaKeyNeededEvent
dom.MSMediaKeys
dom.MSMediaKeySession
dom.MSNavigatorDoNotTrack
dom.MSPointerEvent
dom.MSStream
dom.MultiCacheQueryOptions
dom.MutationCallback
dom.MutationEvent

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

dom.MutationObserver

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.

dom.MutationObserverInit
dom.MutationRecord

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

dom.NamedNodeMap

A collection of Attr objects. Objects inside a NamedNodeMap are not in any particular order, unlike NodeList, although they may be accessed by an index as in an array.

dom.NavigationPreloadManager
dom.NavigationPreloadState
dom.Navigator

The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities.

dom.NavigatorAutomationInformation
dom.NavigatorBeacon
dom.NavigatorConcurrentHardware
dom.NavigatorContentUtils
dom.NavigatorCookies
dom.NavigatorID
dom.NavigatorLanguage
dom.NavigatorOnLine
dom.NavigatorPlugins
dom.NavigatorStorage
dom.NavigatorUserMediaErrorCallback
dom.NavigatorUserMediaSuccessCallback
dom.Node

Node is an interface from which a number of DOM API object types inherit. It allows those types to be treated similarly; for example, inheriting the same set of methods, or being tested in the same way.

dom.NodeFilter

An object used to filter the nodes in a NodeIterator or TreeWalker. They don't know anything about the DOM or how to traverse nodes; they just know how to evaluate a single node against the provided filter.

dom.NodeIterator

An iterator over the members of a list of the nodes in a subtree of the DOM. The nodes will be returned in document order.

dom.NodeList

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

dom.NodeListOf
dom.NonDocumentTypeChildNode
dom.NonElementParentNode
dom.Notification

This Notifications API interface is used to configure and display desktop notifications to the user.

dom.NotificationAction
dom.NotificationEventMap
dom.NotificationOptions
dom.NotificationPermissionCallback
dom.OES_element_index_uint

The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements().

dom.OES_standard_derivatives

The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth.

dom.OES_texture_float

The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures.

dom.OES_texture_float_linear

The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures.

dom.OES_texture_half_float

The OES_texture_half_float extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components.

dom.OES_texture_half_float_linear

The OES_texture_half_float_linear extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures.

dom.OES_vertex_array_object
dom.OfflineAudioCompletionEvent

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

dom.OfflineAudioCompletionEventInit
dom.OfflineAudioContext

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

dom.OfflineAudioContextEventMap
dom.OfflineAudioContextOptions
dom.OffscreenCanvas
dom.OffscreenCanvasRenderingContext2D
dom.OnBeforeUnloadEventHandlerNonNull
dom.OnErrorEventHandlerNonNull
dom.OptionalEffectTiming
dom.OscillatorNode

The OscillatorNode┬áinterface 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.

dom.OscillatorOptions
dom.OverconstrainedError
dom.OverflowEvent
dom.PageTransitionEvent

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

dom.PageTransitionEventInit
dom.PannerNode

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

dom.PannerOptions
dom.ParentNode
dom.Path2D

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

dom.PaymentAddress

This Payment Request API interface is used to store shipping or payment address information.

dom.PaymentCurrencyAmount
dom.PaymentDetailsBase
dom.PaymentDetailsInit
dom.PaymentDetailsModifier
dom.PaymentDetailsUpdate
dom.PaymentItem
dom.PaymentMethodData
dom.PaymentOptions
dom.PaymentRequest

This Payment Request API interface is the primary access point into the API, and lets web content and apps accept payments from the end user.

dom.PaymentRequestEventMap
dom.PaymentRequestUpdateEvent

This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action.

dom.PaymentRequestUpdateEventInit
dom.PaymentResponse

This Payment Request API interface is returned after a user selects a payment method and approves a payment request.

dom.PaymentShippingOption
dom.Pbkdf2Params
dom.Performance

Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API.

dom.PerformanceEntry

Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the mark() method) at an explicit point in an application. Performance entries are also created in indirect ways such as loading a resource (such as an image).

dom.PerformanceEventMap
dom.PerformanceMark

PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline.

dom.PerformanceMeasure

PerformanceMeasure is an abstract interface for PerformanceEntry objects with an entryType of "measure". Entries of this type are created by calling performance.measure() to add a named DOMHighResTimeStamp (the measure) between two marks to the browser's performance timeline.

dom.PerformanceNavigation

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

dom.PerformanceNavigationTiming

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.

dom.PerformanceObserver
dom.PerformanceObserverCallback
dom.PerformanceObserverEntryList
dom.PerformanceObserverInit
dom.PerformanceResourceTiming

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, , image, or script.

dom.PerformanceTiming

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

dom.PerfWidgetExternal
dom.PeriodicWave

PeriodicWave has no inputs or outputs; it is used to define custom oscillators when calling OscillatorNode.setPeriodicWave(). The PeriodicWave itself is created/returned by AudioContext.createPeriodicWave().

dom.PeriodicWaveConstraints
dom.PeriodicWaveOptions
dom.PermissionDescriptor
dom.PermissionRequest
dom.PermissionRequestedEvent
dom.Permissions
dom.PermissionStatus
dom.PermissionStatusEventMap
dom.PipeOptions
dom.Plugin

Provides information about a browser plugin.

dom.PluginArray

Used to store a list of Plugin objects describing the available plugins; it's returned by the window.navigator.plugins property. The PluginArray is not a JavaScript array, but has the length property and supports accessing individual items using bracket notation (plugins[2]), as well as via item(index) and namedItem("name") methods.

dom.PointerEvent

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.

dom.PointerEventInit
dom.PopStateEvent

PopStateEvent is an event handler for the popstate event on the window.

dom.PopStateEventInit
dom.Position

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

dom.PositionCallback
dom.PositionError

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

dom.PositionErrorCallback
dom.PositionOptions
dom.PostMessageOptions
dom.ProcessingInstruction

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

dom.ProgressEvent

Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an , , , or ).

dom.ProgressEventInit
dom.PromiseRejectionEvent
dom.PromiseRejectionEventInit
dom.PropertyIndexedKeyframes
dom.PublicKeyCredential
dom.PublicKeyCredentialCreationOptions
dom.PublicKeyCredentialDescriptor
dom.PublicKeyCredentialEntity
dom.PublicKeyCredentialParameters
dom.PublicKeyCredentialRequestOptions
dom.PublicKeyCredentialRpEntity
dom.PublicKeyCredentialUserEntity
dom.PushManager

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

dom.PushPermissionDescriptor
dom.PushSubscription

This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service.

dom.PushSubscriptionJSON
dom.PushSubscriptionOptions
dom.PushSubscriptionOptionsInit
dom.QueuingStrategy
dom.QueuingStrategySizeCallback
dom.RadioNodeList
dom.RandomSource
dom.Range

A fragment of a document that can contain nodes and parts of text nodes.

dom.ReadableByteStreamController
dom.ReadableByteStreamControllerCallback
dom.ReadableStream

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

dom.ReadableStreamBYOBReader
dom.ReadableStreamBYOBRequest
dom.ReadableStreamDefaultController
dom.ReadableStreamDefaultControllerCallback
dom.ReadableStreamDefaultReader
dom.ReadableStreamErrorCallback
dom.ReadableStreamReadDoneResult
dom.ReadableStreamReader
dom.ReadableStreamReadValueResult
dom.RegistrationOptions
dom.Request

This Fetch API interface represents a resource request.

dom.RequestInit
dom.Response

This Fetch API interface represents the response to a request.

dom.ResponseInit
dom.RsaHashedImportParams
dom.RsaHashedKeyAlgorithm
dom.RsaHashedKeyGenParams
dom.RsaKeyAlgorithm
dom.RsaKeyGenParams
dom.RsaOaepParams
dom.RsaOtherPrimesInfo
dom.RsaPssParams
dom.RTCAnswerOptions
dom.RTCCertificate
dom.RTCCertificateExpiration
dom.RTCConfiguration
dom.RTCDataChannel
dom.RTCDataChannelEvent
dom.RTCDataChannelEventInit
dom.RTCDataChannelEventMap
dom.RTCDataChannelInit
dom.RTCDtlsFingerprint
dom.RTCDtlsParameters
dom.RTCDtlsTransport
dom.RTCDtlsTransportEventMap
dom.RTCDtlsTransportStateChangedEvent
dom.RTCDtmfSender
dom.RTCDTMFSender
dom.RTCDtmfSenderEventMap
dom.RTCDTMFSenderEventMap
dom.RTCDTMFToneChangeEvent

Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event.

dom.RTCDTMFToneChangeEventInit
dom.RTCError
dom.RTCErrorEvent
dom.RTCErrorEventInit
dom.RTCErrorInit
dom.RTCIceCandidate

The RTCIceCandidate interfaceÔÇöpart of the WebRTC APIÔÇörepresents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection.

dom.RTCIceCandidateAttributes
dom.RTCIceCandidateComplete
dom.RTCIceCandidateDictionary
dom.RTCIceCandidateInit
dom.RTCIceCandidatePair
dom.RTCIceCandidatePairChangedEvent
dom.RTCIceCandidatePairStats
dom.RTCIceGatherer
dom.RTCIceGathererEvent
dom.RTCIceGathererEventMap
dom.RTCIceGatherOptions
dom.RTCIceParameters
dom.RTCIceServer
dom.RTCIceTransport

Provides access to information about the ICE transport layer over which the data is being sent and received.

dom.RTCIceTransportEventMap
dom.RTCIceTransportStateChangedEvent
dom.RTCIdentityAssertion
dom.RTCIdentityProviderOptions
dom.RTCInboundRTPStreamStats
dom.RTCMediaStreamTrackStats
dom.RTCOAuthCredential
dom.RTCOfferAnswerOptions
dom.RTCOfferOptions
dom.RTCOutboundRTPStreamStats
dom.RTCPeerConnection

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.

dom.RTCPeerConnectionErrorCallback
dom.RTCPeerConnectionEventMap
dom.RTCPeerConnectionIceErrorEvent
dom.RTCPeerConnectionIceErrorEventInit
dom.RTCPeerConnectionIceEvent

Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate.

dom.RTCPeerConnectionIceEventInit
dom.RTCRtcpFeedback
dom.RTCRtcpParameters
dom.RTCRtpCapabilities
dom.RTCRtpCodecCapability
dom.RTCRtpCodecParameters
dom.RTCRtpCodingParameters
dom.RTCRtpContributingSource
dom.RTCRtpDecodingParameters
dom.RTCRtpEncodingParameters
dom.RTCRtpFecParameters
dom.RTCRtpHeaderExtension
dom.RTCRtpHeaderExtensionCapability
dom.RTCRtpHeaderExtensionParameters
dom.RTCRtpParameters
dom.RTCRtpReceiveParameters
dom.RTCRtpReceiver

This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection.

dom.RTCRtpRtxParameters
dom.RTCRtpSender

Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer.

dom.RTCRtpSendParameters
dom.RTCRTPStreamStats
dom.RTCRtpSynchronizationSource
dom.RTCRtpTransceiver
dom.RTCRtpTransceiverInit
dom.RTCRtpUnhandled
dom.RTCSctpTransport
dom.RTCSctpTransportEventMap
dom.RTCSessionDescription

One end of a connectionÔÇöor potential connectionÔÇöand how it's configured. Each RTCSessionDescription consists of a description type indicating which part of the offer/answer negotiation process it describes and of the SDP descriptor of the session.

dom.RTCSessionDescriptionCallback
dom.RTCSessionDescriptionInit
dom.RTCSrtpKeyParam
dom.RTCSrtpSdesParameters
dom.RTCSrtpSdesTransport
dom.RTCSrtpSdesTransportEventMap
dom.RTCSsrcConflictEvent
dom.RTCSsrcRange
dom.RTCStats
dom.RTCStatsCallback
dom.RTCStatsEvent
dom.RTCStatsEventInit
dom.RTCStatsProvider
dom.RTCStatsReport
dom.RTCTrackEvent
dom.RTCTrackEventInit
dom.RTCTransportStats
dom.ScopedCredential
dom.ScopedCredentialDescriptor
dom.ScopedCredentialInfo
dom.ScopedCredentialOptions
dom.ScopedCredentialParameters
dom.Screen

A screen, usually the one on which the current window is being rendered, and is obtained using window.screen.

dom.ScreenOrientation
dom.ScreenOrientationEventMap
dom.ScriptProcessorNode

Allows the generation, processing, or analyzing of audio using JavaScript.

dom.ScriptProcessorNodeEventMap
dom.ScrollIntoViewOptions
dom.ScrollOptions
dom.ScrollToOptions
dom.SecurityPolicyViolationEvent

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

dom.SecurityPolicyViolationEventInit
dom.Selection

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

dom.ServiceUIFrameContext
dom.ServiceWorker

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

dom.ServiceWorkerContainer

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

dom.ServiceWorkerContainerEventMap
dom.ServiceWorkerEventMap
dom.ServiceWorkerMessageEvent

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

dom.ServiceWorkerMessageEventInit
dom.ServiceWorkerRegistration

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

dom.ServiceWorkerRegistrationEventMap
dom.ShadowRoot
dom.ShadowRootInit
dom.Slotable
dom.SourceBuffer

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.

dom.SourceBufferEventMap
dom.SourceBufferList

A simple container list for multiple SourceBuffer objects.

dom.SourceBufferListEventMap
dom.SpeechGrammar
dom.SpeechGrammarList
dom.SpeechRecognition
dom.SpeechRecognitionAlternative
dom.SpeechRecognitionEvent
dom.SpeechRecognitionEventMap
dom.SpeechRecognitionResult
dom.SpeechRecognitionResultList
dom.SpeechSynthesis

This Web Speech API interface 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.

dom.SpeechSynthesisErrorEvent
dom.SpeechSynthesisErrorEventInit
dom.SpeechSynthesisEvent

This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service.

dom.SpeechSynthesisEventInit
dom.SpeechSynthesisEventMap
dom.SpeechSynthesisUtterance

This Web Speech API interface 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.)

dom.SpeechSynthesisUtteranceEventMap
dom.SpeechSynthesisVoice

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

dom.StaticRange
dom.StaticRangeInit
dom.StereoPannerNode

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

dom.StereoPannerOptions
dom.Storage

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

dom.StorageEstimate
dom.StorageEvent

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

dom.StorageEventInit
dom.StorageManager
dom.StoreExceptionsInformation
dom.StoreSiteSpecificExceptionsInformation
dom.StyleMedia
dom.StyleSheet

A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface.

dom.StyleSheetList

A list of StyleSheet.

dom.SubtleCrypto

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

dom.SVGAElement

Provides access to the properties of element, as well as methods to manipulate them.

dom.SVGAngle

Used to represent a value that can be an or value. An SVGAngle reflected through the animVal attribute is always read only.

dom.SVGAnimatedAngle

Used for attributes of basic type which can be animated.

dom.SVGAnimatedBoolean

Used for attributes of type boolean which can be animated.

dom.SVGAnimatedEnumeration

Used for attributes whose value must be a constant from a particular enumeration and which can be animated.

dom.SVGAnimatedInteger

Used for attributes of basic type which can be animated.

dom.SVGAnimatedLength

Used for attributes of basic type which can be animated.

dom.SVGAnimatedLengthList

Used for attributes of type SVGLengthList which can be animated.

dom.SVGAnimatedNumber

Used for attributes of basic type which can be animated.

dom.SVGAnimatedNumberList

The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated.

dom.SVGAnimatedPoints
dom.SVGAnimatedPreserveAspectRatio

Used for attributes of type SVGPreserveAspectRatio which can be animated.

dom.SVGAnimatedRect

Used for attributes of basic SVGRect which can be animated.

dom.SVGAnimatedString

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

dom.SVGAnimatedTransformList

Used for attributes which take a list of numbers and which can be animated.

dom.SVGAnimateElement
dom.SVGAnimateMotionElement
dom.SVGAnimateTransformElement
dom.SVGAnimationElement
dom.SVGBoundingBoxOptions
dom.SVGCircleElement

An interface for the element. The circle element is defined by the cx and cy attributes that denote the coordinates of the centre of the circle.

dom.SVGClipPathElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGComponentTransferFunctionElement

A base interface used by the component transfer function interfaces.

dom.SVGCursorElement
dom.SVGDefsElement

Corresponds to the element.

dom.SVGDescElement

Corresponds to the element.

dom.SVGElement

All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface.

dom.SVGElementEventMap
dom.SVGElementInstance
dom.SVGElementInstanceList
dom.SVGElementTagNameMap
dom.SVGEllipseElement

Provides access to the properties of elements.

dom.SVGFEBlendElement

Corresponds to the element.

dom.SVGFEColorMatrixElement

Corresponds to the element.

dom.SVGFEComponentTransferElement

Corresponds to the element.

dom.SVGFECompositeElement

Corresponds to the element.

dom.SVGFEConvolveMatrixElement

Corresponds to the element.

dom.SVGFEDiffuseLightingElement

Corresponds to the element.

dom.SVGFEDisplacementMapElement

Corresponds to the element.

dom.SVGFEDistantLightElement

Corresponds to the element.

dom.SVGFEDropShadowElement
dom.SVGFEFloodElement

Corresponds to the element.

dom.SVGFEFuncAElement

Corresponds to the element.

dom.SVGFEFuncBElement

Corresponds to the element.

dom.SVGFEFuncGElement

Corresponds to the element.

dom.SVGFEFuncRElement

Corresponds to the element.

dom.SVGFEGaussianBlurElement

Corresponds to the element.

dom.SVGFEImageElement

Corresponds to the element.

dom.SVGFEMergeElement

Corresponds to the element.

dom.SVGFEMergeNodeElement

Corresponds to the element.

dom.SVGFEMorphologyElement

Corresponds to the element.

dom.SVGFEOffsetElement

Corresponds to the element.

dom.SVGFEPointLightElement

Corresponds to the element.

dom.SVGFESpecularLightingElement

Corresponds to the element.

dom.SVGFESpotLightElement

Corresponds to the element.

dom.SVGFETileElement

Corresponds to the element.

dom.SVGFETurbulenceElement

Corresponds to the element.

dom.SVGFilterElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGFilterPrimitiveStandardAttributes
dom.SVGFitToViewBox
dom.SVGForeignObjectElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGGElement

Corresponds to the element.

dom.SVGGeometryElement
dom.SVGGradientElement

The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement.

dom.SVGGraphicsElement

SVG elements whose primary purpose is to directly render graphics into a group.

dom.SVGImageElement

Corresponds to the element.

dom.SVGLength

Correspond to the basic data type.

dom.SVGLengthList

The SVGLengthList defines a list of SVGLength objects.

dom.SVGLinearGradientElement

Corresponds to the element.

dom.SVGLineElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGMarkerElement
dom.SVGMaskElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGMetadataElement

Corresponds to the element.

dom.SVGNumber

Corresponds to the basic data type.

dom.SVGNumberList

The SVGNumberList defines a list of SVGNumber objects.

dom.SVGPathElement

Corresponds to the element.

dom.SVGPathSeg
dom.SVGPathSegArcAbs
dom.SVGPathSegArcRel
dom.SVGPathSegClosePath
dom.SVGPathSegCurvetoCubicAbs
dom.SVGPathSegCurvetoCubicRel
dom.SVGPathSegCurvetoCubicSmoothAbs
dom.SVGPathSegCurvetoCubicSmoothRel
dom.SVGPathSegCurvetoQuadraticAbs
dom.SVGPathSegCurvetoQuadraticRel
dom.SVGPathSegCurvetoQuadraticSmoothAbs
dom.SVGPathSegCurvetoQuadraticSmoothRel
dom.SVGPathSegLinetoAbs
dom.SVGPathSegLinetoHorizontalAbs
dom.SVGPathSegLinetoHorizontalRel
dom.SVGPathSegLinetoRel
dom.SVGPathSegLinetoVerticalAbs
dom.SVGPathSegLinetoVerticalRel
dom.SVGPathSegList
dom.SVGPathSegMovetoAbs
dom.SVGPathSegMovetoRel
dom.SVGPatternElement

Corresponds to the element.

dom.SVGPointList
dom.SVGPolygonElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGPolylineElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGPreserveAspectRatio

Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements.

dom.SVGRadialGradientElement

Corresponds to the element.

dom.SVGRectElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGScriptElement

Corresponds to the SVG element.

dom.SVGStopElement

Corresponds to the element.

dom.SVGStringList

The SVGStringList defines a list of DOMString objects.

dom.SVGStyleElement

Corresponds to the SVG element.

dom.SVGSVGElement

Provides access to the properties of 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.

dom.SVGSVGElementEventMap
dom.SVGSwitchElement

Corresponds to the element.

dom.SVGSymbolElement

Corresponds to the element.

dom.SVGTests
dom.SVGTextContentElement

Implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, SVGTRefElement, SVGAltGlyphElement and SVGTextPathElement.

dom.SVGTextElement

Corresponds to the elements.

dom.SVGTextPathElement

Corresponds to the element.

dom.SVGTextPositioningElement

Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement.

dom.SVGTitleElement

Corresponds to the element.

dom.SVGTransform

SVGTransform is the interface for one of the component transformations within an SVGTransformList; thus, an SVGTransform object corresponds to a single component (e.g., scale(ÔÇŽ) or matrix(ÔÇŽ)) within a transform attribute.

dom.SVGTransformList

The SVGTransformList defines a list of SVGTransform objects.

dom.SVGTSpanElement

A element.

dom.SVGUnitTypes

A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes.

dom.SVGURIReference
dom.SVGUseElement

Corresponds to the element.

dom.SVGViewElement

Provides access to the properties of elements, as well as methods to manipulate them.

dom.SVGZoomAndPan

Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute.

dom.SVGZoomEvent
dom.SyncManager

This ServiceWorker API interface provides an interface for registering and listing sync registrations.

dom.Text

The textual content of Element or Attr. If an element has no markup within its content, it has a single child implementing Text that contains the element's text. However, if the element contains markup, it is parsed into information items and Text nodes that form its children.

dom.TextDecodeOptions
dom.TextDecoder

A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc.┬áA decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView ÔÇô a C-like representation of strings based on typed arrays.

dom.TextDecoderCommon
dom.TextDecoderOptions
dom.TextDecoderStream
dom.TextEncoder

TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView ÔÇô a C-like representation of strings based on typed arrays.

dom.TextEncoderCommon
dom.TextEncoderEncodeIntoResult
dom.TextEncoderStream
dom.TextEvent
dom.TextMetrics

The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method.

dom.TextTrack

This interface also inherits properties from EventTarget.

dom.TextTrackCue

TextTrackCues represent a string of text that will be displayed for some duration of time on a TextTrack. This includes the start and end times that the cue will be displayed. A TextTrackCue cannot be used directly, instead one of the derived types (e.g. VTTCue) must be used.

dom.TextTrackCueEventMap
dom.TextTrackCueList
dom.TextTrackEventMap
dom.TextTrackList
dom.TextTrackListEventMap
dom.TimeRanges

Used to represent a set of time ranges, primarily for the purpose of tracking which portions of media have been buffered when loading it for use by the and  elements.

dom.Touch

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.

dom.TouchEvent

An event sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth.

dom.TouchEventInit
dom.TouchInit
dom.TouchList

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 corresponding TouchList object would have one Touch object for each finger, for a total of three entries.

dom.TrackEvent

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

dom.TrackEventInit
dom.Transformer
dom.TransformStream
dom.TransformStreamDefaultController
dom.TransformStreamDefaultControllerCallback
dom.TransformStreamDefaultControllerTransformCallback
dom.TransitionEvent

Events providing information related to transitions.

dom.TransitionEventInit
dom.TreeWalker

The nodes of a document subtree and a position within them.

dom.txAuthGenericArg
dom.UIEvent

Simple user interface events.

dom.UIEventInit
dom.ULongRange
dom.UnderlyingByteSource
dom.UnderlyingSink
dom.UnderlyingSource
dom.URL

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

dom.URLSearchParams
dom.ValidityState

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.

dom.VideoPlaybackQuality

Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video.

dom.VideoTrack

A single video track from a element.

dom.VideoTrackList

Used to represent a list of the video tracks contained within a element, with each track represented by a separate VideoTrack object in the list.

dom.VideoTrackListEventMap
dom.VoidFunction
dom.VRDisplay

This WebVR API interface represents any VR device supported by this API. It includes generic information such as device IDs and descriptions, as well as methods for starting to present a VR scene, retrieving eye parameters and display capabilities, and other important functionality.

dom.VRDisplayCapabilities

This WebVR API interface describes the capabilities of a VRDisplay ÔÇö its features can be used to perform VR device capability tests, for example can it return position information.

dom.VRDisplayEvent

This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions).

dom.VRDisplayEventInit
dom.VREyeParameters

This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information.

dom.VRFieldOfView

This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point.

dom.VRFrameData

This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData().

dom.VRLayer
dom.VRPose

This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.)

dom.VRStageParameters
dom.VTTCue
dom.VTTRegion
dom.WaveShaperNode

A WaveShaperNode always has exactly one input and one output.

dom.WaveShaperOptions
dom.WebAuthentication
dom.WebAuthnAssertion
dom.WebAuthnExtensions
dom.WEBGL_color_buffer_float
dom.WEBGL_compressed_texture_astc
dom.WEBGL_compressed_texture_s3tc

The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats.

dom.WEBGL_compressed_texture_s3tc_srgb
dom.WEBGL_debug_renderer_info

The WEBGL_debug_renderer_info extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes.

dom.WEBGL_debug_shaders
dom.WEBGL_depth_texture

The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures.

dom.WEBGL_draw_buffers
dom.WEBGL_lose_context
dom.WebGL2RenderingContext
dom.WebGL2RenderingContextBase
dom.WebGL2RenderingContextOverloads
dom.WebGLActiveInfo

Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods.

dom.WebGLBuffer

Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.

dom.WebGLContextAttributes
dom.WebGLContextEvent

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

dom.WebGLContextEventInit
dom.WebGLFramebuffer

Part of the WebGL API and represents a collection of buffers that serve as a rendering destination.

dom.WebGLObject
dom.WebGLProgram

The WebGLProgram is 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).

dom.WebGLQuery
dom.WebGLRenderbuffer

Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation.

dom.WebGLRenderingContext

Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML element.

dom.WebGLRenderingContextBase
dom.WebGLRenderingContextOverloads
dom.WebGLSampler
dom.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.

dom.WebGLShaderPrecisionFormat

Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method.

dom.WebGLSync
dom.WebGLTexture

Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.

dom.WebGLTransformFeedback
dom.WebGLUniformLocation

Part of the WebGL API and represents the location of a uniform variable in a shader program.

dom.WebGLVertexArrayObject
dom.WebGLVertexArrayObjectOES
dom.WebKitPoint
dom.webkitRTCPeerConnection
dom.WebSocket

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

dom.WebSocketEventMap
dom.WheelEvent

Events that occur due to the user moving a mouse wheel or similar input device.

dom.WheelEventInit
dom.Window

A window containing a DOM document; the document property points to the DOM document loaded in that window.

dom.WindowConsole
dom.WindowEventHandlers
dom.WindowEventHandlersEventMap
dom.WindowEventMap
dom.WindowLocalStorage
dom.WindowOrWorkerGlobalScope
dom.WindowSessionStorage
dom.Worker

This Web Workers API interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread.

dom.WorkerEventMap
dom.WorkerOptions
dom.Worklet
dom.WorkletOptions
dom.WritableStream

This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing.

dom.WritableStreamDefaultController

This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate.

dom.WritableStreamDefaultControllerCloseCallback
dom.WritableStreamDefaultControllerStartCallback
dom.WritableStreamDefaultControllerWriteCallback
dom.WritableStreamDefaultWriter

This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink.

dom.WritableStreamErrorCallback
dom.XMLDocument

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.

dom.XMLHttpRequest

Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.

dom.XMLHttpRequestEventMap
dom.XMLHttpRequestEventTarget
dom.XMLHttpRequestEventTargetEventMap
dom.XMLHttpRequestUpload
dom.XMLSerializer

Provides the serializeToString() method to construct an XML string representing a DOM tree.

dom.XPathEvaluator

The XPathEvaluator interface allows to compile and evaluate XPath expressions.

dom.XPathEvaluatorBase
dom.XPathExpression

This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree.

dom.XPathResult

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

dom.XSLTProcessor

An XSLTProcessor applies an XSLT stylesheet transformation to an XML document to produce a new XML document as output. It has methods to load the XSLT stylesheet, to manipulate xsl:param parameter values, and to apply the transformation to documents.

EventTargetLike.HasEventTargetAddRemove
EventTargetLike.HasEventTargetAddRemove.Options
EventTargetLike.JQueryStyleEventEmitter
EventTargetLike.NodeStyleEventEmitter.Compat
EventTargetLike.NodeStyleEventEmitter.Regular
Evt
Postable
StatefulEvt
StatefulPostable
VoidCtx

https://docs.evt.land/api/evt/ctx

VoidCtxLike
VoidEvt

https://docs.evt.land/api/evt/create#why-voidevt-and-not-evt-less-than-void-greater-than https://docs.evt.land/api/evt/create

Type Aliases

Ctx
Diff
dom.AAGUID
dom.AlgorithmIdentifier
dom.AlignSetting
dom.AnimationPlayState
dom.AppendMode
dom.AttestationConveyancePreference
dom.AudioContextLatencyCategory
dom.AudioContextState
dom.AuthenticationExtensionsSupported
dom.AuthenticatorAttachment
dom.AuthenticatorSelectionList
dom.AuthenticatorTransport
dom.AutoKeyword
dom.AutomationRate
dom.BigInteger
dom.BinaryType
dom.BiquadFilterType
dom.BlobPart
dom.BodyInit
dom.BufferSource
dom.CanPlayTypeResult
dom.CanvasDirection
dom.CanvasFillRule
dom.CanvasImageSource
dom.CanvasLineCap
dom.CanvasLineJoin
dom.CanvasTextAlign
dom.CanvasTextBaseline
dom.ChannelCountMode
dom.ChannelInterpretation
dom.ClientTypes
dom.CompositeOperation
dom.CompositeOperationOrAuto
dom.ConstrainBoolean
dom.ConstrainDOMString
dom.ConstrainDouble
dom.ConstrainULong
dom.COSEAlgorithmIdentifier
dom.CredentialMediationRequirement
dom.DirectionSetting
dom.DisplayCaptureSurfaceType
dom.DistanceModelType
dom.DocumentReadyState
dom.DOMHighResTimeStamp
dom.DOMTimeStamp
dom.ElementTagNameMap ­čĹÄ deprecated
dom.EndingType
dom.EndOfStreamError
dom.EventListenerOrEventListenerObject
dom.FillMode
dom.Float32List
dom.FormDataEntryValue
dom.FullscreenNavigationUI
dom.GamepadHand
dom.GamepadHapticActuatorType
dom.GamepadMappingType
dom.GLbitfield
dom.GLboolean
dom.GLclampf
dom.GLenum
dom.GLfloat
dom.GLint
dom.GLint64
dom.GLintptr
dom.GLsizei
dom.GLsizeiptr
dom.GLuint
dom.GLuint64
dom.HashAlgorithmIdentifier
dom.HeadersInit

Occurs when playback stops because the next frame of a video resource is not available.

dom.HTMLOrSVGImageElement
dom.HTMLOrSVGScriptElement
dom.IDBCursorDirection
dom.IDBKeyPath
dom.IDBRequestReadyState
dom.IDBTransactionMode
dom.IDBValidKey
dom.ImageBitmapSource
dom.ImageSmoothingQuality
dom.InsertPosition
dom.Int32List
dom.IterationCompositeOperation
dom.KeyFormat
dom.KeyType
dom.KeyUsage
dom.LineAlignSetting
dom.LineAndPositionSetting
dom.ListeningState
dom.MediaDeviceKind
dom.MediaKeyMessageType
dom.MediaKeySessionType
dom.MediaKeysRequirement
dom.MediaKeyStatus
dom.MediaStreamTrackState
dom.MessageEventSource
dom.MouseWheelEvent ­čĹÄ deprecated
dom.MSCredentialType
dom.MSTransportType
dom.MSWebViewPermissionState
dom.MSWebViewPermissionType
dom.MutationRecordType
dom.NamedCurve
dom.NavigationReason
dom.NavigationType
dom.NotificationDirection
dom.NotificationPermission
dom.OffscreenRenderingContext
dom.OffscreenRenderingContextId
dom.OnBeforeUnloadEventHandler
dom.OnErrorEventHandler
dom.OrientationLockType
dom.OrientationType
dom.OscillatorType
dom.OverSampleType
dom.PanningModelType
dom.PaymentComplete
dom.PaymentShippingType
dom.PerformanceEntryList
dom.PermissionName
dom.PermissionState
dom.PlaybackDirection
dom.PositionAlignSetting
dom.PublicKeyCredentialType
dom.PushEncryptionKeyName
dom.PushPermissionState
dom.ReadableStreamReadResult
dom.ReadyState
dom.ReferrerPolicy
dom.RenderingContext
dom.RequestCache
dom.RequestCredentials
dom.RequestDestination
dom.RequestInfo
dom.RequestMode
dom.RequestRedirect
dom.ResponseType
dom.RTCBundlePolicy
dom.RTCDataChannelState
dom.RTCDegradationPreference
dom.RTCDtlsRole
dom.RTCDtlsTransportState
dom.RTCDtxStatus
dom.RTCErrorDetailType
dom.RTCIceCandidateType
dom.RTCIceComponent
dom.RTCIceConnectionState
dom.RTCIceCredentialType
dom.RTCIceGatherCandidate
dom.RTCIceGathererState
dom.RTCIceGatheringState
dom.RTCIceGatherPolicy
dom.RTCIceProtocol
dom.RTCIceRole
dom.RTCIceTcpCandidateType
dom.RTCIceTransportPolicy
dom.RTCIceTransportState
dom.RTCPeerConnectionState
dom.RTCPriorityType
dom.RTCRtcpMuxPolicy
dom.RTCRtpTransceiverDirection
dom.RTCSctpTransportState
dom.RTCSdpType
dom.RTCSignalingState
dom.RTCStatsIceCandidatePairState
dom.RTCStatsIceCandidateType
dom.RTCStatsType
dom.RTCTransport
dom.ScopedCredentialType
dom.ScrollBehavior
dom.ScrollLogicalPosition
dom.ScrollRestoration
dom.ScrollSetting
dom.SelectionMode
dom.ServiceWorkerState
dom.ServiceWorkerUpdateViaCache
dom.ShadowRootMode
dom.SpeechSynthesisErrorCode
dom.SupportedType
dom.SVGMatrix
dom.SVGPoint
dom.SVGRect
dom.TexImageSource
dom.TextTrackKind
dom.TextTrackMode
dom.TimerHandler
dom.TouchType
dom.Transferable
dom.Transport
dom.Uint32List
dom.UserVerificationRequirement
dom.UvmEntries
dom.UvmEntry
dom.VibratePattern
dom.VideoFacingModeEnum
dom.VisibilityState
dom.VRDisplayEventReason
dom.WebGLPowerPreference
dom.WebKitCSSMatrix
dom.webkitURL
dom.WindowProxy
dom.WorkerType
dom.XMLHttpRequestResponseType
dom.XPathNSResolver
DoneOrAborted
DoneOrAborted.Aborted
DoneOrAborted.Done
EventTargetLike
EventTargetLike.Document
EventTargetLike.HTMLElement
EventTargetLike.NodeStyleEventEmitter
EventTargetLike.NodeStyleEventEmitter.NodeEventHandler
EventTargetLike.RxJSSubject
EventTargetLike.RxJSSubject.Subscription
EventTargetLike.Window
Evt

https://docs.evt.land/api/evt

EvtError
EvtError.Detached
EvtError.Timeout
EvtLike

Minimal interface that an object have to implement to be considered as being most certainly an Evt instance

FactorizeEvt

https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than

Handler

https://docs.evt.land/api/handler

Handler.PropsFromArgs

Handlers params that come from the arguments passed to the method invoked

Handler.PropsFromMethodName

Handlers params that are implicitly specified by the method used: attachOnce => once attachOncePrepend => once + prepend waitFor => once + async ...

Handler.PropsFromMethodName.Async
Handler.PropsFromMethodName.Sync
Handler.WithEvt
NonPostableEvt
Operator

https://docs.evt.land/api/operator

Operator.f╬╗
Operator.f╬╗.Result
Operator.f╬╗.Result.Detach
Operator.f╬╗.Result.Detach.FromEvt
Operator.f╬╗.Result.Detach.WithCtxArg
Operator.f╬╗.Result.Detach.WithCtxArg.Arg
Operator.f╬╗.Result.Detach.WithCtxArg.Void
Operator.f╬╗.Result.Matched
Operator.f╬╗.Result.Matched.NoDetachArg
Operator.f╬╗.Result.Matched.WithDetachArg
Operator.f╬╗.Result.NotMatched
Operator.f╬╗.Stateful
Operator.f╬╗.Stateless
Operator.Stateless
StatefulEvt

https://docs.evt.land/api/statefulevt

StatefulReadonlyEvt
SwapEvtType

https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than

ToNonPostableEvt

https://docs.evt.land/api/helpertypes#tononpostableevt-less-than-e-greater-than

ToPostableEvt

https://docs.evt.land/api/helpertypes#topostableevt-less-than-e-greater-than

UnpackCtx

Analog to UnpackEvt Unpack the type argument of a Ctx

UnpackEvt

https://docs.evt.land/api/helpertypes#unpackevt-less-than-e-greater-than

­čĺžEventEmitter's typesafe replacement­čĺž

Home - Documentation - v2.0 ­čÜÇ


'evt' is intended to be a replacement for 'events'.
It enables and encourages functional programming and makes heavy use of typescript's type inference features to provide type safety while keeping things concise and elegant ­čŹŞ.

Suitable for any JS runtime env (deno, node, old browsers, react-native ...)

  • Ôťů It is both a Deno and an NPM module. ( Achieved with Denoify )
  • Ôťů Lightweight, no dependency.
  • Ôťů Can be imported with require (CJS) or import (ESM) as long as you install evt@beta
  • Ôťů React Hooks integration

Can be imported in TypeScript projects using version >= 3.4 (Mar 2019) and in any plain JS projects.

TL;DR*

import { Evt } from "evt";

const evtText = new Evt<string>();
const evtTime = new Evt<number>();

evtText.attach(text => console.log(text));
evtTime.attachOnce(time => console.log(time));

evtText.post("hi!"); //Prints "hi!"
evtTime.post(123);   //Prints "123"
evtTime.post(1234);  //Prints nothing

OR

import { Evt, to } from "evt";

const evt = new Evt<
    [ "text",  string ] | 
    [ "time",  number ]
>();

//Mind the '$' prefixing 'attach'
evt.$attach(to("text"), text => console.log(text));
evt.$attachOnce(to("time"), time => console.log(time));

evt.post(["text", "hi!"]);
evt.post(["time", 123]);
evt.post(["time", 1234]);

in React, it let you attach event listeners without having to worry about detaching them.

import { useState } from "react";
import { Evt } from "evt";
import { useEvt } from "evt/hooks";

const evtTick = Evt.create();

setInterval(()=> evtTick.post(), 1000);

function App(){

    const [count, setCount]= useState(0);

    useEvt(ctx=> {
    
        evtTick.attach(ctx, ()=> setCount(count+1));
    
    },[count]);
    
    return <h1>tick count: {count}</h1>;


}

run it

*Those are introductory examples, EVT can do much more than this.

Who is using it


Install / Import

In Deno:

import { Evt } from "https://deno.land/x/evt/mod.ts";

Anywhere else:

$ npm install --save evt
# OR npm install --save evt@beta for the latest features
import { Evt } from "evt"; 

Import from HTML, with CDN

<script src="//unpkg.com/evt/bundle.min.js"></script>
<script>
    const { Evt } = window["evt"];
</script>

Try it

Run some examples

Motivations

There are a lot of things that can't easily be done with EventEmitter:

  • Enforcing type safety.
  • Removing a particular listener ( if the callback is an anonymous function ).
  • Adding a one-time listener for the next event that meets a condition.
  • Waiting (via a Promise) for one thing or another to happen.
    Example: waiting at most one second for the next message, stop waiting if the socket disconnects.

Why would someone pick EVT over RxJS:

  • RxJS introduces a lot of abstractions. It's a big jump from EventEmitter.
  • With RxJS It is often needed to resort to custom type guards, the filter operator breaks the type inference.
  • RxJS tends to be quite verbose.
  • It could be months before RxJS it eventually supports Deno.
  • No official guideline on how to integrate RxJS with React.

EVT is an attempt to address all these points while trying to remain as accessible as EventEmitter.


Get started

The sticker

Shop