Helper class used to create streams abstracting DOM events. This is a piece of the helper layer directly derived from a similar feature in dart:html.

EventStreamProviders

Statically accessible EventStreamProviders for all event types.

FilterResult

Filter result.

HSLColor

A color represented using alpha, hue, saturation, and lightness.

HSVColor

A color represented using alpha, hue, saturation, and value.

HttpRequest

Warning

This class is deprecated and will be removed in a future release of package:web.

You should instead use the cross-platform package:http and its BrowserClient adapter on top of XMLHttpRequest.

HttpStatus

HTTP status codes.

ImagePerspectiveFilter

A filter that applies a perspective to an image.

ImagePerspectiveFilterCache

A cache for perspective filers.

ImageScaledCache

A cache for scaled images.

JS

An annotation on a JavaScript interop declaration.

JSExport

Annotation to allow Dart classes to be wrapped with a JS object using dart:js_interop's createJSInteropWrapper.

JSImmutableListWrapper<T extends JSObject, U extends JSObject>

A wrapper to present a JS immutable list of type T and list item type U as a List<U>.

KeyCode

KeyLocation

Label<T extends num>

State

A state stored in DataStorage.

StorageValue

Represents a value stored in State.

StyleColor

Specifies a CSS color.

TextStyle

Specifies a CSS text style.

TouchListWrapper

TrackElementInViewport

Tracks a DOM Element to identify when its visible in viewport.

TrackElementResize

Tracks a DOM Element to identify when its size changes.

TrackElementValue

Tracks a DOM Element to identify when a value changes.

ViewerElement<T>

Represents an element in the CanvasImageViewer.

Enums

DataStorageType: Type of DataStorage.
EditionType: The type of edition for CanvasImageViewer.
FontStyle: Specifies a CSS font style.
FontWeight: Specifies a CSS font weight.
Quality: Quality of an image.
StateOperation: State operation.
TouchDeviceDetection: Status type of touch device detection.
Web<T>

Extension Types

$Console: The console object provides access to the debugging console (e.g., the Web console in Firefox).
$CSS: The CSS interface holds useful CSS-related methods. No objects with this interface are implemented: it contains only static methods and is therefore a utilitarian interface.
$GPUBufferUsage
$GPUColorWrite
$GPUMapMode
$GPUShaderStage
$GPUTextureUsage
$WebAssembly
AbortController: The AbortController interface represents a controller object that allows you to abort one or more Web requests as and when desired.
AbortSignal: The AbortSignal interface represents a signal object that allows you to communicate with an asynchronous operation (such as a fetch request) and abort it if required via an AbortController object.
AbsoluteOrientationSensor: The AbsoluteOrientationSensor interface of the Sensor APIs describes the device's physical orientation in relation to the Earth's reference coordinate system.
AbstractRange: The AbstractRange abstract interface is the base class upon which all range types are defined. A range is an object that indicates the start and end points of a section of content within the document.
AccelerometerSensorOptions
AddEventListenerOptions
AnalyserNode: The AnalyserNode interface represents a node able to provide real-time frequency and time-domain analysis information. It is an AudioNode that passes the audio stream unchanged from the input to the output, but allows you to take the generated data, process it, and create audio visualizations.
AnalyserOptions
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.
Animation: The Animation interface of the Web Animations API represents a single animation player and provides playback controls and a timeline for an animation node or source.
AnimationEffect: The AnimationEffect interface of the Web Animations API is an interface representing animation effects.
AnimationEvent: The AnimationEvent interface represents events providing information related to animations.
AnimationEventInit
AnimationPlaybackEvent: The AnimationPlaybackEvent interface of the Web Animations API represents animation events.
AnimationPlaybackEventInit
AnimationTimeline: The AnimationTimeline interface of the Web Animations API represents the timeline of an animation. This interface exists to define timeline features, inherited by other timeline types:
AssignedNodesOptions
Attr: The Attr interface represents one of an element's attributes as an object. In most situations, you will directly retrieve the attribute value as a string (e.g., Element.getAttribute), but some cases may require interacting with Attr instances (e.g., Element.getAttributeNode).
AttributionReportingRequestOptions
AudioBuffer: The AudioBuffer interface represents a short audio asset residing in memory, created from an audio file using the BaseAudioContext.decodeAudioData method, or from raw data using BaseAudioContext.createBuffer. Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode.
AudioBufferOptions
AudioBufferSourceNode: The AudioBufferSourceNode interface is an AudioScheduledSourceNode which represents an audio source consisting of in-memory audio data, stored in an AudioBuffer.
AudioBufferSourceOptions
AudioConfiguration
AudioContext: The AudioContext interface represents an audio-processing graph built from audio modules linked together, each represented by an AudioNode.
AudioContextOptions
AudioDestinationNode: The AudioDestinationNode interface represents the end destination of an audio graph in a given context — usually the speakers of your device. It can also be the node that will "record" the audio data when used with an OfflineAudioContext.
AudioListener: The AudioListener interface represents the position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to the AudioListener stored in the BaseAudioContext.listener attribute.
AudioNode: The AudioNode interface is a generic interface for representing an audio processing module.
AudioNodeOptions
AudioParam: The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain).
AudioParamMap: The AudioParamMap interface of the Web Audio API represents an iterable and read-only set of multiple audio parameters.
AudioProcessingEvent: The AudioProcessingEvent interface of the Web Audio API represents events that occur when a ScriptProcessorNode input buffer is ready to be processed.
AudioProcessingEventInit
AudioScheduledSourceNode: The AudioScheduledSourceNode interface—part of the Web Audio API—is a parent interface for several types of audio source node interfaces which share the ability to be started and stopped, optionally at specified times. Specifically, this interface defines the AudioScheduledSourceNode.start and AudioScheduledSourceNode.stop methods, as well as the AudioScheduledSourceNode.ended_event event.
AudioSinkOptions
AudioTimestamp
AudioTrack: The AudioTrack interface represents a single audio track from one of the HTML media elements, audio or video.
AudioTrackList: The AudioTrackList interface is used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list.
AudioWorklet: The AudioWorklet interface of the Web Audio API is used to supply custom audio processing scripts that execute in a separate thread to provide very low latency audio processing.
AudioWorkletGlobalScope: The AudioWorkletGlobalScope interface of the Web Audio API represents a global execution context for user-supplied code, which defines custom AudioWorkletProcessor-derived classes.
AudioWorkletNode: Note: Although the interface is available outside secure contexts, the BaseAudioContext.audioWorklet property is not, thus custom AudioWorkletProcessors cannot be defined outside them.
AudioWorkletNodeOptions
AudioWorkletProcessor: The AudioWorkletProcessor interface of the Web Audio API represents an audio processing code behind a custom AudioWorkletNode. It lives in the AudioWorkletGlobalScope and runs on the Web Audio rendering thread. In turn, an AudioWorkletNode based on it runs on the main thread.
AuthenticationExtensionsClientInputs
AuthenticationExtensionsClientOutputs
AuthenticationExtensionsLargeBlobInputs
AuthenticationExtensionsLargeBlobOutputs
AuthenticationExtensionsPaymentInputs
AuthenticationExtensionsPRFInputs
AuthenticationExtensionsPRFOutputs
AuthenticationExtensionsPRFValues
AuthenticationExtensionsSupplementalPubKeysInputs
AuthenticationExtensionsSupplementalPubKeysOutputs
AuthenticatorAssertionResponse: The AuthenticatorAssertionResponse interface of the Web Authentication API contains a digital signature from the private key of a particular WebAuthn credential. The relying party's server can verify this signature to authenticate a user, for example when they sign in.
AuthenticatorAttestationResponse: The AuthenticatorAttestationResponse interface of the Web Authentication API is the result of a WebAuthn credential registration. It contains information about the credential that the server needs to perform WebAuthn assertions, such as its credential ID and public key.
AuthenticatorResponse: The AuthenticatorResponse interface of the Web Authentication API is the base interface for interfaces that provide a cryptographic root of trust for a key pair. The child interfaces include information from the browser such as the challenge origin and either may be returned from PublicKeyCredential.response.
AuthenticatorSelectionCriteria
AvcEncoderConfig
BarProp: The BarProp interface of the Document Object Model represents the web browser user interface elements that are exposed to scripts in web pages. Each of the following interface elements are represented by a BarProp object.
BaseAudioContext: The BaseAudioContext interface of the Web Audio API acts as a base definition for online and offline audio-processing graphs, as represented by AudioContext and OfflineAudioContext respectively. You wouldn't use BaseAudioContext directly — you'd use its features via one of these two inheriting interfaces.
BatteryManager: The BatteryManager interface of the Battery Status API provides information about the system's battery charge level. The navigator.getBattery method returns a promise that resolves with a BatteryManager interface.
BeforeUnloadEvent: The BeforeUnloadEvent interface represents the event object for the Window.beforeunload_event event, which is fired when the current window, contained document, and associated resources are about to be unloaded.
BiquadFilterNode: The BiquadFilterNode interface represents a simple low-order filter, and is created using the BaseAudioContext.createBiquadFilter method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. A BiquadFilterNode always has exactly one input and one output.
BiquadFilterOptions
Blob: The Blob interface represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a ReadableStream so its methods can be used for processing the data.
BlobEvent: The BlobEvent interface of the MediaStream Recording API represents events associated with a Blob. These blobs are typically, but not necessarily, associated with media content.
BlobEventInit
BlobPropertyBag
BluetoothUUID: The BluetoothUUID interface of the Web Bluetooth API provides a way to look up Universally Unique Identifier (UUID) values by name in the registry maintained by the Bluetooth SIG.
BroadcastChannel: The BroadcastChannel interface represents a named channel that any of a given can subscribe to. It allows communication between different documents (in different windows, tabs, frames or iframes) of the same origin. Messages are broadcasted via a BroadcastChannel.message_event event fired at all BroadcastChannel objects listening to the channel, except the object that sent the message.
ByteLengthQueuingStrategy: The ByteLengthQueuingStrategy interface of the Streams API provides a built-in byte length queuing strategy that can be used when constructing streams.
Cache: The Cache interface provides a persistent storage mechanism for Request / Response object pairs that are cached in long lived memory. How long a Cache object lives is browser dependent, but a single origin's scripts can typically rely on the presence of a previously populated Cache object. 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.
CacheQueryOptions
CacheStorage: The CacheStorage interface represents the storage for Cache objects.
CanvasCaptureMediaStreamTrack: The CanvasCaptureMediaStreamTrack interface of the Media Capture and Streams API represents the video track contained in a MediaStream being generated from a canvas following a call to HTMLCanvasElement.captureStream.
CanvasGradient: The CanvasGradient interface represents an opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient, CanvasRenderingContext2D.createConicGradient or CanvasRenderingContext2D.createRadialGradient.
CanvasPattern: The CanvasPattern interface represents an opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern method.
CanvasRenderingContext2D: The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a canvas element. It is used for drawing shapes, text, images, and other objects.
CanvasRenderingContext2DSettings
CaretPositionFromPointOptions
CDATASection: The CDATASection interface represents a CDATA section that can be used within XML to include extended portions of unescaped text. When inside a CDATA section, the symbols < and & don't need escaping as they normally do.
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.
ChannelMergerOptions
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.
ChannelSplitterOptions
ChapterInformationInit
CharacterData: The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any objects of type CharacterData: it is implemented by other interfaces like Text, Comment, CDATASection, or ProcessingInstruction, which aren't abstract.
CheckVisibilityOptions
Client: @AvailableInWorkers("service")
ClientQueryOptions
Clients: @AvailableInWorkers("service")
Clipboard: The Clipboard interface of the Clipboard API provides read and write access to the contents of the system clipboard. This allows a web application to implement cut, copy, and paste features.
ClipboardEvent: The ClipboardEvent interface of the Clipboard API represents events providing information related to modification of the clipboard, that is Element.cut_event, Element.copy_event, and Element.paste_event events.
ClipboardEventInit
ClipboardItem: The ClipboardItem interface of the Clipboard API represents a single item format, used when reading or writing clipboard data using clipboard.read and clipboard.write respectively.
ClipboardItemOptions
ClipboardUnsanitizedFormats
CloseEvent: A CloseEvent is sent to clients using when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute.
CloseEventInit
Comment: The Comment interface represents textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.
CompositionEvent: The DOM CompositionEvent represents events that occur due to the user indirectly entering text.
CompositionEventInit
CompressionStream: The CompressionStream interface of the Compression Streams API is an API for compressing a stream of data.
ComputedEffectTiming
ConstantSourceNode: The ConstantSourceNode interface—part of the Web Audio API—represents an audio source (based upon AudioScheduledSourceNode) whose output is single unchanging value. This makes it useful for cases in which you need a constant value coming in from an audio source. In addition, it can be used like a constructible AudioParam by automating the value of its ConstantSourceNode.offset or by connecting another node to it; see Controlling multiple parameters with ConstantSourceNode.
ConstantSourceOptions
ConstrainBooleanParameters
ConstrainDOMStringParameters
ConstrainDoubleRange
ConstrainPoint2DParameters
ConstrainULongRange
ContentVisibilityAutoStateChangeEvent: The ContentVisibilityAutoStateChangeEvent interface is the event object for the element.contentvisibilityautostatechange_event event, which fires on any element with set on it when it starts or stops being relevant to the user and skipping its contents.
ContentVisibilityAutoStateChangeEventInit
ConvolverNode: The ConvolverNode interface is an AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. A ConvolverNode always has exactly one input and one output.
ConvolverOptions
CookieChangeEvent: The CookieChangeEvent interface of the Cookie Store API is the event type of the CookieStore.change_event event fired at a CookieStore when any cookie changes occur. A cookie change consists of a cookie and a type (either "changed" or "deleted").
CookieChangeEventInit
CookieInit
CookieListItem
CookieStore: @AvailableInWorkers("window_and_service")
CookieStoreDeleteOptions
CookieStoreGetOptions
CookieStoreManager: @AvailableInWorkers("window_and_service")
CountQueuingStrategy: The CountQueuingStrategy interface of the Streams API provides a built-in chunk counting queuing strategy that can be used when constructing streams.
Credential: The Credential interface of the Credential Management API provides information about an entity (usually a user) normally as a prerequisite to a trust decision.
CredentialCreationOptions
CredentialData
CredentialPropertiesOutput
CredentialRequestOptions
CredentialsContainer: The CredentialsContainer interface of the Credential Management API exposes methods to request credentials and notify the user agent when events such as successful sign in or sign out happen. This interface is accessible from Navigator.credentials.
Crypto: The Crypto interface represents basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.
CryptoKey: The CryptoKey interface of the Web Crypto API represents a cryptographic obtained from one of the SubtleCrypto methods SubtleCrypto.generateKey, SubtleCrypto.deriveKey, SubtleCrypto.importKey, or SubtleCrypto.unwrapKey.
CSPViolationReportBody: The CSPViolationReportBody interface contains the report data for a Content Security Policy (CSP) violation. CSP violations are thrown when the webpage attempts to load a resource that violates the CSP set by the HTTP header.
CSSAnimation: The CSSAnimation interface of the Web Animations API represents an Animation object.
CSSConditionRule: An object implementing the CSSConditionRule interface represents a single condition CSS at-rule, which consists of a condition and a statement block.
CSSContainerRule: The CSSContainerRule interface represents a single CSS rule.
CSSCounterStyleRule: The CSSCounterStyleRule interface represents an at-rule.
CSSFontFaceRule: The CSSFontFaceRule interface represents an at-rule.
CSSFontFeatureValuesRule: The CSSFontFeatureValuesRule interface represents an at-rule, letting developers assign for each font face a common name to specify features indices to be used in .
CSSFontPaletteValuesRule: The CSSFontPaletteValuesRule interface represents an at-rule.
CSSGroupingRule: The CSSGroupingRule interface of the CSS Object Model represents any CSS at-rule that contains other rules nested within it.
CSSImageValue: The CSSImageValue interface of the CSS Typed Object Model API represents values for properties that take an image, for example , , or .
CSSImportRule: The CSSImportRule interface represents an at-rule.
CSSKeyframeRule: The CSSKeyframeRule interface describes an object representing a set of styles for a given keyframe. It corresponds to the contents of a single keyframe of a at-rule.
CSSKeyframesRule: The CSSKeyframesRule interface describes an object representing a complete set of keyframes for a CSS animation. It corresponds to the contents of a whole at-rule.
CSSKeywordValue: The CSSKeywordValue interface of the CSS Typed Object Model API creates an object to represent CSS keywords and other identifiers.
CSSLayerBlockRule: The CSSLayerBlockRule represents a block rule. It is a grouping at-rule meaning that it can contain other rules, and is associated to a given cascade layer, identified by its name.
CSSLayerStatementRule: The CSSLayerStatementRule represents a statement rule. Unlike CSSLayerBlockRule, it doesn't contain other rules and merely defines one or several layers by providing their names.
CSSMathClamp
CSSMathInvert: The CSSMathInvert interface of the CSS Typed Object Model API represents a CSS calc() used as calc(1 / <value>). It inherits properties and methods from its parent CSSNumericValue.
CSSMathMax: The CSSMathMax interface of the CSS Typed Object Model API represents the CSS max() function. It inherits properties and methods from its parent CSSNumericValue.
CSSMathMin: The CSSMathMin interface of the CSS Typed Object Model API represents the CSS min() function. It inherits properties and methods from its parent CSSNumericValue.
CSSMathNegate: The CSSMathNegate interface of the CSS Typed Object Model API negates the value passed into it. It inherits properties and methods from its parent CSSNumericValue.
CSSMathProduct: The CSSMathProduct interface of the CSS Typed Object Model API represents the result obtained by calling CSSNumericValue.add, CSSNumericValue.sub, or CSSNumericValue.toSum on CSSNumericValue. It inherits properties and methods from its parent CSSNumericValue.
CSSMathSum: The CSSMathSum interface of the CSS Typed Object Model API represents the result obtained by calling CSSNumericValue.add, CSSNumericValue.sub, or CSSNumericValue.toSum on CSSNumericValue.
CSSMathValue: The CSSMathValue interface of the CSS Typed Object Model API a base class for classes representing complex numeric values.
CSSMatrixComponent: The CSSMatrixComponent interface of the CSS Typed Object Model API represents the matrix() and matrix3d() values of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSMatrixComponentOptions
CSSMediaRule: The CSSMediaRule interface represents a single CSS rule.
CSSNamespaceRule: The CSSNamespaceRule interface describes an object representing a single CSS at-rule.
CSSNumericArray: The CSSNumericArray interface of the CSS Typed Object Model API contains a list of CSSNumericValue objects.
CSSNumericType
CSSNumericValue: The CSSNumericValue interface of the CSS Typed Object Model API represents operations that all numeric values can perform.
CSSPageRule: CSSPageRule represents a single CSS rule.
CSSPerspective: The CSSPerspective interface of the CSS Typed Object Model API represents the perspective() value of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSPropertyRule: The CSSPropertyRule interface of the CSS Properties and Values API represents a single CSS rule.
CSSRotate: The CSSRotate interface of the CSS Typed Object Model API represents the rotate value of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSRule: The CSSRule interface represents a single CSS rule. There are several types of rules which inherit properties from CSSRule.
CSSRuleList: A CSSRuleList represents an ordered collection of read-only CSSRule objects.
CSSScale: The CSSScale interface of the CSS Typed Object Model API represents the scale() and scale3d() values of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSScopeRule: The CSSScopeRule interface of the CSS Object Model represents a CSS at-rule.
CSSSkew: The CSSSkew interface of the CSS Typed Object Model API is part of the CSSTransformValue interface. It represents the skew() value of the individual transform property in CSS.
CSSSkewX: The CSSSkewX interface of the CSS Typed Object Model API represents the skewX() value of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSSkewY: The CSSSkewY interface of the CSS Typed Object Model API represents the skewY() value of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSStartingStyleRule: The CSSStartingStyleRule interface of the CSS Object Model represents a CSS at-rule.
CSSStyleDeclaration: The CSSStyleDeclaration interface represents an object that is a CSS declaration block, and exposes style information and various style-related methods and properties.
CSSStyleRule: The CSSStyleRule interface represents a single CSS style rule.
CSSStyleSheet: The CSSStyleSheet interface represents a single CSS stylesheet, and lets you inspect and modify the list of rules contained in the stylesheet. It inherits properties and methods from its parent, StyleSheet.
CSSStyleSheetInit
CSSStyleValue: The CSSStyleValue interface of the CSS Typed Object Model API is the base class of all CSS values accessible through the Typed OM API. An instance of this class may be used anywhere a string is expected.
CSSSupportsRule: The CSSSupportsRule interface represents a single CSS at-rule.
CSSTransformComponent: The CSSTransformComponent interface of the CSS Typed Object Model API is part of the CSSTransformValue interface.
CSSTransformValue: The CSSTransformValue interface of the CSS Typed Object Model API represents transform-list values as used by the CSS transform property.
CSSTransition: The CSSTransition interface of the Web Animations API represents an Animation object used for a CSS Transition.
CSSTranslate: The CSSTranslate interface of the CSS Typed Object Model API represents the translate() value of the individual transform property in CSS. It inherits properties and methods from its parent CSSTransformValue.
CSSUnitValue: The CSSUnitValue interface of the CSS Typed Object Model API represents values that contain a single unit type. For example, "42px" would be represented by a CSSNumericValue.
CSSUnparsedValue: The CSSUnparsedValue interface of the CSS Typed Object Model API represents property values that reference custom properties. It consists of a list of string fragments and variable references.
CSSVariableReferenceValue: The CSSVariableReferenceValue interface of the CSS Typed Object Model API allows you to create a custom name for a built-in CSS value. This object functionality is sometimes called a "CSS variable" and serves the same purpose as the var() function. The custom name must begin with two dashes.
CustomElementRegistry: The CustomElementRegistry interface provides methods for registering custom elements and querying registered elements. To get an instance of it, use the window.customElements property.
CustomEvent: The CustomEvent interface represents events initialized by an application for any purpose.
CustomEventInit
CustomStateSet: The CustomStateSet interface of the Document Object Model stores a list of states for an autonomous custom element, and allows states to be added and removed from the set.
DataTransfer: The DataTransfer object is used to hold the data that is being dragged during a drag and drop operation. It may hold one or more data items, each of one or more data types. For more information about drag and drop, see HTML Drag and Drop API.
DataTransferItem: The DataTransferItem object represents one drag data item. During a drag operation, each DragEvent has a DragEvent.dataTransfer property which contains a DataTransferItemList of drag data items. Each item in the list is a DataTransferItem object.
DataTransferItemList: The DataTransferItemList object is a list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a DragEvent.dataTransfer property and that property is a DataTransferItemList.
DecompressionStream: The DecompressionStream interface of the Compression Streams API is an API for decompressing a stream of data.
DedicatedWorkerGlobalScope: @AvailableInWorkers("dedicated")
DelayNode: The DelayNode interface represents a delay-line; an AudioNode audio-processing module that causes a delay between the arrival of an input data and its propagation to the output.
DelayOptions
DeviceMotionEvent: The DeviceMotionEvent interface of the Device Orientation Events provides web developers with information about the speed of changes for the device's position and orientation.
DeviceMotionEventAcceleration: The DeviceMotionEventAcceleration interface of the Device Orientation Events provides information about the amount of acceleration the device is experiencing along all three axes.
DeviceMotionEventAccelerationInit
DeviceMotionEventInit
DeviceMotionEventRotationRate: A DeviceMotionEventRotationRate interface of the Device Orientation Events provides information about the rate at which the device is rotating around all three axes.
DeviceMotionEventRotationRateInit
DeviceOrientationEvent: The DeviceOrientationEvent interface of the Device Orientation Events provides web developers with information from the physical orientation of the device running the web page.
DeviceOrientationEventInit
DigitalCredentialRequestOptions
DisplayMediaStreamOptions
Document: The Document interface represents any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree.
DocumentFragment: The DocumentFragment interface represents a minimal document object that has no parent.
DocumentTimeline: The DocumentTimeline interface of the Web Animations API represents animation timelines, including the default document timeline (accessed via Document.timeline).
DocumentTimelineOptions
DocumentType: The DocumentType interface represents a Node containing a doctype.
DOMException: The DOMException interface represents an abnormal event (called an exception) that occurs as a result of calling a method or accessing a property of a web API. This is how error conditions are described in web APIs.
DOMImplementation: The DOMImplementation interface represents an object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property.
DOMMatrix: The DOMMatrix interface represents 4×4 matrices, suitable for 2D and 3D operations including rotation and translation. It is a mutable version of the DOMMatrixReadOnly interface.
DOMMatrix2DInit
DOMMatrixInit
DOMMatrixReadOnly: The DOMMatrixReadOnly interface represents a read-only 4×4 matrix, suitable for 2D and 3D operations. The DOMMatrix interface — which is based upon DOMMatrixReadOnly—adds mutability, allowing you to alter the matrix after creating it.
DOMParser: The DOMParser interface provides the ability to parse or source code from a string into a DOM Document.
DOMPoint: A DOMPoint object represents a 2D or 3D point in a coordinate system; it includes values for the coordinates in up to three dimensions, as well as an optional perspective value. DOMPoint is based on DOMPointReadOnly but allows its properties' values to be changed.
DOMPointInit
DOMPointReadOnly: The DOMPointReadOnly interface specifies the coordinate and perspective fields used by DOMPoint to define a 2D or 3D point in a coordinate system.
DOMQuad: A DOMQuad is a collection of four DOMPoints defining the corners of an arbitrary quadrilateral. Returning DOMQuads lets getBoxQuads() return accurate information even when arbitrary 2D or 3D transforms are present. It has a handy bounds attribute returning a DOMRectReadOnly for those cases where you just want an axis-aligned bounding rectangle.
DOMQuadInit
DOMRect: A DOMRect describes the size and position of a rectangle.
DOMRectInit
DOMRectList
DOMRectReadOnly: The DOMRectReadOnly interface specifies the standard properties (also used by DOMRect) to define a rectangle whose properties are immutable.
DOMStringList: The DOMStringList interface is a legacy type returned by some APIs and represents a non-modifiable list of strings (DOMString).
DOMStringMap: The DOMStringMap interface is used for the HTMLElement.dataset attribute, to represent data for custom attributes added to elements.
DOMTokenList: The DOMTokenList interface represents a set of space-separated tokens. Such a set is returned by Element.classList or HTMLLinkElement.relList, and many others.
DoubleRange
DragEvent: The DragEvent interface is a 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.
DragEventInit
DynamicsCompressorNode: The DynamicsCompressorNode interface provides a compression effect, which lowers the volume of the loudest parts of the signal in order to help prevent clipping and distortion that can occur when multiple sounds are played and multiplexed together at once. This is often used in musical production and game audio. DynamicsCompressorNode is an AudioNode that has exactly one input and one output.
DynamicsCompressorOptions
EffectTiming
Element: Element is the most general base class from which all element objects (i.e. objects that represent elements) in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from Element.
ElementCreationOptions
ElementDefinitionOptions
ElementInternals: The ElementInternals interface of the Document Object Model gives web developers a way to allow custom elements to fully participate in HTML forms. It provides utilities for working with these elements in the same way you would work with any standard HTML form element, and also exposes the Accessibility Object Model to the element.
EncodedVideoChunk: @AvailableInWorkers("window_and_dedicated")
EncodedVideoChunkInit
ErrorEvent: The ErrorEvent interface represents events providing information related to errors in scripts or in files.
ErrorEventInit
Event: The Event interface represents an event which takes place on an EventTarget.
EventCounts: The EventCounts interface of the Performance API provides the number of events that have been dispatched for each event type.
EventInit
EventListenerOptions
EventModifierInit
EventSource: The EventSource interface is web content's interface to server-sent events.
EventSourceInit
EventTarget: The EventTarget interface is implemented by objects that can receive events and may have listeners for them. In other words, any target of events implements the three methods associated with this interface.
EXT_blend_minmax
EXT_color_buffer_float
EXT_color_buffer_half_float
EXT_disjoint_timer_query
EXT_disjoint_timer_query_webgl2
EXT_float_blend
EXT_frag_depth
EXT_shader_texture_lod
EXT_sRGB
EXT_texture_compression_bptc
EXT_texture_compression_rgtc
EXT_texture_filter_anisotropic
EXT_texture_norm16
ExtendableCookieChangeEvent: @AvailableInWorkers("service")
ExtendableCookieChangeEventInit
ExtendableEvent: @AvailableInWorkers("service")
ExtendableEventInit
ExtendableMessageEvent: @AvailableInWorkers("service")
ExtendableMessageEventInit
External
ExternalDartReference: An opaque reference to a Dart object that can be passed to JavaScript.
FederatedCredentialInit: The FederatedCredentialInit dictionary represents the object passed to CredentialsContainer.create as the value of the federated option: that is, when creating a FederatedCredential object representing a credential associated with a federated identify provider.
FederatedCredentialRequestOptions
FetchEvent: @AvailableInWorkers("service")
FetchEventInit
File: The File interface provides information about files and allows JavaScript in a web page to access their content.
FileList: The FileList interface represents an object of this type returned by the files property of the HTML input element; this lets you access the list of files selected with the <input type="file"> element. It's also used for a list of files dropped into web content when using the drag and drop API; see the DataTransfer object for details on this usage.
FilePropertyBag
FileReader: The FileReader interface lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read.
FileReaderSync: @AvailableInWorkers("worker_except_service")
FileSystem: The File and Directory Entries API interface FileSystem is used to represent a file system. These objects can be obtained from the FileSystemEntry.filesystem property on any file system entry. Some browsers offer additional APIs to create and manage file systems, such as Chrome's Window.requestFileSystem method.
FileSystemCreateWritableOptions
FileSystemDirectoryEntry: The FileSystemDirectoryEntry interface of the File and Directory Entries API represents a directory in a file system. It provides methods which make it possible to access and manipulate the files in a directory, as well as to access the entries within the directory.
FileSystemDirectoryHandle: The FileSystemDirectoryHandle interface of the File System API provides a handle to a file system directory.
FileSystemDirectoryReader: The FileSystemDirectoryReader interface of the File and Directory Entries API lets you access the FileSystemFileEntry-based objects (generally FileSystemFileEntry or FileSystemDirectoryEntry) representing each entry in a directory.
FileSystemEntry: The FileSystemEntry interface of the File and Directory Entries API represents a single entry in a file system. The entry can be a file or a directory (directories are represented by the FileSystemDirectoryEntry interface). It includes methods for working with files—including copying, moving, removing, and reading files—as well as information about a file it points to—including the file name and its path from the root to the entry.
FileSystemFileEntry: The FileSystemFileEntry interface of the File and Directory Entries API represents a file in a file system. It offers properties describing the file's attributes, as well as the FileSystemFileEntry.file method, which creates a File object that can be used to read the file.
FileSystemFileHandle: The FileSystemFileHandle interface of the File System API represents a handle to a file system entry. The interface is accessed through the window.showOpenFilePicker method.
FileSystemFlags
FileSystemGetDirectoryOptions
FileSystemGetFileOptions
FileSystemHandle: The FileSystemHandle interface of the File System API is an object which represents a file or directory entry. Multiple handles can represent the same entry. For the most part you do not work with FileSystemHandle directly but rather its child interfaces FileSystemFileHandle and FileSystemDirectoryHandle.
FileSystemReadWriteOptions
FileSystemRemoveOptions
FileSystemSyncAccessHandle: @AvailableInWorkers("dedicated")
FileSystemWritableFileStream: The FileSystemWritableFileStream interface of the File System API is a WritableStream object with additional convenience methods, which operates on a single file on disk. The interface is accessed through the FileSystemFileHandle.createWritable method.
FocusEvent: The FocusEvent interface represents focus-related events, including Element.focus_event, Element.blur_event, Element.focusin_event, and Element.focusout_event.
FocusEventInit
FocusOptions
FontFace: The FontFace interface of the CSS Font Loading API represents a single usable font face.
FontFaceDescriptors
FontFaceSet: The FontFaceSet interface of the CSS Font Loading API manages the loading of font-faces and querying of their download status.
FontFaceSetLoadEvent: The FontFaceSetLoadEvent interface of the CSS Font Loading API represents events fired at a FontFaceSet after it starts loading font faces.
FontFaceSetLoadEventInit
FormData: The FormData interface provides a way to construct a set of key/value pairs representing form fields and their values, which can be sent using the fetch, XMLHttpRequest.send or navigator.sendBeacon methods. It uses the same format a form would use if the encoding type were set to "multipart/form-data".
FormDataEvent: The FormDataEvent interface represents a formdata event — such an event is fired on an HTMLFormElement object after the entry list representing the form's data is constructed. This happens when the form is submitted, but can also be triggered by the invocation of a FormData.FormData constructor.
FormDataEventInit
FullscreenOptions
GainNode: The GainNode interface represents a change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels.
GainOptions
Gamepad: The Gamepad interface of the Gamepad API defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id.
GamepadButton: The GamepadButton interface defines an individual button of a gamepad or other controller, allowing access to the current state of different types of buttons available on the control device.
GamepadEffectParameters
GamepadEvent: The GamepadEvent interface of the Gamepad API contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected_event and Window.gamepaddisconnected_event are fired in response to.
GamepadEventInit
GamepadHapticActuator: The GamepadHapticActuator interface of the Gamepad API represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware.
Geolocation: The Geolocation interface represents an object able to obtain the position of the device programmatically. It gives Web content access to the location of the device. This allows a website or app to offer customized results based on the user's location.
GeolocationCoordinates: The GeolocationCoordinates interface represents the position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated. The geographic position information is provided in terms of World Geodetic System coordinates (WGS84).
GeolocationPosition: The GeolocationPosition interface represents the position of the concerned device at a given time. The position, represented by a GeolocationCoordinates object, comprehends the 2D position of the device, on a spheroid representing the Earth, but also its altitude and its speed.
GeolocationPositionError: The GeolocationPositionError interface represents the reason of an error occurring when using the geolocating device.
GetAnimationsOptions
GetHTMLOptions
GetNotificationOptions
GetRootNodeOptions
Global
GlobalDescriptor
GravitySensor: The GravitySensor interface of the Sensor APIs provides on each reading the gravity applied to the device along all three axes.
Gyroscope: The Gyroscope interface of the Sensor APIs provides on each reading the angular velocity of the device along all three axes.
GyroscopeSensorOptions
HashChangeEvent: The HashChangeEvent interface represents events that fire when the fragment identifier of the URL has changed.
HashChangeEventInit
Headers: The Headers interface of the Fetch API allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing headers from the list of the request's headers.
HevcEncoderConfig
Highlight: The Highlight interface of the CSS Custom Highlight API is used to represent a collection of Range instances to be styled using the API.
HighlightRegistry: The HighlightRegistry interface of the CSS Custom Highlight API is used to register Highlight objects to be styled using the API. It is accessed via CSS.highlights_static.
History: The History interface of the History API allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in.
HMACGetSecretInput
HMACGetSecretOutput
HTMLAllCollection: The HTMLAllCollection interface represents a collection of all of the document's elements, accessible by index (like an array) and by the element's id. It is returned by the document.all property.
HTMLAnchorElement: The HTMLAnchorElement interface represents hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface that they inherit from) for manipulating the layout and presentation of such elements. This interface corresponds to <a> element; not to be confused with <link>, which is represented by HTMLLinkElement.
HTMLAreaElement: The HTMLAreaElement interface provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of area elements.
HTMLAudioElement: The HTMLAudioElement interface provides access to the properties of audio elements, as well as methods to manipulate them.
HTMLBaseElement: The HTMLBaseElement interface contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface.
HTMLBodyElement: The HTMLBodyElement interface provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating body elements.
HTMLBRElement: The HTMLBRElement interface represents an HTML line break element (br). It inherits from HTMLElement.
HTMLButtonElement: The HTMLButtonElement interface provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating button elements.
HTMLCanvasElement: The HTMLCanvasElement interface provides properties and methods for manipulating the layout and presentation of canvas elements. The HTMLCanvasElement interface also inherits the properties and methods of the HTMLElement interface.
HTMLCollection: The HTMLCollection interface represents a generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list.
HTMLDataElement: The HTMLDataElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating data elements.
HTMLDataListElement: The HTMLDataListElement interface provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate datalist elements and their content.
HTMLDetailsElement: The HTMLDetailsElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating details elements.
HTMLDialogElement: The HTMLDialogElement interface provides methods to manipulate dialog elements. It inherits properties and methods from the HTMLElement interface.
HTMLDirectoryElement
HTMLDivElement: The HTMLDivElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating div elements.
HTMLDListElement: The HTMLDListElement interface provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (dl) elements.
HTMLElement: The HTMLElement interface represents any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it.
HTMLEmbedElement: The HTMLEmbedElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating embed elements.
HTMLFieldSetElement: The HTMLFieldSetElement interface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of fieldset elements.
HTMLFontElement: Implements the document object model (DOM) representation of the font element. The HTML Font Element font defines the font size, font face and color of text.
HTMLFormControlsCollection: The HTMLFormControlsCollection interface represents a collection of HTML form control elements, returned by the HTMLFormElement interface's HTMLFormElement.elements property.
HTMLFormElement: The HTMLFormElement interface represents a form element in the DOM. It allows access to—and, in some cases, modification of—aspects of the form, as well as access to its component elements.
HTMLFrameElement
HTMLFrameSetElement: The HTMLFrameSetElement interface provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating frameset elements.
HTMLHeadElement: The HTMLHeadElement interface contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface.
HTMLHeadingElement: The HTMLHeadingElement interface represents the different heading elements, <h1> through <h6>. It inherits methods and properties from the HTMLElement interface.
HTMLHRElement: The HTMLHRElement interface provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating hr elements.
HTMLHtmlElement: The HTMLHtmlElement interface serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface.
HTMLIFrameElement: The HTMLIFrameElement interface provides special properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of inline frame elements.
HTMLImageElement: The HTMLImageElement interface represents an HTML img element, providing the properties and methods used to manipulate image elements.
HTMLInputElement: The HTMLInputElement interface provides special properties and methods for manipulating the options, layout, and presentation of input elements.
HTMLLabelElement: The HTMLLabelElement interface gives access to properties specific to label elements. It inherits methods and properties from the base HTMLElement interface.
HTMLLegendElement: The HTMLLegendElement is an interface allowing to access properties of the legend elements. It inherits properties and methods from the HTMLElement interface.
HTMLLIElement: The HTMLLIElement interface exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements.
HTMLLinkElement: The HTMLLinkElement interface represents reference information for external resources and the relationship of those resources to a document and vice versa (corresponds to <link> element; not to be confused with <a>, which is represented by HTMLAnchorElement). This object inherits all of the properties and methods of the HTMLElement interface.
HTMLMapElement: The HTMLMapElement interface provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of map elements.
HTMLMarqueeElement: The HTMLMarqueeElement interface provides methods to manipulate marquee elements.
HTMLMediaElement: The HTMLMediaElement interface adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video.
HTMLMenuElement: The HTMLMenuElement interface provides additional properties (beyond those inherited from the HTMLElement interface) for manipulating a menu element. <menu> is a semantic alternative to the ul element.
HTMLMetaElement: The HTMLMetaElement interface contains descriptive metadata about a document provided in HTML as <meta> elements. This interface inherits all of the properties and methods described in the HTMLElement interface.
HTMLMeterElement: The HTML meter 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 meter elements.
HTMLModElement: The HTMLModElement interface provides special properties (beyond the regular methods and properties available through the HTMLElement interface they also have available to them by inheritance) for manipulating modification elements, that is del and ins.
HTMLObjectElement: The HTMLObjectElement interface provides special properties and methods (beyond those on the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of object element, representing external resources.
HTMLOListElement: The HTMLOListElement interface provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements.
HTMLOptGroupElement: The HTMLOptGroupElement interface provides special properties and methods (beyond the regular HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of optgroup elements.
HTMLOptionElement: The HTMLOptionElement interface represents option elements and inherits all properties and methods of the HTMLElement interface.
HTMLOptionsCollection: The HTMLOptionsCollection interface represents a collection of <option> HTML elements (in document order) and offers methods and properties for selecting from the list as well as optionally altering its items. This object is returned only by the options property of select.
HTMLOutputElement: The HTMLOutputElement interface provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of output elements.
HTMLParagraphElement: The HTMLParagraphElement interface provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating p elements.
HTMLParamElement: The HTMLParamElement interface provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating param elements, representing a pair of a key and a value that acts as a parameter for an object element.
HTMLPictureElement: The HTMLPictureElement interface represents a picture HTML element. It doesn't implement specific properties or methods.
HTMLPreElement: The HTMLPreElement interface 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 (pre).
HTMLProgressElement: The HTMLProgressElement interface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of progress elements.
HTMLQuoteElement: The HTMLQuoteElement interface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like blockquote and q, but not the cite element.
HTMLScriptElement: HTML script elements expose the HTMLScriptElement interface, which provides special properties and methods for manipulating the behavior and execution of <script> elements (beyond the inherited HTMLElement interface).
HTMLSelectElement: The HTMLSelectElement interface represents a select HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface.
HTMLSlotElement: The HTMLSlotElement interface of the Shadow DOM API enables access to the name and assigned nodes of an HTML slot element.
HTMLSourceElement: The HTMLSourceElement interface provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating source elements.
HTMLSpanElement: The HTMLSpanElement interface represents a span element and derives from the HTMLElement interface, but without implementing any additional properties or methods.
HTMLStyleElement: The HTMLStyleElement interface represents a style element. It inherits properties and methods from its parent, HTMLElement.
HTMLTableCaptionElement: The HTMLTableCaptionElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements.
HTMLTableCellElement: The HTMLTableCellElement interface provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header cells (th) or data cells (td), in an HTML document.
HTMLTableColElement: The HTMLTableColElement interface provides properties for manipulating single or grouped table column elements.
HTMLTableElement: The HTMLTableElement interface provides special properties and methods (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document.
HTMLTableRowElement: The HTMLTableRowElement interface provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of rows in an HTML table.
HTMLTableSectionElement: The HTMLTableSectionElement interface provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies (thead, tfoot, and tbody, respectively) in an HTML table.
HTMLTemplateElement: The HTMLTemplateElement interface enables access to the contents of an HTML template element.
HTMLTextAreaElement: The HTMLTextAreaElement interface provides special properties and methods for manipulating the layout and presentation of textarea elements.
HTMLTimeElement: The HTMLTimeElement interface provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating time elements.
HTMLTitleElement: The HTMLTitleElement interface is implemented by a document's title. This element inherits all of the properties and methods of the HTMLElement interface.
HTMLTrackElement: The HTMLTrackElement interface represents an track element within the . This element can be used as a child of either audio or video to specify a text track containing information such as closed captions or subtitles.
HTMLUListElement: The HTMLUListElement interface provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list (ul) elements.
HTMLUnknownElement: The HTMLUnknownElement interface represents an invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods.
HTMLVideoElement: Implemented by the video element, the HTMLVideoElement interface provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement.
IDBCursor: Note: Not to be confused with IDBCursorWithValue which is just an IDBCursor interface with an additional value property.
IDBCursorWithValue: The IDBCursorWithValue interface of the IndexedDB API represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property.
IDBDatabase: The IDBDatabase interface of the IndexedDB API 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.
IDBDatabaseInfo
IDBFactory: The IDBFactory interface of the IndexedDB API lets applications asynchronously access the indexed databases. The object that implements the interface is window.indexedDB. You open — that is, create and access — and delete a database with this object, and not directly with IDBFactory.
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.
IDBIndexParameters
IDBKeyRange: The IDBKeyRange interface of the IndexedDB API represents a continuous interval over some data type that is used for keys. Records can be retrieved from IDBObjectStore and IDBIndex objects using keys or a range of keys. You can limit the range using lower and upper bounds. For example, you can iterate over all values of a key in the value range A–Z.
IDBObjectStore: The IDBObjectStore interface of the IndexedDB API represents an object store in a database. Records within an object store are sorted according to their keys. This sorting enables fast insertion, look-up, and ordered retrieval.
IDBObjectStoreParameters
IDBOpenDBRequest: The IDBOpenDBRequest interface of the IndexedDB API provides access to the results of requests to open or delete databases (performed using IDBFactory.open and IDBFactory.deleteDatabase), using specific event handler attributes.
IDBRequest: The IDBRequest interface of the IndexedDB API provides access to results of asynchronous requests to databases and database objects using event handler attributes. Each reading and writing operation on a database is done using a request.
IDBTransaction: The IDBTransaction interface of the IndexedDB API provides a static, asynchronous transaction on a database using event handler attributes. All reading and writing of data is done within transactions. You use IDBDatabase to start transactions, IDBTransaction to set the mode of the transaction (e.g. is it readonly or readwrite), and you access an IDBObjectStore to make a request. You can also use an IDBTransaction object to abort transactions.
IDBTransactionOptions
IDBVersionChangeEvent: The IDBVersionChangeEvent interface of the IndexedDB API indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.upgradeneeded_event event handler function.
IDBVersionChangeEventInit
IdentityCredentialRequestOptions
IdentityProviderConfig
IdentityProviderRequestOptions
IdentityRequestProvider
IdleDeadline: The IdleDeadline interface is used as the data type of the input parameter to idle callbacks established by calling Window.requestIdleCallback. It offers a method, IdleDeadline.timeRemaining, which lets you determine how much longer the user agent estimates it will remain idle and a property, IdleDeadline.didTimeout, which lets you determine if your callback is executing because its timeout duration expired.
IdleRequestOptions
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.
IIRFilterOptions
ImageBitmap: The ImageBitmap interface represents a bitmap image which can be drawn to a canvas without undue latency. It can be created from a variety of source objects using the createImageBitmap factory method. ImageBitmap provides an asynchronous and resource efficient pathway to prepare textures for rendering in WebGL.
ImageBitmapOptions
ImageBitmapRenderingContext: The ImageBitmapRenderingContext interface is a canvas rendering context that provides the functionality to replace the canvas's contents with the given ImageBitmap. Its context id (the first argument to HTMLCanvasElement.getContext or OffscreenCanvas.getContext) is "bitmaprenderer".
ImageData: The ImageData interface represents the underlying pixel data of an area of a canvas element.
ImageDataSettings
ImageEncodeOptions
InputDeviceInfo: The InputDeviceInfo interface of the Media Capture and Streams API gives access to the capabilities of the input device that it represents.
InputEvent: The InputEvent interface represents an event notifying the user of editable content changes.
InputEventInit
InstallEvent: Note: Instead of using the deprecated ServiceWorkerGlobalScope.oninstall handler to catch events of this type, handle the (non-deprecated) ServiceWorkerGlobalScope.install_event event using a listener added with EventTarget.addEventListener.
Instance
IntersectionObserver: The IntersectionObserver interface of the Intersection Observer API provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or with a top-level document's . The ancestor element or viewport is referred to as the root.
IntersectionObserverEntry: The IntersectionObserverEntry interface of the Intersection Observer API describes the intersection between the target element and its root container at a specific moment of transition.
IntersectionObserverInit
JSAny: A non-nullish JavaScript value.
JSArray: A JavaScript Array.
JSArrayBuffer: A JavaScript ArrayBuffer.
JSArrayUtil
JSBigInt: A JavaScript BigInt.
JSBoolean: A JavaScript boolean.
JSBoxedDartObject: A Dart object that is wrapped with a JavaScript object so that it can be passed to JavaScript safely.
JSDataView: A JavaScript DataView.
JSDate
JSExportedDartFunction: A JavaScript callable function created from a Dart function.
JSFloat32Array: A JavaScript Float32Array.
JSFloat64Array: A JavaScript Float64Array.
JSFunction: A JavaScript Function value.
JSInt16Array: A JavaScript Int16Array.
JSInt32Array: A JavaScript Int32Array.
JSInt8Array: A JavaScript Int8Array.
JSNumber: A JavaScript number.
JSObject: A JavaScript Object.
JSObjectUtil
JsonWebKey
JSPromise: A JavaScript Promise or a promise-like object.
JSString: A JavaScript string.
JSSymbol: A JavaScript Symbol.
JSTypedArray: Abstract supertype of all JavaScript typed arrays.
JSUint16Array: A JavaScript Uint16Array.
JSUint32Array: A JavaScript Uint32Array.
JSUint8Array: A JavaScript Uint8Array.
JSUint8ClampedArray: A JavaScript Uint8ClampedArray.
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. The event type (Element.keydown_event, Element.keypress_event, or Element.keyup_event) identifies what kind of keyboard activity occurred.
KeyboardEventInit
KeyframeAnimationOptions
KeyframeEffect: The KeyframeEffect interface of the Web Animations API lets us create sets of animatable properties and values, called keyframes. These can then be played using the Animation.Animation constructor.
KeyframeEffectOptions
KeySystemTrackConfiguration
KHR_parallel_shader_compile
LargestContentfulPaint: The LargestContentfulPaint interface provides timing information about the largest image or text paint before user input on a web page.
LinearAccelerationSensor: The LinearAccelerationSensor interface of the Sensor APIs provides on each reading the acceleration applied to the device along all three axes, but without the contribution of gravity.
Location: The Location interface represents the location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linked Location, accessible via Document.location and Window.location respectively.
Lock: The Lock interface of the Web Locks API provides the name and mode of a lock. This may be a newly requested lock that is received in the callback to LockManager.request, or a record of an active or queued lock returned by LockManager.query.
LockInfo
LockManager: The LockManager interface of the Web Locks API provides methods for requesting a new Lock object and querying for an existing Lock object. To get an instance of LockManager, call navigator.locks.
LockManagerSnapshot
LockOptions
MathMLElement: The MathMLElement interface represents any MathML element.
MediaCapabilities: The MediaCapabilities interface of the Media Capabilities API provides information about the decoding abilities of the device, system and browser. The API can be used to query the browser about the decoding abilities of the device based on codecs, profile, resolution, and bitrates. The information can be used to serve optimal media streams to the user and determine if playback should be smooth and power efficient.
MediaCapabilitiesDecodingInfo
MediaCapabilitiesEncodingInfo
MediaCapabilitiesInfo
MediaCapabilitiesKeySystemConfiguration
MediaConfiguration
MediaDecodingConfiguration
MediaDeviceInfo: The MediaDeviceInfo interface of the Media Capture and Streams API contains information that describes a single media input or output device.
MediaDevices: The MediaDevices interface of the Media Capture and Streams API provides access to connected media input devices like cameras and microphones, as well as screen sharing. In essence, it lets you obtain access to any hardware source of media data.
MediaElementAudioSourceNode: The MediaElementAudioSourceNode interface represents an audio source consisting of an HTML audio or video element. It is an AudioNode that acts as an audio source.
MediaElementAudioSourceOptions
MediaEncodingConfiguration
MediaEncryptedEvent: The MediaEncryptedEvent interface of the Encrypted Media Extensions API contains the information associated with an HTMLMediaElement.encrypted_event event sent to a HTMLMediaElement when some initialization data is encountered in the media.
MediaEncryptedEventInit
MediaError: The MediaError interface represents an error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as audio or video.
MediaImage
MediaKeyMessageEvent: The MediaKeyMessageEvent interface of the Encrypted Media Extensions API contains the content and related data when the content decryption module generates a message for the session.
MediaKeyMessageEventInit
MediaKeys: The MediaKeys interface of Encrypted Media Extensions API represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback.
MediaKeySession: The MediaKeySession interface of the Encrypted Media Extensions API represents a context for message exchange with a content decryption module (CDM).
MediaKeysPolicy
MediaKeyStatusMap: The MediaKeyStatusMap interface of the Encrypted Media Extensions API is a read-only map of media key statuses by key IDs.
MediaKeySystemAccess: The MediaKeySystemAccess interface of the Encrypted Media Extensions API provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the Navigator.requestMediaKeySystemAccess method.
MediaKeySystemConfiguration
MediaKeySystemMediaCapability
MediaList: The MediaList interface represents the media queries of a stylesheet, e.g. those set using a link element's media attribute.
MediaMetadata: The MediaMetadata interface of the Media Session API allows a web page to provide rich media metadata for display in a platform UI.
MediaMetadataInit
MediaPositionState
MediaQueryList: A MediaQueryList object stores information on a media query applied to a document, with support for both immediate and event-driven matching against the state of the document.
MediaQueryListEvent: The MediaQueryListEvent object stores information on the changes that have happened to a MediaQueryList object — instances are available as the event object on a function referenced by a MediaQueryList.change_event event.
MediaQueryListEventInit
MediaRecorder: The MediaRecorder interface of the MediaStream Recording API provides functionality to easily record media. It is created using the MediaRecorder.MediaRecorder constructor.
MediaRecorderOptions
MediaSession: The MediaSession interface of the Media Session API allows a web page to provide custom behaviors for standard media playback interactions, and to report metadata that can be sent by the user agent to the device or operating system for presentation in standardized user interface elements.
MediaSettingsRange
MediaSource: The MediaSource interface of the Media Source Extensions API 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.
MediaSourceHandle: The MediaSourceHandle interface of the Media Source Extensions API is a proxy for a MediaSource that can be transferred from a dedicated worker back to the main thread and attached to a media element via its HTMLMediaElement.srcObject property. MediaSource objects are not transferable because they are event targets, hence the need for MediaSourceHandles.
MediaStream: The MediaStream interface of the Media Capture and Streams API represents a stream of media content. A stream consists of several tracks, such as video or audio tracks. Each track is specified as an instance of MediaStreamTrack.
MediaStreamAudioDestinationNode: The MediaStreamAudioDestinationNode interface represents an audio destination consisting of a WebRTC MediaStream with a single AudioMediaStreamTrack, which can be used in a similar way to a MediaStream obtained from MediaDevices.getUserMedia.
MediaStreamAudioSourceNode: The MediaStreamAudioSourceNode interface is a type of AudioNode which operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs.
MediaStreamAudioSourceOptions
MediaStreamConstraints
MediaStreamTrack: The MediaStreamTrack interface of the Media Capture and Streams API represents a single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well.
MediaStreamTrackAudioSourceNode: The MediaStreamTrackAudioSourceNode interface is a type of AudioNode which represents a source of audio data taken from a specific MediaStreamTrack obtained through the WebRTC or Media Capture and Streams APIs.
MediaStreamTrackAudioSourceOptions
MediaStreamTrackEvent: The MediaStreamTrackEvent interface of the Media Capture and Streams API represents events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Capture and Streams API methods. These events are sent to the stream when these changes occur.
MediaStreamTrackEventInit
MediaStreamTrackProcessor: The MediaStreamTrackProcessor interface of the Insertable Streams for MediaStreamTrack API consumes a MediaStreamTrack object's source and generates a stream of media frames.
MediaStreamTrackProcessorInit
MediaTrackCapabilities
MediaTrackConstraints: The MediaTrackConstraints dictionary is used to describe a set of capabilities and the value or values each can take on. A constraints dictionary is passed into MediaStreamTrack.applyConstraints to allow a script to establish a set of exact (required) values or ranges and/or preferred values or ranges of values for the track, and the most recently-requested set of custom constraints can be retrieved by calling MediaStreamTrack.getConstraints.
MediaTrackConstraintSet
MediaTrackSettings: The MediaTrackSettings dictionary is used to return the current values configured for each of a MediaStreamTrack's settings. These values will adhere as closely as possible to any constraints previously described using a MediaTrackConstraints object and set using MediaStreamTrack.applyConstraints, and will adhere to the default constraints for any properties whose constraints haven't been changed, or whose customized constraints couldn't be matched.
MediaTrackSupportedConstraints: The MediaTrackSupportedConstraints dictionary establishes the list of constrainable properties recognized by the or browser in its implementation of the MediaStreamTrack object. An object conforming to MediaTrackSupportedConstraints is returned by MediaDevices.getSupportedConstraints.
Memory
MemoryDescriptor
MessageChannel: The MessageChannel interface of the Channel Messaging API allows us to create a new message channel and send data through it via its two MessagePort properties.
MessageEvent: The MessageEvent interface represents a message received by a target object.
MessageEventInit
MessagePort: The MessagePort interface of the Channel Messaging API represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other.
MIDIAccess: The MIDIAccess interface of the Web MIDI API provides methods for listing MIDI input and output devices, and obtaining access to those devices.
MIDIConnectionEvent: The MIDIConnectionEvent interface of the Web MIDI API is the event passed to the MIDIAccess.statechange_event event of the MIDIAccess interface and the MIDIPort.statechange_event event of the MIDIPort interface. This occurs any time a new port becomes available, or when a previously available port becomes unavailable. For example, this event is fired whenever a MIDI device is either plugged in to or unplugged from a computer.
MIDIConnectionEventInit
MIDIInput: The MIDIInput interface of the Web MIDI API receives messages from a MIDI input port.
MIDIInputMap: The MIDIInputMap read-only interface of the Web MIDI API provides the set of MIDI input ports that are currently available.
MIDIMessageEvent: The MIDIMessageEvent interface of the Web MIDI API represents the event passed to the MIDIInput.midimessage_event event of the MIDIInput interface. A midimessage event is fired every time a MIDI message is sent from a device represented by a MIDIInput, for example when a MIDI keyboard key is pressed, a knob is tweaked, or a slider is moved.
MIDIMessageEventInit
MIDIOptions
MIDIOutput: The MIDIOutput interface of the Web MIDI API provides methods to add messages to the queue of an output device, and to clear the queue of messages.
MIDIOutputMap: The MIDIOutputMap read-only interface of the Web MIDI API provides the set of MIDI output ports that are currently available.
MIDIPort: The MIDIPort interface of the Web MIDI API represents a MIDI input or output port.
MimeType: The MimeType interface provides contains information about a MIME type associated with a particular plugin. Navigator.mimeTypes returns an array of this object.
MimeTypeArray: The MimeTypeArray interface returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by the deprecated Navigator.mimeTypes property.
Module
ModuleExportDescriptor
ModuleImportDescriptor
MouseEvent: The MouseEvent interface represents events that occur due to the user interacting with a pointing device (such as a mouse). Common events using this interface include Element.click_event, Element.dblclick_event, Element.mouseup_event, Element.mousedown_event.
MouseEventInit
MultiCacheQueryOptions
MutationEvent: The MutationEvent interface provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes.
MutationObserver: The MutationObserver interface 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.
MutationObserverInit
MutationRecord: The MutationRecord is a read-only interface that represents an individual DOM mutation observed by a MutationObserver. It is the object inside the array passed to the callback of a MutationObserver.
NamedNodeMap: The NamedNodeMap interface represents 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.
NavigationPreloadManager: The NavigationPreloadManager interface of the Service Worker API provides methods for managing the preloading of resources in parallel with service worker bootup.
NavigationPreloadState
Navigator: The Navigator interface represents the state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities.
NetworkInformation: The NetworkInformation interface of the Network Information API provides information about the connection a device is using to communicate with the network and provides a means for scripts to be notified if the connection type changes. The NetworkInformation interface cannot be instantiated. It is instead accessed through the connection property of the Navigator interface or the WorkerNavigator interface.
Node: The Node interface is an abstract base class upon which many other DOM API objects are based, thus letting those object types to be used similarly and often interchangeably. As an abstract class, there is no such thing as a plain Node object. All objects that implement Node functionality are based on one of its subclasses. Most notable are Document, Element, and DocumentFragment.
NodeIterator: The NodeIterator interface represents an iterator to traverse nodes of a DOM subtree in document order.
NodeList: NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll.
Notification: The Notification interface of the Notifications API is used to configure and display desktop notifications to the user.
NotificationAction
NotificationEvent: @AvailableInWorkers("service")
NotificationEventInit
NotificationOptions
OES_draw_buffers_indexed: The OES_draw_buffers_indexed extension is part of the WebGL API and enables the use of different blend options when writing to multiple color buffers simultaneously.
OES_element_index_uint
OES_fbo_render_mipmap
OES_standard_derivatives
OES_texture_float
OES_texture_float_linear
OES_texture_half_float
OES_texture_half_float_linear
OES_vertex_array_object
OfflineAudioCompletionEvent: The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The OfflineAudioContext.complete_event event uses this interface.
OfflineAudioCompletionEventInit
OfflineAudioContext: The OfflineAudioContext interface is 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.
OfflineAudioContextOptions
OffscreenCanvas: When using the canvas element or the Canvas API, rendering, animation, and user interaction usually happen on the main execution thread of a web application. The computation relating to canvas animations and rendering can have a significant impact on application performance.
OffscreenCanvasRenderingContext2D: The OffscreenCanvasRenderingContext2D interface is a CanvasRenderingContext2D rendering context for drawing to the bitmap of an OffscreenCanvas object. It is similar to the CanvasRenderingContext2D object, with the following differences:
OptionalEffectTiming
OrientationSensor: The OrientationSensor interface of the Sensor APIs is the base class for orientation sensors. This interface cannot be used directly. Instead it provides properties and methods accessed by interfaces that inherit from it.
OrientationSensorOptions
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.
OscillatorOptions
OTPCredentialRequestOptions
OverconstrainedError: The OverconstrainedError interface of the Media Capture and Streams API indicates that the set of desired capabilities for the current MediaStreamTrack cannot currently be met. When this event is thrown on a MediaStreamTrack, it is muted until either the current constraints can be established or until satisfiable constraints are applied.
OVR_multiview2
PageTransitionEvent: The PageTransitionEvent event object is available inside handler functions for the pageshow and pagehide events, fired when a document is being loaded or unloaded.
PageTransitionEventInit
PaintRenderingContext2D
PaintSize
PannerNode: The PannerNode interface defines an audio-processing object that represents the location, direction, and behavior of an audio source signal in a simulated physical space. This AudioNode uses right-hand Cartesian coordinates to describe the source's position as a vector and its orientation as a 3D directional cone.
PannerOptions
PasswordCredentialData
Path2D: The Path2D interface of the Canvas 2D API 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.
PaymentCompleteDetails
PaymentCredentialInstrument
PaymentCurrencyAmount
PaymentDetailsBase
PaymentDetailsInit
PaymentDetailsModifier
PaymentDetailsUpdate
PaymentItem
PaymentMethodChangeEvent: The PaymentMethodChangeEvent interface of the Payment Request API describes the PaymentRequest.paymentmethodchange_event event which is fired by some payment handlers when the user switches payment instruments (e.g., a user selects a "store" card to make a purchase while using Apple Pay).
PaymentMethodChangeEventInit
PaymentMethodData
PaymentRequest: The Payment Request API's PaymentRequest interface is the primary access point into the API, and lets web content and apps accept payments from the end user on behalf of the operator of the site or the publisher of the app.
PaymentRequestUpdateEvent: The PaymentRequestUpdateEvent interface is used for events sent to a PaymentRequest instance when changes are made to shipping-related information for a pending PaymentRequest. Those events are:
PaymentRequestUpdateEventInit
PaymentResponse: The PaymentResponse interface of the Payment Request API is returned after a user selects a payment method and approves a payment request.
PaymentValidationErrors
Performance: The Performance interface provides access to performance-related information for the current page.
PerformanceEntry: The PerformanceEntry object encapsulates a single performance metric that is part of the browser's performance timeline.
PerformanceEventTiming: The PerformanceEventTiming interface of the Event Timing API provides insights into the latency of certain event types triggered by user interaction.
PerformanceMark: PerformanceMark is an interface for PerformanceEntry objects with an PerformanceEntry.entryType of "mark".
PerformanceMarkOptions
PerformanceMeasure: PerformanceMeasure is an abstract interface for PerformanceEntry objects with an PerformanceEntry.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.
PerformanceMeasureOptions
PerformanceNavigation: The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done.
PerformanceNavigationTiming: The PerformanceNavigationTiming interface provides methods and properties to store and retrieve metrics regarding the browser's document navigation events. For example, this interface can be used to determine how much time it takes to load or unload a document.
PerformanceObserver: The PerformanceObserver interface is used to observe performance measurement events and be notified of new PerformanceEntry as they are recorded in the browser's performance timeline.
PerformanceObserverEntryList: The PerformanceObserverEntryList interface is a list of PerformanceEntry that were explicitly observed via the PerformanceObserver.observe method.
PerformanceObserverInit
PerformancePaintTiming: The PerformancePaintTiming interface provides timing information about "paint" (also called "render") operations during web page construction. "Paint" refers to conversion of the render tree to on-screen pixels.
PerformanceResourceTiming: The PerformanceResourceTiming interface 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.
PerformanceServerTiming: The PerformanceServerTiming interface surfaces server metrics that are sent with the response in the HTTP header.
PerformanceTiming: Warning: This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
PeriodicWave: The PeriodicWave interface defines a periodic waveform that can be used to shape the output of an OscillatorNode.
PeriodicWaveConstraints
PeriodicWaveOptions
Permissions: The Permissions interface of the Permissions API provides the core Permission API functionality, such as methods for querying and revoking permissions
PermissionStatus: The PermissionStatus interface of the Permissions API provides the state of an object and an event handler for monitoring changes to said state.
PictureInPictureEvent: The PictureInPictureEvent interface represents picture-in-picture-related events, including HTMLVideoElement.enterpictureinpicture_event, HTMLVideoElement.leavepictureinpicture_event and PictureInPictureWindow.resize_event
PictureInPictureEventInit
PictureInPictureWindow: The PictureInPictureWindow interface represents an object able to programmatically obtain the width and height and resize event of the floating video window.
PlaneLayout
Plugin: The Plugin interface provides information about a browser plugin.
PluginArray: The PluginArray interface is used to store a list of Plugin objects describing the available plugins; it's returned by the 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.
Point2D
PointerEvent: The PointerEvent interface represents the state of a DOM event produced by a pointer such as the geometry of the contact point, the device type that generated the event, the amount of pressure that was applied on the contact surface, etc.
PointerEventInit
PointerLockOptions
PopStateEvent: PopStateEvent is an interface for the popstate event.
PopStateEventInit
PositionOptions
PrivateToken
ProcessingInstruction: The ProcessingInstruction interface represents a processing instruction; that is, a Node which embeds an instruction targeting a specific application but that can be ignored by any other applications which don't recognize the instruction.
ProgressEvent: The ProgressEvent interface represents events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an img, audio, video, style or link).
ProgressEventInit
PromiseRejectionEvent: The PromiseRejectionEvent interface represents events which are sent to the global script context when JavaScript Promises are rejected. These events are particularly useful for telemetry and debugging purposes.
PromiseRejectionEventInit
PropertyDefinition
PublicKeyCredential: The PublicKeyCredential interface provides information about a public key / private key pair, which is a credential for logging in to a service using an un-phishable and data-breach resistant asymmetric key pair instead of a password. It inherits from Credential, and is part of the Web Authentication API extension to the Credential Management API.
PublicKeyCredentialCreationOptions: The PublicKeyCredentialCreationOptions dictionary represents the object passed to CredentialsContainer.create as the value of the publicKey option: that is, when using create() to create a public key credential using the Web Authentication API.
PublicKeyCredentialDescriptor
PublicKeyCredentialEntity
PublicKeyCredentialParameters
PublicKeyCredentialRequestOptions
PublicKeyCredentialRpEntity
PublicKeyCredentialUserEntity
PushEvent: @AvailableInWorkers("service")
PushEventInit
PushManager: The PushManager interface of the Push API provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
PushMessageData: @AvailableInWorkers("service")
PushSubscription: The PushSubscription interface of the Push API provides a subscription's URL endpoint and allows unsubscribing from a push service.
PushSubscriptionChangeEvent
PushSubscriptionJSON
PushSubscriptionOptions: The PushSubscriptionOptions interface of the Push API represents the options associated with a push subscription.
PushSubscriptionOptionsInit
QueuingStrategy
QueuingStrategyInit
RadioNodeList: The RadioNodeList interface represents a collection of elements in a form returned by a call to HTMLFormControlsCollection.namedItem.
Range: The Range interface represents a fragment of a document that can contain nodes and parts of text nodes.
ReadableByteStreamController: The ReadableByteStreamController interface of the Streams API represents a controller for a readable byte stream. It allows control of the state and internal queue of a ReadableStream with an underlying byte source, and enables efficient zero-copy transfer of data from the underlying source to a consumer when the stream's internal queue is empty.
ReadableStream: The ReadableStream interface of the Streams API represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the Response.body property of a Response object.
ReadableStreamBYOBReader: The ReadableStreamBYOBReader interface of the Streams API defines a reader for a ReadableStream that supports zero-copy reading from an underlying byte source. It is used for efficient copying from underlying sources where the data is delivered as an "anonymous" sequence of bytes, such as files.
ReadableStreamBYOBReaderReadOptions
ReadableStreamBYOBRequest: The ReadableStreamBYOBRequest interface of the Streams API represents a "pull request" for data from an underlying source that will made as a zero-copy transfer to a consumer (bypassing the stream's internal queues).
ReadableStreamDefaultController: The ReadableStreamDefaultController interface of the Streams API represents a controller allowing control of a ReadableStream's state and internal queue. Default controllers are for streams that are not byte streams.
ReadableStreamDefaultReader: The ReadableStreamDefaultReader interface of the Streams API represents a default reader that can be used to read stream data supplied from a network (such as a fetch request).
ReadableStreamGetReaderOptions
ReadableStreamReadResult
ReadableWritablePair
RegistrationOptions
RelativeOrientationSensor: The RelativeOrientationSensor interface of the Sensor APIs describes the device's physical orientation without regard to the Earth's reference coordinate system.
RemotePlayback: The RemotePlayback interface of the Remote Playback API allows the page to detect availability of remote playback devices, then connect to and control playing on these devices.
Report: The Report interface of the Reporting API represents a single report.
ReportBody: The ReportBody interface of the Reporting API represents the body of a report. Individual report types inherit from this interface, adding specific attributes relevant to the particular report.
ReportingObserver: The ReportingObserver interface of the Reporting API allows you to collect and access reports.
ReportingObserverOptions
Request: The Request interface of the Fetch API represents a resource request.
RequestInit
ResizeObserver: The ResizeObserver interface reports changes to the dimensions of an Element's content or border box, or the bounding box of an SVGElement.
ResizeObserverEntry: The ResizeObserverEntry interface represents the object passed to the ResizeObserver.ResizeObserver constructor's callback function, which allows you to access the new dimensions of the Element or SVGElement being observed.
ResizeObserverOptions
ResizeObserverSize: The ResizeObserverSize interface of the Resize Observer API is used by the ResizeObserverEntry interface to access the box sizing properties of the element being observed.
Response: The Response interface of the Fetch API represents the response to a request.
ResponseInit
RsaOtherPrimesInfo
RTCAnswerOptions
RTCCertificate: The RTCCertificate interface of the WebRTC API provides an object representing a certificate that an RTCPeerConnection uses to authenticate.
RTCConfiguration
RTCDataChannel: The RTCDataChannel interface represents a network channel which can be used for bidirectional peer-to-peer transfers of arbitrary data. Every data channel is associated with an RTCPeerConnection, and each peer connection can have up to a theoretical maximum of 65,534 data channels (the actual limit may vary from browser to browser).
RTCDataChannelEvent: The RTCDataChannelEvent interface represents an event related to a specific RTCDataChannel.
RTCDataChannelEventInit
RTCDataChannelInit
RTCDtlsFingerprint
RTCDtlsTransport: The RTCDtlsTransport interface provides access to information about the Datagram Transport Layer Security (****) transport over which a RTCPeerConnection's and packets are sent and received by its RTCRtpSender and RTCRtpReceiver objects.
RTCDTMFSender: The RTCDTMFSender interface provides a mechanism for transmitting codes on a WebRTC RTCPeerConnection. You gain access to the connection's RTCDTMFSender through the RTCRtpSender.dtmf property on the audio track you wish to send DTMF with.
RTCDTMFToneChangeEvent: The RTCDTMFToneChangeEvent interface represents events sent to indicate that tones have started or finished playing. This interface is used by the tonechange event.
RTCDTMFToneChangeEventInit
RTCEncodedAudioFrame: @AvailableInWorkers("window_and_dedicated")
RTCEncodedAudioFrameMetadata
RTCEncodedVideoFrame: @AvailableInWorkers("window_and_dedicated")
RTCEncodedVideoFrameMetadata
RTCError: The RTCError interface describes an error which has occurred while handling WebRTC operations. It's based upon the standard DOMException interface that describes general DOM errors.
RTCErrorEvent: The WebRTC API's RTCErrorEvent interface represents an error sent to a WebRTC object. It's based on the standard Event interface, but adds RTC-specific information describing the error, as shown below.
RTCErrorEventInit
RTCErrorInit
RTCIceCandidate: The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Interactive Connectivity Establishment () configuration which may be used to establish an RTCPeerConnection.
RTCIceCandidateInit
RTCIceParameters: The RTCIceParameters dictionary specifies the username fragment and password assigned to an session.
RTCIceServer
RTCIceTransport: The RTCIceTransport interface provides access to information about the transport layer over which the data is being sent and received. This is particularly useful if you need to access state information about the connection.
RTCIdentityProviderOptions
RTCLocalSessionDescriptionInit
RTCOfferAnswerOptions
RTCOfferOptions
RTCPeerConnection: The RTCPeerConnection interface represents a WebRTC connection between the local computer and a remote peer. It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed.
RTCPeerConnectionIceErrorEvent: The RTCPeerConnectionIceErrorEvent interface—based upon the Event interface—provides details pertaining to an error announced by sending an RTCPeerConnection.icecandidateerror_event event to the RTCPeerConnection object.
RTCPeerConnectionIceErrorEventInit
RTCPeerConnectionIceEvent: The RTCPeerConnectionIceEvent interface represents events that occur in relation to candidates with the target, usually an RTCPeerConnection.
RTCPeerConnectionIceEventInit
RTCRtcpParameters
RTCRtpCapabilities
RTCRtpCodec
RTCRtpCodecParameters
RTCRtpCodingParameters
RTCRtpContributingSource
RTCRtpEncodingParameters
RTCRtpHeaderExtensionCapability
RTCRtpHeaderExtensionParameters
RTCRtpParameters
RTCRtpReceiveParameters
RTCRtpReceiver: The RTCRtpReceiver interface of the WebRTC API manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection.
RTCRtpScriptTransform: The RTCRtpScriptTransform interface of the WebRTC API is used to insert a WebRTC Encoded Transform (a TransformStream running in a worker thread) into the WebRTC sender and receiver pipelines.
RTCRtpScriptTransformer: The RTCRtpScriptTransformer interface of the WebRTC API provides a worker-side Stream API interface that a WebRTC Encoded Transform can use to modify encoded media frames in the incoming and outgoing WebRTC pipelines.
RTCRtpSender: The RTCRtpSender interface provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer.
RTCRtpSendParameters
RTCRtpSynchronizationSource
RTCRtpTransceiver: The WebRTC interface RTCRtpTransceiver describes a permanent pairing of an RTCRtpSender and an RTCRtpReceiver, along with some shared state.
RTCRtpTransceiverInit
RTCSctpTransport: The RTCSctpTransport interface provides information which describes a Stream Control Transmission Protocol () transport. This provides information about limitations of the transport, but also provides a way to access the underlying Datagram Transport Layer Security () transport over which SCTP packets for all of an RTCPeerConnection's data channels are sent and received.
RTCSessionDescription: The RTCSessionDescription interface describes one end of a connection—or potential connection—and how it's configured. Each RTCSessionDescription consists of a description RTCSessionDescription.type indicating which part of the offer/answer negotiation process it describes and of the descriptor of the session.
RTCSessionDescriptionInit
RTCSetParameterOptions
RTCStatsReport: The RTCStatsReport interface of the WebRTC API provides a statistics report for a RTCPeerConnection, RTCRtpSender, or RTCRtpReceiver.
RTCTrackEvent: The WebRTC API interface RTCTrackEvent represents the RTCPeerConnection.track_event event, which is sent when a new MediaStreamTrack is added to an RTCRtpReceiver which is part of the RTCPeerConnection.
RTCTrackEventInit
RTCTransformEvent: The RTCTransformEvent of the WebRTC API represent an event that is fired in a dedicated worker when an encoded frame has been queued for processing by a WebRTC Encoded Transform.
Sanitizer: The Sanitizer interface of the HTML Sanitizer API is used to sanitize untrusted strings of HTML, Document and DocumentFragment objects. After sanitization, unwanted elements or attributes are removed, and the returned objects can safely be inserted into a document's DOM.
SanitizerAttributeNamespace
SanitizerConfig
SanitizerElementNamespace
SanitizerElementNamespaceWithAttributes
Scheduler: The Scheduler interface of the Prioritized Task Scheduling API provides the Scheduler.postTask method that can be used for adding prioritized tasks to be scheduled.
SchedulerPostTaskOptions
Screen: The Screen interface represents a screen, usually the one on which the current window is being rendered, and is obtained using window.screen.
ScreenOrientation: The ScreenOrientation interface of the Screen Orientation API provides information about the current orientation of the document.
ScriptProcessorNode: The ScriptProcessorNode interface allows the generation, processing, or analyzing of audio using JavaScript.
ScrollIntoViewOptions
ScrollOptions
ScrollToOptions
SecurityPolicyViolationEvent: The SecurityPolicyViolationEvent interface inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated.
SecurityPolicyViolationEventInit
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 manipulation, call window.getSelection.
Sensor: The Sensor interface of the Sensor APIs is the base class for all the other sensor interfaces. This interface cannot be used directly. Instead it provides properties, event handlers, and methods accessed by interfaces that inherit from it.
SensorErrorEvent: The SensorErrorEvent interface of the Sensor APIs provides information about errors thrown by a Sensor or derived interface.
SensorErrorEventInit
SensorOptions
ServiceWorker: The ServiceWorker interface of the Service Worker API provides a reference to a service worker. Multiple (e.g. pages, workers, etc.) can be associated with the same service worker, each through a unique ServiceWorker object.
ServiceWorkerContainer: The ServiceWorkerContainer interface of the Service Worker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.
ServiceWorkerGlobalScope: @AvailableInWorkers("service")
ServiceWorkerRegistration: The ServiceWorkerRegistration interface of the Service Worker API represents the service worker registration. You register a service worker to control one or more pages that share the same origin.
ShadowRoot: The ShadowRoot interface of the Shadow DOM API is the root node of a DOM subtree that is rendered separately from a document's main DOM tree.
ShadowRootInit
ShareData
SharedWorker: The SharedWorker interface represents a specific kind of worker that can be accessed from several browsing contexts, such as several windows, iframes or even workers. They implement an interface different than dedicated workers and have a different global scope, SharedWorkerGlobalScope.
SharedWorkerGlobalScope: The SharedWorkerGlobalScope object (the SharedWorker global scope) is accessible through the window.self keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the JavaScript Reference. See the complete list of functions available to workers.
SharedWorkerOptions
SourceBuffer: The SourceBuffer interface represents a chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object. This can be made up of one or several media segments.
SourceBufferList: The SourceBufferList interface represents a simple container list for multiple SourceBuffer objects.
SpeechRecognition: The SpeechRecognition interface of the Web Speech API is the controller interface for the recognition service; this also handles the SpeechRecognitionEvent sent from the recognition service.
SpeechRecognitionAlternative: The SpeechRecognitionAlternative interface of the Web Speech API represents a single word that has been recognized by the speech recognition service.
SpeechRecognitionErrorEvent: The SpeechRecognitionErrorEvent interface of the Web Speech API represents error messages from the recognition service.
SpeechRecognitionEvent: The SpeechRecognitionEvent interface of the Web Speech API represents the event object for the SpeechRecognition.result_event and SpeechRecognition.nomatch_event events, and contains all the data associated with an interim or final speech recognition result.
SpeechRecognitionResult: The SpeechRecognitionResult interface of the Web Speech API represents a single recognition match, which may contain multiple SpeechRecognitionAlternative objects.
SpeechRecognitionResultList: The SpeechRecognitionResultList interface of the Web Speech API represents a list of SpeechRecognitionResult objects, or a single one if results are being captured in mode.
SpeechSynthesis: The SpeechSynthesis interface of the Web Speech API is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides.
SpeechSynthesisErrorEvent: The SpeechSynthesisErrorEvent interface of the Web Speech API contains information about any errors that occur while processing SpeechSynthesisUtterance objects in the speech service.
SpeechSynthesisErrorEventInit
SpeechSynthesisEvent: The SpeechSynthesisEvent interface of the Web Speech API contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service.
SpeechSynthesisEventInit
SpeechSynthesisUtterance: The SpeechSynthesisUtterance interface of the Web Speech API represents a speech request. It contains the content the speech service should read and information about how to read it (e.g. language, pitch and volume.)
SpeechSynthesisVoice: The SpeechSynthesisVoice interface of the Web Speech API represents a voice that the system supports. Every SpeechSynthesisVoice has its own relative speech service including information about language, name and URI.
StartViewTransitionOptions
StaticRange: The DOM StaticRange interface extends AbstractRange to provide a method to specify a range of content in the DOM whose contents don't update to reflect changes which occur within the DOM tree.
StaticRangeInit
StereoPannerNode: The StereoPannerNode interface of the Web Audio API represents a simple stereo panner node that can be used to pan an audio stream left or right. It is an AudioNode audio-processing module that positions an incoming audio stream in a stereo image using a low-cost equal-power panning algorithm.
StereoPannerOptions
Storage: The Storage interface of the Web Storage API provides access to a particular domain's session or local storage. It allows, for example, the addition, modification, or deletion of stored data items.
StorageAccessHandle: The StorageAccessHandle interface represents access to unpartitioned state granted by a call to Document.requestStorageAccess.
StorageEstimate
StorageEvent: The StorageEvent interface is implemented by the Window.storage_event event, which is sent to a window when a storage area the window has access to is changed within the context of another document.
StorageEventInit
StorageManager: The StorageManager interface of the Storage API provides an interface for managing persistence permissions and estimating available storage. You can get a reference to this interface using either navigator.storage or WorkerNavigator.storage.
StreamPipeOptions
StructuredSerializeOptions
StylePropertyMap: The StylePropertyMap interface of the CSS Typed Object Model API provides a representation of a CSS declaration block that is an alternative to CSSStyleDeclaration.
StylePropertyMapReadOnly: The StylePropertyMapReadOnly interface of the CSS Typed Object Model API provides a read-only representation of a CSS declaration block that is an alternative to CSSStyleDeclaration. Retrieve an instance of this interface using Element.computedStyleMap.
StyleSheet: An object implementing the StyleSheet interface represents a single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface.
StyleSheetList: The StyleSheetList interface represents a list of CSSStyleSheet objects. An instance of this object can be returned by Document.styleSheets.
SubmitEvent: The SubmitEvent interface defines the object used to represent an form's HTMLFormElement.submit_event event. This event is fired at the form when the form's submit action is invoked.
SubmitEventInit
SubtleCrypto: The SubtleCrypto interface of the Web Crypto API provides a number of low-level cryptographic functions.
SVGAElement: The SVGAElement interface provides access to the properties of an element, as well as methods to manipulate them.
SVGAngle: The SVGAngle interface is used to represent a value that can be an or value. An SVGAngle reflected through the animVal attribute is always read only.
SVGAnimatedAngle
SVGAnimatedBoolean
SVGAnimatedEnumeration: The SVGAnimatedEnumeration interface describes attribute values which are constants from a particular enumeration and which can be animated.
SVGAnimatedInteger
SVGAnimatedLength: The SVGAnimatedLength interface represents attributes of type <length> which can be animated.
SVGAnimatedLengthList
SVGAnimatedNumber
SVGAnimatedNumberList
SVGAnimatedPreserveAspectRatio
SVGAnimatedRect: The SVGAnimatedRect interface is used for attributes of basic SVGRect which can be animated.
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.
SVGAnimatedTransformList
SVGAnimateElement: The SVGAnimateElement interface corresponds to the element.
SVGAnimateMotionElement: The SVGAnimateMotionElement interface corresponds to the element.
SVGAnimateTransformElement: The SVGAnimateTransformElement interface corresponds to the element.
SVGAnimationElement: The SVGAnimationElement interface is the base interface for all of the animation element interfaces: SVGAnimateElement, SVGSetElement, SVGAnimateColorElement, SVGAnimateMotionElement and SVGAnimateTransformElement.
SVGBoundingBoxOptions
SVGCircleElement: The SVGCircleElement interface is an interface for the element.
SVGClipPathElement: The SVGClipPathElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGComponentTransferFunctionElement: The SVGComponentTransferFunctionElement interface defines a base interface used by the component transfer function interfaces.
SVGDefsElement: The SVGDefsElement interface corresponds to the element.
SVGDescElement: The SVGDescElement interface corresponds to the element.
SVGElement: All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface.
SVGEllipseElement: The SVGEllipseElement interface provides access to the properties of elements.
SVGFEBlendElement: The SVGFEBlendElement interface corresponds to the element.
SVGFEColorMatrixElement: The SVGFEColorMatrixElement interface corresponds to the element.
SVGFEComponentTransferElement: The SVGFEComponentTransferElement interface corresponds to the element.
SVGFECompositeElement: The SVGFECompositeElement interface corresponds to the element.
SVGFEConvolveMatrixElement: The SVGFEConvolveMatrixElement interface corresponds to the element.
SVGFEDiffuseLightingElement: The SVGFEDiffuseLightingElement interface corresponds to the element.
SVGFEDisplacementMapElement: The SVGFEDisplacementMapElement interface corresponds to the element.
SVGFEDistantLightElement: The SVGFEDistantLightElement interface corresponds to the element.
SVGFEDropShadowElement: The SVGFEDropShadowElement interface corresponds to the element.
SVGFEFloodElement: The SVGFEFloodElement interface corresponds to the element.
SVGFEFuncAElement: The SVGFEFuncAElement interface corresponds to the element.
SVGFEFuncBElement: The SVGFEFuncBElement interface corresponds to the element.
SVGFEFuncGElement: The SVGFEFuncGElement interface corresponds to the element.
SVGFEFuncRElement: The SVGFEFuncRElement interface corresponds to the element.
SVGFEGaussianBlurElement: The SVGFEGaussianBlurElement interface corresponds to the element.
SVGFEImageElement: The SVGFEImageElement interface corresponds to the element.
SVGFEMergeElement: The SVGFEMergeElement interface corresponds to the element.
SVGFEMergeNodeElement: The SVGFEMergeNodeElement interface corresponds to the element.
SVGFEMorphologyElement: The SVGFEMorphologyElement interface corresponds to the element.
SVGFEOffsetElement: The SVGFEOffsetElement interface corresponds to the element.
SVGFEPointLightElement: The SVGFEPointLightElement interface corresponds to the element.
SVGFESpecularLightingElement: The SVGFESpecularLightingElement interface corresponds to the element.
SVGFESpotLightElement: The SVGFESpotLightElement interface corresponds to the element.
SVGFETileElement: The SVGFETileElement interface corresponds to the element.
SVGFETurbulenceElement: The SVGFETurbulenceElement interface corresponds to the element.
SVGFilterElement: The SVGFilterElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGForeignObjectElement: The SVGForeignObjectElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGGElement: The SVGGElement interface corresponds to the element.
SVGGeometryElement: The SVGGeometryElement interface represents SVG elements whose rendering is defined by geometry with an equivalent path, and which can be filled and stroked. This includes paths and the basic shapes.
SVGGradientElement: The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement.
SVGGraphicsElement: The SVGGraphicsElement interface represents SVG elements whose primary purpose is to directly render graphics into a group.
SVGImageElement: The SVGImageElement interface corresponds to the element.
SVGLength
SVGLengthList
SVGLinearGradientElement: The SVGLinearGradientElement interface corresponds to the element.
SVGLineElement: The SVGLineElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGMarkerElement: The SVGMarkerElement interface provides access to the properties of elements, as well as methods to manipulate them. The element defines the graphics used for drawing marks on a shape.
SVGMaskElement: The SVGMaskElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGMetadataElement: The SVGMetadataElement interface corresponds to the element.
SVGMPathElement: The SVGMPathElement interface corresponds to the element.
SVGNumber: The SVGNumber interface corresponds to the basic data type.
SVGNumberList
SVGPathElement: The SVGPathElement interface corresponds to the element.
SVGPatternElement: The SVGPatternElement interface corresponds to the element.
SVGPointList: The SVGPointList interface represents a list of SVGPoint objects.
SVGPolygonElement: The SVGPolygonElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGPolylineElement: The SVGPolylineElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGPreserveAspectRatio
SVGRadialGradientElement: The SVGRadialGradientElement interface corresponds to the element.
SVGRectElement: The SVGRectElement interface provides access to the properties of elements, as well as methods to manipulate them.
SVGScriptElement: The SVGScriptElement interface corresponds to the SVG element.
SVGSetElement: The SVGSetElement interface corresponds to the element.
SVGStopElement: The SVGStopElement interface corresponds to the element.
SVGStringList
SVGStyleElement: The SVGStyleElement interface corresponds to the SVG element.
SVGSVGElement: The SVGSVGElement interface 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.
SVGSwitchElement: The SVGSwitchElement interface corresponds to the element.
SVGSymbolElement: The SVGSymbolElement interface corresponds to the element.
SVGTextContentElement: The SVGTextContentElement interface is implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, SVGTRefElement, and SVGTextPathElement.
SVGTextElement: The SVGTextElement interface corresponds to the elements.
SVGTextPathElement: The SVGTextPathElement interface corresponds to the element.
SVGTextPositioningElement: The SVGTextPositioningElement interface is implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, and SVGTRefElement.
SVGTitleElement: The SVGTitleElement interface corresponds to the element.
SVGTransform
SVGTransformList
SVGTSpanElement: The SVGTSpanElement interface represents a element.
SVGUnitTypes: The SVGUnitTypes interface defines a commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes.
SVGUseElement
SVGViewElement: The SVGViewElement interface provides access to the properties of elements, as well as methods to manipulate them.
SyncEvent: @AvailableInWorkers("service")
SyncEventInit
SyncManager: The SyncManager interface of the Background Synchronization API provides an interface for registering and listing sync registrations.
Table
TableDescriptor
TaskController: The TaskController interface of the Prioritized Task Scheduling API represents a controller object that can be used to both abort and change the priority of one or more prioritized tasks. If there is no need to change task priorities, then AbortController can be used instead.
TaskControllerInit
TaskPriorityChangeEvent: The TaskPriorityChangeEvent is the interface for the prioritychange event.
TaskPriorityChangeEventInit
TaskSignal: The TaskSignal interface of the Prioritized Task Scheduling API represents a signal object that allows you to communicate with a prioritized task, and abort it or change the priority (if required) via a TaskController object.
Text: The Text interface represents a text Node in a DOM tree.
TextDecodeOptions
TextDecoder: The TextDecoder interface represents a decoder for a specific text encoding, such as UTF-8, ISO-8859-2, KOI8-R, GBK, etc. A decoder takes a stream of bytes as input and emits a stream of code points.
TextDecoderOptions
TextDecoderStream: The TextDecoderStream interface of the Encoding API converts a stream of text in a binary encoding, such as UTF-8 etc., to a stream of strings. It is the streaming equivalent of TextDecoder.
TextEncoder: The TextEncoder interface takes a stream of code points as input and emits a stream of UTF-8 bytes.
TextEncoderEncodeIntoResult
TextEncoderStream: The TextEncoderStream interface of the Encoding API converts a stream of strings into bytes in the UTF-8 encoding. It is the streaming equivalent of TextEncoder.
TextEvent
TextMetrics: The TextMetrics interface represents the dimensions of a piece of text in the canvas; a TextMetrics instance can be retrieved using the CanvasRenderingContext2D.measureText method.
TextTrack: The TextTrack interface—part of the API for handling WebVTT (text tracks on media presentations)—describes and controls the text track associated with a particular track element.
TextTrackCue: TextTrackCue is an abstract class which is used as the basis for the various derived cue types, such as VTTCue; you will instead work with those derived types. These cues represent strings of text presented for some duration of time during the performance of a TextTrack. The cue includes the start time (the time at which the text will be displayed) and the end time (the time at which it will be removed from the display), as well as other information.
TextTrackCueList: The TextTrackCueList array-like object represents a dynamically updating list of TextTrackCue objects.
TextTrackList: The TextTrackList interface is used to represent a list of the text tracks defined by the track element, with each track represented by a separate textTrack object in the list.
TimeEvent: The TimeEvent interface, a part of SVG SMIL animation, provides specific contextual information associated with Time events.
TimelineRangeOffset
TimeRanges: When loading a media resource for use by an audio or video element, the TimeRanges interface is used for representing the time ranges of the media resource that have been buffered, the time ranges that have been played, and the time ranges that are seekable.
ToggleEvent: The ToggleEvent interface represents an event notifying the user when a popover element's state toggles between showing and hidden.
ToggleEventInit
Touch: The Touch interface represents a single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad.
TouchEvent: The TouchEvent interface represents an UIEvent which is sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth.
TouchEventInit
TouchInit
TouchList: The TouchList interface represents a list of contact points on a touch surface. For example, if the user has three fingers on the touch surface (such as a screen or trackpad), the corresponding TouchList object would have one Touch object for each finger, for a total of three entries.
TrackEvent: The TrackEvent interface, which is part of the HTML DOM specification, is used for events which represent changes to a set of available tracks on an HTML media element; these events are addtrack and removetrack.
TrackEventInit
TransformStream: The TransformStream interface of the Streams API represents a concrete implementation of the pipe chain transform stream concept.
TransformStreamDefaultController: The TransformStreamDefaultController interface of the Streams API provides methods to manipulate the associated ReadableStream and WritableStream.
TransitionEvent: The TransitionEvent interface represents events providing information related to transitions.
TransitionEventInit
TreeWalker: The TreeWalker object represents the nodes of a document subtree and a position within them.
TrustedHTML: The TrustedHTML interface of the Trusted Types API represents a string that a developer can insert into an injection sink that will render it as HTML. These objects are created via TrustedTypePolicy.createHTML and therefore have no constructor.
TrustedScript: The TrustedScript interface of the Trusted Types API represents a string with an uncompiled script body that a developer can insert into an injection sink that might execute the script. These objects are created via TrustedTypePolicy.createScript and therefore have no constructor.
TrustedScriptURL: The TrustedScriptURL interface of the Trusted Types API represents a string that a developer can insert into an injection sink that will parse it as a URL of an external script. These objects are created via TrustedTypePolicy.createScriptURL and therefore have no constructor.
TrustedTypePolicy: The TrustedTypePolicy interface of the Trusted Types API defines a group of functions which create TrustedType objects.
TrustedTypePolicyFactory: The TrustedTypePolicyFactory interface of the Trusted Types API creates policies and allows the verification of Trusted Type objects against created policies.
TrustedTypePolicyOptions
UIEvent: The UIEvent interface represents simple user interface events.
UIEventInit
ULongRange
URL: The URL interface is used to parse, construct, normalize, and encode . It works by providing properties which allow you to easily read and modify the components of a URL.
URLSearchParams: The URLSearchParams interface defines utility methods to work with the query string of a URL.
UserActivation: The UserActivation interface provides information about whether a user is currently interacting with the page, or has completed an interaction since page load.
ValidityState: The ValidityState interface represents the validity states that an element can be in, with respect to constraint validation. Together, they help explain why an element's value fails to validate, if it's not valid.
ValidityStateFlags
VideoColorSpace: @AvailableInWorkers("window_and_dedicated")
VideoColorSpaceInit
VideoConfiguration
VideoDecoder: @AvailableInWorkers("window_and_dedicated")
VideoDecoderConfig
VideoDecoderInit
VideoDecoderSupport
VideoEncoder: @AvailableInWorkers("window_and_dedicated")
VideoEncoderConfig
VideoEncoderEncodeOptions
VideoEncoderEncodeOptionsForAv1
VideoEncoderEncodeOptionsForAvc
VideoEncoderEncodeOptionsForHevc
VideoEncoderEncodeOptionsForVp9
VideoEncoderInit
VideoEncoderSupport
VideoFrame: @AvailableInWorkers("window_and_dedicated")
VideoFrameBufferInit
VideoFrameCopyToOptions
VideoFrameInit
VideoFrameMetadata
VideoPlaybackQuality: A VideoPlaybackQuality object is returned by the HTMLVideoElement.getVideoPlaybackQuality method and contains metrics that can be used to determine the playback quality of a video.
VideoTrack: The VideoTrack interface represents a single video track from a video element.
VideoTrackList: The VideoTrackList interface is used to represent a list of the video tracks contained within a video element, with each track represented by a separate VideoTrack object in the list.
ViewTransition: The ViewTransition interface of the View Transitions API represents an active view transition, and provides functionality to react to the transition reaching different states (e.g. ready to run the animation, or animation finished) or skip the transition altogether.
VisualViewport: The VisualViewport interface of the Visual Viewport API represents the visual viewport for a given window. For a page containing iframes, each iframe, as well as the containing page, will have a unique window object. Each window on a page will have a unique VisualViewport representing the properties associated with that window.
VTTCue: The VTTCue interface—part of the API for handling WebVTT (text tracks on media presentations)—describes and controls the text track associated with a particular track element.
VTTRegion: The VTTRegion interface—part of the API for handling WebVTT (text tracks on media presentations)—describes a portion of the video to render a VTTCue onto.
WakeLock: The WakeLock interface of the Screen Wake Lock API can be used to request a lock that prevents device screens from dimming or locking when an application needs to keep running.
WakeLockSentinel: The WakeLockSentinel interface of the Screen Wake Lock API can be used to monitor the status of the platform screen wake lock, and manually release the lock when needed.
WaveShaperNode: The WaveShaperNode interface represents a non-linear distorter.
WaveShaperOptions
WebAssemblyInstantiatedSource
WebGL2RenderingContext: The WebGL2RenderingContext interface provides the OpenGL ES 3.0 rendering context for the drawing surface of an HTML canvas element.
WEBGL_color_buffer_float
WEBGL_compressed_texture_astc
WEBGL_compressed_texture_etc
WEBGL_compressed_texture_etc1
WEBGL_compressed_texture_pvrtc
WEBGL_compressed_texture_s3tc
WEBGL_compressed_texture_s3tc_srgb
WEBGL_debug_renderer_info
WEBGL_debug_shaders
WEBGL_depth_texture
WEBGL_draw_buffers
WEBGL_lose_context
WEBGL_multi_draw
WebGLActiveInfo: The WebGLActiveInfo interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib and WebGLRenderingContext.getActiveUniform methods.
WebGLBuffer: The WebGLBuffer interface is part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors.
WebGLContextAttributes
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.
WebGLContextEventInit
WebGLFramebuffer: The WebGLFramebuffer interface is part of the WebGL API and represents a collection of buffers that serve as a rendering destination.
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).
WebGLQuery: The WebGLQuery interface is part of the WebGL 2 API and provides ways to asynchronously query for information. By default, occlusion queries and primitive queries are available.
WebGLRenderbuffer: The WebGLRenderbuffer interface is part of the WebGL API and represents a buffer that can contain an image, or that can be a source or target of a rendering operation.
WebGLRenderingContext: The WebGLRenderingContext interface provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML canvas element.
WebGLSampler: The WebGLSampler interface is part of the WebGL 2 API and stores sampling parameters for WebGLTexture access inside of a shader.
WebGLShader: The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders.
WebGLShaderPrecisionFormat: The WebGLShaderPrecisionFormat interface is part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat method.
WebGLSync: The WebGLSync interface is part of the WebGL 2 API and is used to synchronize activities between the GPU and the application.
WebGLTexture: The WebGLTexture interface is part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations.
WebGLTimerQueryEXT
WebGLTransformFeedback: The WebGLTransformFeedback interface is part of the WebGL 2 API and enables transform feedback, which is the process of capturing primitives generated by vertex processing. It allows to preserve the post-transform rendering state of an object and resubmit this data multiple times.
WebGLUniformLocation: The WebGLUniformLocation interface is part of the WebGL API and represents the location of a uniform variable in a shader program.
WebGLVertexArrayObject: The WebGLVertexArrayObject interface is part of the WebGL 2 API, represents vertex array objects (VAOs) pointing to vertex array data, and provides names for different sets of vertex data.
WebGLVertexArrayObjectOES
WebSocket: The WebSocket object provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
WebTransport: The WebTransport interface of the WebTransport API provides functionality to enable a user agent to connect to an HTTP/3 server, initiate reliable and unreliable transport in either or both directions, and close the connection once it is no longer needed.
WebTransportBidirectionalStream: The WebTransportBidirectionalStream interface of the WebTransport API represents a bidirectional stream created by a server or a client that can be used for reliable transport. Provides access to a WebTransportReceiveStream for reading incoming data, and a WebTransportSendStream for writing outgoing data.
WebTransportCloseInfo
WebTransportDatagramDuplexStream: The WebTransportDatagramDuplexStream interface of the WebTransport API represents a duplex stream that can be used for unreliable transport of datagrams between client and server. Provides access to a ReadableStream for reading incoming datagrams, a WritableStream for writing outgoing datagrams, and various settings and statistics related to the stream.
WebTransportError: The WebTransportError interface of the WebTransport API represents an error related to the API, which can arise from server errors, network connection problems, or client-initiated abort operations (for example, arising from a WritableStream.abort call).
WebTransportErrorOptions
WebTransportHash
WebTransportOptions
WebTransportSendStreamOptions
WheelEvent: The WheelEvent interface represents events that occur due to the user moving a mouse wheel or similar input device.
WheelEventInit
Window: The Window interface represents a window containing a document; the document property points to the DOM document loaded in that window.
WindowClient: @AvailableInWorkers("service")
WindowPostMessageOptions
Worker: @AvailableInWorkers("window_and_worker_except_service")
WorkerGlobalScope: The WorkerGlobalScope interface of the Web Workers API is an interface representing the scope of any worker. Workers have no browsing context; this scope contains the information usually conveyed by Window objects — in this case event handlers, the console or the associated WorkerNavigator object. Each WorkerGlobalScope has its own event loop.
WorkerLocation: The WorkerLocation interface defines the absolute location of the script executed by the Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.location property obtained by calling self.location.
WorkerNavigator: The WorkerNavigator interface represents a subset of the Navigator interface allowed to be accessed from a Worker. Such an object is initialized for each worker and is available via the WorkerGlobalScope.navigator property.
WorkerOptions
Worklet: The Worklet interface is a lightweight version of Worker and gives developers access to low-level parts of the rendering pipeline.
WorkletGlobalScope: The WorkletGlobalScope interface is an abstract class that specific worklet scope classes inherit from. Each WorkletGlobalScope defines a new global environment.
WorkletOptions
WritableStream: The WritableStream interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing.
WritableStreamDefaultController: The WritableStreamDefaultController interface of the Streams API 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.
WritableStreamDefaultWriter: The WritableStreamDefaultWriter interface of the Streams API 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.
WriteParams
XMLDocument: The XMLDocument interface represents an XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents.
XMLHttpRequest: @AvailableInWorkers("window_and_worker_except_service")
XMLHttpRequestEventTarget: @AvailableInWorkers("window_and_worker_except_service")
XMLHttpRequestUpload: @AvailableInWorkers("window_and_worker_except_service")
XMLSerializer: The XMLSerializer interface provides the XMLSerializer.serializeToString method to construct an XML string representing a tree.
XPathEvaluator: The XPathEvaluator interface allows to compile and evaluate expressions.
XPathExpression: This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information from its tree.
XPathResult: The XPathResult interface represents the results generated by evaluating an XPath expression within the context of a given node.
XRHand: The XRHand interface is pair iterator (an ordered map) with the key being the hand joints and the value being an XRJointSpace.
XRInputSource: The WebXR Device API's XRInputSource interface describes a single source of control input which is part of the user's WebXR-compatible virtual or augmented reality system. The device is specific to the platform being used, but provides the direction in which it is being aimed and optionally may generate events if the user triggers performs actions using the device.
XRInputSourceEvent: The WebXR Device API's XRInputSourceEvent interface describes an event which has occurred on a WebXR user input device such as a hand controller, gaze tracking system, or motion tracking system. More specifically, they represent a change in the state of an XRInputSource.
XRInputSourceEventInit
XRInputSourcesChangeEvent: The WebXR Device API interface XRInputSourcesChangeEvent is used to represent the XRSession.inputsourceschange_event event sent to an XRSession when the set of available WebXR input controllers changes.
XRInputSourcesChangeEventInit
XRJointPose: The XRJointPose interface is an XRPose with additional information about the size of the skeleton joint it represents.
XRJointSpace: The XRJointSpace interface is an XRSpace and represents the position and orientation of an XRHand joint.
XRPose: XRPose is a WebXR API interface representing a position and orientation in the 3D space, relative to the XRSpace within which it resides. The XRSpace—which is either an XRReferenceSpace or an XRBoundedReferenceSpace—defines the coordinate system used for the pose and, in the case of an XRViewerPose, its underlying views.
XRReferenceSpace: The WebXR Device API's XRReferenceSpace interface describes the coordinate system for a specific tracked entity or object within the virtual world using a specified tracking behavior. The tracking behavior is defined by the selected reference space type. It expands upon the base class, XRSpace, by adding support for several different tracking behaviors as well as to request a new reference space which describes the offset transform between the tracked object and another location in the world.
XRReferenceSpaceEvent: The WebXR Device API interface XRReferenceSpaceEvent represents an event sent to an XRReferenceSpace. Currently, the only event that uses this type is the XRReferenceSpace.reset_event event.
XRReferenceSpaceEventInit
XRRigidTransform: The XRRigidTransform is a WebXR API interface that represents the 3D geometric transform described by a position and orientation.
XRSessionEvent: The WebXR Device API's XRSessionEvent interface describes an event which indicates the change of the state of an XRSession. These events occur, for example, when the session ends or the visibility of its context changes.
XRSessionEventInit
XRSpace: The XRSpace interface of the WebXR Device API is an abstract interface providing a common basis for every class which represents a virtual coordinate system within the virtual world, in which its origin corresponds to a physical location. Spatial data in WebXR is always expressed relative to an object based upon one of the descendant interfaces of XRSpace, at the time at which a given XRFrame takes place.
XRViewerPose: The WebXR Device API interface XRViewerPose represents the pose (the position and orientation) of a viewer's point of view on the scene. Each XRViewerPose can have multiple views to represent, for example, the slight separation between the left and right eye.
XRViewport: The WebXR Device API's XRViewport interface provides properties used to describe the size and position of the current viewport within the XRWebGLLayer being used to render the 3D scene.
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.

Extensions

AutoElementEventGetters on AudioNode
BoolToJSBoolean on bool: Conversions from bool to JSBoolean.
ByteBufferToJSArrayBuffer on ByteBuffer: Conversions from ByteBuffer to JSArrayBuffer.
ByteDataToJSDataView on ByteData: Conversions from ByteData to JSDataView.
CanvasRenderingContext2DExtension on CanvasRenderingContext2D
CanvasRenderingContext2DGlue on CanvasRenderingContext2D
CrossOriginContentWindowExtension on HTMLIFrameElement
CrossOriginWindowExtension on Window: Safe alternatives to common Window members that can return cross-origin windows.
CSSRuleListExtension on CSSRuleList
CSSStyleDeclarationExtension on CSSStyleDeclaration
DateTimeToJSDateExtension on DateTime
DocumentCustomEvents on Document
DocumentExtension on Document
DomElementExtension on Element
DOMRectExtension on DOMRect
DOMTokenListExtension on DOMTokenList
DoubleToJSNumber on double: Conversions from double to JSNumber.
ElementCustomEvents on Element
ElementEventGetters on Element
ElementExtension on Element
ElementNullableExtension on Element?
EventGlue on MouseEvent
EventSourceEventGetters on EventSource
ExternalDartReferenceToObject on ExternalDartReference<T>: Conversions from ExternalDartReference to the value of type T.
FileListExtension on FileList
FileReaderEventGEtters on FileReader
FileReaderExtension on FileReader
Float32ListToJSFloat32Array on Float32List: Conversions from Float32List to JSFloat32Array.
Float64ListToJSFloat64Array on Float64List: Conversions from Float64List to JSFloat64Array.
FunctionToJSExportedDartFunction on Function: Conversions from Function to JSExportedDartFunction.
FutureOfJSAnyToJSPromise on Future<T>: Conversions from Future to JSPromise where the Future returns a value.
FutureOfVoidToJSPromise on Future<void>: Conversions from Future to JSPromise where the Future does not return a value.
GeolocationExtension on Geolocation
HTMLCanvasElementExtension on HTMLCanvasElement
HTMLCanvasElementGlue on HTMLCanvasElement
HTMLCollectionExtension on HTMLCollection
HTMLElementExtension on HTMLElement
HTMLOptionsCollectionExtension on HTMLOptionsCollection
HTMLSelectElementExtension on HTMLSelectElement
HTMLTableElementExtension on HTMLTableElement
HTMLTableRowElementExtension on HTMLTableRowElement
HTMLTableSectionElementExtension on HTMLTableSectionElement
IDBFactoryExtension on IDBFactory
IDBRequestExtension on IDBRequest
IDBRequestToFutureExtension on IDBRequest
Int16ListToJSInt16Array on Int16List: Conversions from Int16List to JSInt16Array.
Int32ListToJSInt32Array on Int32List: Conversions from Int32List to JSInt32Array.
Int8ListToJSInt8Array on Int8List: Conversions from Int8List to JSInt8Array.
IterableBoolExtension on Iterable<bool>
IterableDomElementExtension on Iterable<E>
IterableDoubleExtension on Iterable<double>
IterableElementExtension on Iterable<T>
IterableExtension on Iterable<T>
IterableIntExtension on Iterable<int>
IterableJSAnyToJSArray on Iterable<T>
IterableNodeExtension on Iterable<Node>
IterableNumExtension on Iterable<num>
IterableOfIterableExtension on Iterable<T>
IterableStringExtension on Iterable<String>
JSAnyExtension on JSAny
JSAnyNullableExtension on JSAny?
JSAnyOperatorExtension on JSAny?: General-purpose JavaScript operators.
JSAnyUtilityExtension on JSAny?: Common utility functions that are useful for any JavaScript value.
JSArrayBufferToByteBuffer on JSArrayBuffer: Conversions from JSArrayBuffer to ByteBuffer.
JSArrayExtension on JSArray<JSAny?>
JSArrayOfJSBigIntExtension on JSArray<JSBigInt>
JSArrayOfJSBooleanExtension on JSArray<JSBoolean>
JSArrayOfJSNumberExtension on JSArray<JSNumber>
JSArrayOfJSStringExtension on JSArray<JSString>
JSArrayToList on JSArray<T>: Conversions from JSArray to List.
JSBooleanToBool on JSBoolean: Conversions from JSBoolean to bool.
JSBoxedDartObjectToObject on JSBoxedDartObject: Conversions from JSBoxedDartObject to Object.
JSDataViewToByteData on JSDataView: Conversions from JSDataView to ByteData.
JSExportedDartFunctionToFunction on JSExportedDartFunction: Conversions from JSExportedDartFunction to Function.
JSFloat32ArrayToFloat32List on JSFloat32Array: Conversions from JSFloat32Array to Float32List.
JSFloat64ArrayToFloat64List on JSFloat64Array: Conversions from JSFloat64Array to Float64List.
JSFunctionUtilExtension on JSFunction: Utility extensions for JSFunction.
JSInt16ArrayToInt16List on JSInt16Array: Conversions from JSInt16Array to Int16List.
JSInt32ArrayToInt32List on JSInt32Array: Conversions from JSInt32Array to Int32List.
JSInt8ArrayToInt8List on JSInt8Array: Conversions from JSInt8Array to Int8List.
JSNumberToNumber on JSNumber: Conversions from JSNumber to double or int.
JSObjectExtension on JSObject
JSObjectWebExtension on JSObject?
JSPromiseToFuture on JSPromise<T>: Conversions from JSPromise to Future.
JSStringToString on JSString: Conversions from JSString to String.
JSUint16ArrayToInt16List on JSUint16Array: Conversions from JSUint16Array to Uint16List.
JSUint32ArrayToUint32List on JSUint32Array: Conversions from JSUint32Array to Uint32List.
JSUint8ArrayToUint8List on JSUint8Array: Conversions from JSUint8Array to Uint8List.
JSUint8ClampedArrayToUint8ClampedList on JSUint8ClampedArray: Conversions from JSUint8ClampedArray to Uint8ClampedList.
ListToJSArray on List<T>: Conversions from List to JSArray.
MapExtension on Map<K, V>
MouseEventExtension on MouseEvent
NamedNodeMapExtension on NamedNodeMap
NodeExtension on Node
NodeGlue on Node
NodeListExtension on NodeList
NodeNullableExtension on Node?
NullableObjectUtilExtension on Object?: Common utility functions for Object?s.
NullableUndefineableJSAnyExtension on JSAny?: Helper methods to determine if a value is JavaScript undefined or null.
NumToJSExtension on num: Conversions from num to JSNumber.
ObjectExtension on Object?
ObjectToExternalDartReference on T: Conversions from a value of type T to ExternalDartReference.
ObjectToJSBoxedDartObject on Object: Conversions from Object to JSBoxedDartObject.
ServiceWorkerContainerExtension on ServiceWorkerContainer
SpeechSynthesisUtteranceExtension on SpeechSynthesisUtterance
StorageExtension on Storage
StorageGlue on Storage
StringExtension on String
StringToJSString on String: Conversions from String to JSString.
SVGElementExtension on SVGElement
TextMetricsExtension on TextMetrics
TouchExtension on Touch
TouchGlue on Touch
TouchListConvert on TouchList
TouchListExtension on TouchList
Uint16ListToJSInt16Array on Uint16List: Conversions from Uint16List to JSUint16Array.
Uint32ListToJSUint32Array on Uint32List: Conversions from Uint32List to JSUint32Array.
Uint8ClampedListToJSUint8ClampedArray on Uint8ClampedList: Conversions from Uint8ClampedList to JSUint8ClampedArray.
Uint8ListExtension on Uint8List
Uint8ListToJSUint8Array on Uint8List: Conversions from Uint8List to JSUint8Array.
WebIterableExtension on Iterable<T>
WebIterableJSAnyExtension on Iterable<T>
WebObjectExtension on Object?
WebSocketEvents on WebSocket
WindowCustomEvents on Window
WindowEventGetters on Window
WindowExtension on Window
WorkerGlobalScopeExtension on WorkerGlobalScope
XHRGetters on XMLHttpRequest
XMLHttpRequestGlue on XMLHttpRequest

Constants

anonymous → const _Anonymous: An annotation that indicates a JS annotated class is structural and does not have a known JavaScript prototype.
codeTheme0 → const Map<String, TextStyle>
codeTheme1 → const Map<String, TextStyle>
codeTheme2 → const Map<String, TextStyle>
cssMaxZIndex → const int
staticInterop → const _StaticInterop: staticInterop enables the JS annotated class to be treated as a "static" interop class.

Properties

codeTheme → CSSThemeSet: final
console → $Console: no setter
CSS → $CSS: no setter
deviceHeight → int?: no setter
deviceWidth → int?: no setter
document → Document: no setter
globalContext → JSObject: The global scope that is used to find user-declared interop members.
no setter
GPUBufferUsage → $GPUBufferUsage: no setter
GPUColorWrite → $GPUColorWrite: no setter
GPUMapMode → $GPUMapMode: no setter
GPUShaderStage → $GPUShaderStage: no setter
GPUTextureUsage → $GPUTextureUsage: no setter
isExtraLargeDevice → bool: no setter
isExtraSmallDevice → bool: no setter
isLargeDevice → bool: no setter
isLargeDeviceOrHigher → bool: no setter
isLargeDeviceOrLower → bool: no setter
isMediumDevice → bool: no setter
isMediumDeviceOrLHigher → bool: no setter
isMediumDeviceOrLower → bool: no setter
isSmallDevice → bool: no setter
isSmallDeviceOrHigher → bool: no setter
isSmallDeviceOrLower → bool: no setter
onDetectTouchDevice → EventStream<TouchDeviceDetection>: Will fire a TouchDeviceDetection when detection finishes.
final
WebAssembly → $WebAssembly: no setter
window → Window: no setter

Functions

addCSSCode(String cssCode) → Future<bool>: Adds a CSS code (cssCode) into DOM.
addCssSource(String cssSource, {int? insertIndex}) → Future<bool>: Add a CSS path using a link element into head DOM node.
addElementsClasses(Iterable<Element> elements, Iterable<String> classes) → bool: Add to elements a set of classes. Will remove classes starting with '!'.
addJavaScriptCode(String scriptCode) → Future<bool>: Adds a JavaScript code (scriptCode) into DOM.
addJavaScriptSource(String scriptSource, {bool addToBody = false, bool async = false}) → Future<bool>: Adds a JavaScript path (scriptSource] into DOM.
addJSFunction(String name, List<String> parameters, String body) → Future<bool>: Adds a JavaScript function into DOM.
animateCSSSequence(Iterable<CSSAnimationConfig> animationsConfig, {Duration? initialDelay, int? repeat, bool? repeatInfinity}) → Future<void>?: Sames animateCSS but runs animationsConfig in sequence;
appendElementInnerHTML(HTMLElement element, String html, {Object? validator, bool unsafe = false}) → void: Appends to the inner HTML of element with parsed result of html.
applyCSS(CSSStyleDeclaration css, Element element, [List<Element>? extraElements]) → bool: Applies css to element and extraElements list if present.
applyPerspective(CanvasImageSource image, List<Point<num>> perspective) → FilterResult?: Apply perspective filter to image.
asCssStyleDeclaration(Object? css) → CSSStyleDeclaration: Parses dynamic css as CSSStyleDeclaration.
blockHorizontalScrollTraverse(HTMLElement element) → void: Blocks a scroll event in the horizontal direction that traverses the element.
blockHorizontalScrollTraverseEvent(HTMLElement element, WheelEvent wheelEvent) → bool: Blocks a wheelEvent in the horizontal direction that traverses the element.
blockScrollTraverse(HTMLElement element) → void: Blocks a scroll event in the vertical and horizontal directions that traverses the element.
blockVerticalScrollTraverse(HTMLElement element) → void: Blocks a scroll event in the vertical direction that traverses the element.
blockVerticalScrollTraverseEvent(HTMLElement element, WheelEvent wheelEvent) → bool: Blocks a wheelEvent in the vertical direction that traverses the element.
buildMetaContent(Map<String, String?> map) → String: Builds a meta content from map.
callJSFunction(String method, [List<Object?>? args]) → dynamic: Calls JavaScript a function method with args.
callJSObjectMethod(JSObject o, String method, [List<Object?>? args]) → dynamic: Calls JavaScript a method in object o with args.
canvasToImageElement(HTMLCanvasElement canvas, [String? mimeType, num? quality]) → HTMLImageElement: Converts canvas to HTMLImageElement
clearSelections() → void: Clears selected text in vieport.
copyElementToClipboard(Element element) → bool: Copies element text to Clipboard.
copyPoints(List<Point<num>> points) → List<Point<num>>: Makes a copy of points.
createAudioElement() → HTMLAudioElement
createCanvasElement({int? width, int? height}) → HTMLCanvasElement: Create an HTMLCanvasElement in the current document.
createDiv({bool inline = false, String? html, Object? validator, bool unsafe = false}) → HTMLDivElement: Creates a div. inline If true sets display: inline-block. html The HTML to parse as content.
createDivInline({String? html, bool unsafe = false}) → HTMLDivElement: Creates a div with display: inline-block.
createDivInlineBlock() → HTMLDivElement: Creates a div with display: inline-block.
createElement({String? html, bool unsafe = false}) → Element: Creates a HTML Element. Returns 1st node form parsed HTML.
createElementTag(String tagName) → HTMLElement: Create an HTMLElement with the specified tagName. If no element with tagName exists, returns an HTMLUnknownElement.
createHTML({String? html, Object? validator, bool unsafe = false}) → HTMLElement: Creates a HTMLElement. Returns 1st node form parsed HTML.
createIFrameElement() → HTMLIFrameElement: Create an HTMLIFrameElement in the current document.
createImageElementFromBase64(String? base64, [String? mimeType]) → HTMLImageElement?: Creates an image from a Base-64 with mimeType.
createImageElementFromFile(File file) → Future<HTMLImageElement>: Creates an image from a file.
createJSInteropWrapper<T extends Object>(T dartObject) → JSObject: Given a instance of a Dart class that contains an @JSExport annotation, creates a JavaScript object that wraps the given Dart object.
createLabel({String? html, Object? validator, bool unsafe = false}) → HTMLLabelElement: Creates a label element.
createScaledImage(CanvasImageSource image, int width, int height, double scale) → CanvasImageSource: Creates a new image from image, of width and height, to a scale.
createSpan({String? html, Object? validator, bool unsafe = false}) → HTMLSpanElement: Creates a span element.
cropImage(CanvasImageSource image, int x, int y, int width, int height) → HTMLCanvasElement?: Crops the image using coordinates x, y, width and height, returning new image (HTMLCanvasElement).
cropImageByRectangle(CanvasImageSource image, Rectangle<num>? crop) → HTMLCanvasElement?: Crops an image using a Rectangle (crop), delegating to method cropImage,
dataURLToBlob(DataURLBase64 dataURL) → Blob: Converts a dataURL to a Blob.
defineCSS(CSSStyleDeclaration? currentCSS, CSSStyleDeclaration? appendCSS, [dynamic defaultCSS]) → CSSStyleDeclaration: Defines a new CSSStyleDeclaration merging currentCSS and appendCSS.
detectTouchDevice() → TouchDeviceDetection?: Starts touch device detection. Returns the current status.
disableDoubleClicks() → void: Disables browser double clicks/tap.
disableScrolling() → void: Disables scrolling in browser.
disableZooming() → void: Disables browser zooming.
downloadBlob(Blob blob, String fileName) → void: Downloads blob of type mimeType, saving a file with fileName.
downloadBytes(List<int> bytes, MimeType mimeType, String fileName) → void: Downloads bytes of type mimeType, saving a file with fileName.
downloadContent(List<String> content, MimeType mimeType, String fileName) → void: Downloads content of type mimeType, saving a file with fileName.
downloadDataURL(DataURLBase64 dataURL, String fileName) → void: Downloads dataURL, saving a file with fileName.
elementMatchesAttribute(Element element, String attributeName, dynamic attributeValue) → bool: Returns true if element matches attributeName and attributeValue.
elementMatchesAttributes(Element element, Map<String, dynamic> attributes) → bool: Returns true if element matches attributes.
elementOnLoad(HTMLImageElement img) → Future<bool>: Returns a Future<bool> for when img loads.
enableScrolling() → void: Enables scrolling in browser.
evalJS(String scriptCode) → dynamic: Call eval() with the content of scriptCode and returns the result.
getAllCssRuleBySelector(Pattern targetSelector, CSSStyleSheet? sheet) → List<CSSRule>: Returns a List<CssRule> for targetSelector.
getAllCssStyleSheet() → List<CSSStyleSheet>: Returns all current CssStyleSheet.
getAllMediaCssRule(String mediaCondition) → List<CSSMediaRule>: Returns a list of @media CssRule with mediaCondition.
getAllOutOfViewportMediaCssRule(int viewportWidth, dynamic viewportHeight) → List<CSSMediaRule>: Returns all CssMediaRule not applied for viewportWidth and viewportHeight.
getAllOutOfViewportMediaCssRuleAsClassRule(int viewportWidth, dynamic viewportHeight, String targetClass) → List<String>: Transforms all CssMediaRule to targetClass rule not applied for viewportWidth and viewportHeight.
getAllViewportMediaCssRule(int viewportWidth, dynamic viewportHeight) → List<CSSMediaRule>: Returns all CssMediaRule applied for viewportWidth viewportHeight.
getAllViewportMediaCssRuleAsClassRule(int viewportWidth, dynamic viewportHeight, String targetClass) → List<String>: Transforms all CssMediaRule to targetClass rule applied for viewportWidth and viewportHeight.
getAnchorElementByHREF(String href) → HTMLAnchorElement?: Selects an AnchorElement in DOM with href.
getComputedStyle({Element? parent, HTMLElement? element, String? classes, String? style, bool? hidden}) → CSSStyleDeclaration: Returns a CSSStyleDeclaration from an element.
getElementAllCssProperties(Element element) → List<String>: Returns a list of CSS properties associated with element
getElementAllCssRule(Element element) → List<CSSRule>: Returns a list of CssRule associated with element.
getElementAttribute(Element element, Object? key) → String?: Returns element attribute with key.
getElementAttributeRegExp(Element element, RegExp key) → String?: Returns element attribute with RegExp key.
getElementAttributeStr(Element element, String key) → String?: Returns element attribute with String key.
getElementByHREF(String tag, String href) → Element?: Selects an Element in DOM with tag and href.
getElementBySRC(String tag, String src) → Element?: Selects an Element in DOM with tag and src.
getElementByValues<V>(String tag, ElementValueGetter getter, List<V> values, [ElementValueGetter? getter2, List<V>? values2]) → Element?: selects in DOM an Element with tag and one of values provided by getter.
getElementDocumentPosition(HTMLElement element) → Pair<num>: Returns the X and Y position of Element int the Document.
getElementHeight(HTMLElement element, [int? def]) → int?: Returns element height. Tries to use 'offsetHeight' or 'style.height' values.
getElementHREF(Element element) → String?: Returns href value for different Element types.
getElementPreComputedStyle(Element element) → CSSStyleDeclaration: Returns a CSSStyleDeclaration of the pre-computed CSS properties of element.
getElementSRC(Element element) → String?: Returns src value for different Element types.
getElementsWithAttributes(String tag, Map<String, dynamic> matchAttributes) → List<Element>: Selects elements from DOM with tag and matches attribute.
getElementTagName(Node node) → String?: Returns the node tag name. Returns null if node is not an Element.
getElementValue(Element element, [String? def]) → String?: Gets the element value depending of identified type.
getElementWidth(HTMLElement element, [int? def]) → int?: Returns element width. Tries to use 'offsetWidth' or 'style.width' values.
getElementZIndex(Element? element, [String? def]) → String?: Returns the element z-index or element.parent z-index recursively.
getFileMimeType(File file, [String accept = '']) → MimeType?: Returns the file MimeType.
getImageDimension(CanvasImageSource image) → Rectangle<int>?: Gets the width and height from image (CanvasImageSource).
getLinkElementByHREF(String href, [String? rel]) → HTMLLinkElement?: Selects an LinkElement in DOM with href.
getMetaTagsContentWithName(String name) → List<String?>: Returns a list of meta contet with name.
getMetaTagsWithName(String name) → List<Element>: Returns a list of meta Element with name.
getParentElement(Element element, {bool validator(Element parent)?, int maxLevels = 1000}) → Element?: Returns the parent of element applying validator and maxLevels.
getScriptElementBySRC(String src) → HTMLScriptElement?: Selects an ScriptElement in DOM with src.
getURLData(String url, {String? user, String? password, bool withCredentials = true}) → Future<Uint8List>: Makes a HTTP request and returns url content as Uint8List.
getVisibleNode(HTMLElement? element) → HTMLElement?: Get the first visible element in the hierarchy.
htmlToText(String html, [Object? validator]) → String?: Transform html to plain text.
importModule(JSAny moduleName) → JSPromise<JSObject>: Dynamically imports a JavaScript module with the given moduleName using the JavaScript import() syntax.
isCssEmpty(CSSStyleDeclaration css) → bool: Returns true if CSSStyleDeclaration is empty.
isCssNotEmpty(CSSStyleDeclaration css) → bool: Returns true if CSSStyleDeclaration is not empty.
isElementWithHREF(Element element) → bool: Returns true if element type can have href attribute.
isElementWithSRC(Element element) → bool: Returns true if element type can have src attribute.
isInDOM(Object? element) → bool: Returns true if element is in DOM tree.
isInlineElement(HTMLDivElement element, {bool checkBootstrapClasses = true}) → bool: Returns true if element display property is inline.
isInViewport(Element element, {bool fully = false}) → bool: Returns true if element is visible in viewport.
isMobileAppStatusBarTranslucent() → bool: Returns true if meta tag of name apple-mobile-web-app-status-bar-style is translucent.
isNodeInDOM(Node node) → bool: Returns true if node is in DOM tree.
isOrientationInLandscapeMode() → bool: Returns true if device orientation is in Landscape mode.
isOrientationInPortraitMode() → bool: Returns true if device orientation is in Portrait mode.
isSafariIOS() → bool
jsArrayToList(JSArray<JSAny?>? a) → List?: Converts a JSArray a to a List. Also converts values using jsToDart.
jsObjectKeys(JSObject o) → List<String>: Returns the keys of JSObject o.
jsObjectToMap(JSObject? o) → Map?: Converts a JSObject o to a Map. Also converts keys and values using jsToDart.
jsToDart(Object? o) → Object?: Converts o to Dart primitives or collections.
lerpDouble(num a, num b, double t) → double?
loadCSS(String cssClassPrefix, Map<String, CSSValueBase>? css) → void: Loads css dynamically.
mapJSFunction(String jsFunctionName, MappedFunction f) → void: Maps a JavaScript function to a Dart function.
markdownToDiv(String markdown, {bool normalize = true, Iterable<BlockSyntax>? blockSyntaxes, Iterable<InlineSyntax>? inlineSyntaxes, ExtensionSet? extensionSet, Resolver? linkResolver, Resolver? imageLinkResolver, bool inlineOnly = false}) → HTMLDivElement: Converts a markdown document into a HTML in a div node.
markdownToHtml(String markdown, {bool normalize = true, Iterable<BlockSyntax>? blockSyntaxes, Iterable<InlineSyntax>? inlineSyntaxes, ExtensionSet? extensionSet, Resolver? linkResolver, Resolver? imageLinkResolver, bool inlineOnly = false}) → String: Converts a markdown document into a HTML string.
measureText(String text, {required String fontFamily, required Object fontSize, bool bold = false}) → Dimension?
newCSSStyleDeclaration({String? cssText}) → CSSStyleDeclaration
nodeTreeContains(Node rootNode, Node target) → bool: Returns true if rootNode contains target.
nodeTreeContainsAny(Node rootNode, Iterable<Node> list) → bool: Returns true if rootNode contains any Node in list.
normalizeIndent(String text) → String: Normalizes a indent, removing the common/global indent of the code.
numsToPoints(List<num> perspective) → List<Point<num>>: Converts a List<num>, as pairs, to a List<Point>.
onOrientationchange(EventListener listener) → bool: Attaches listener to orientationchange event.
parseCSSLength(String cssValue, {String? unit, int? def, bool allowPXWithoutSuffix = false}) → num?: Parses a CSS length, using optional unit.
parseCssRuleSelectors(CSSRule cssRule) → List<String>: Parses the selectors of cssRule.
parseCssRuleTextProperties(String? cssRuleText) → String: Returns a list of properties of the CssRule text.
parseCssRuleTextSelectors(String? cssRuleText) → List<String>: Returns a list of selectors of the CssRule text.
parseMetaContent(String content) → Map<String, String?>: Parses a meta content to Map<String,String>.
prefetchHref(String href, {int? insertIndex, bool? preLoad}) → Future<bool>: Prefetch a HREF using a link element into head DOM node.
querySelector(String selector) → Element?: Finds and returns the first element within the document that matches the specified CSS selector string. If no match is found, null is returned.
readFileDataAsArrayBuffer(File file) → Future<Uint8List?>: Reads file as Uint8List.
readFileDataAsBase64(File file) → Future<String?>: Reads file as Base64 String.
readFileDataAsDataURLBase64(File file, [String accept = '']) → Future<String?>: Reads file as DATA URL Base64 String.
readFileDataAsText(File file) → Future<String?>: Reads file as text.
readFileInputElementAsArrayBuffer(HTMLInputElement? input, [bool removeExifFromImage = false]) → Future<Uint8List?>: Reads selected file of input as Uint8List.
readFileInputElementAsBase64(HTMLInputElement? input, [bool removeExifFromImage = false]) → Future<String?>: Reads selected file of input as Base64.
readFileInputElementAsDataURLBase64(HTMLInputElement? input, [bool removeExifFromImage = false]) → Future<String?>: Reads selected file of input as DATA URL Base64.
readFileInputElementAsString(HTMLInputElement? input, [bool removeExifFromImage = false]) → Future<String?>: Reads selected file of input as String.
redirectOnTouchEndToMouseEvent(Element element) → void: Redirects element.onTouchEnd to element.onMouseUp as MouseEvent.
redirectOnTouchMoveToMouseEvent(Element element) → void: Redirects element.onTouchMove to element.onMouseMove as MouseEvent.
redirectOnTouchStartToMouseEvent(Element element) → void: Redirects element.onTouchStart to element.onMouseDown as MouseEvent.
reloadAssets(Map<String, String> assetsURLAndTag, {Duration? timeout}) → Future<bool>: Reloads an asset (img, audi or video), forcing reload of asset URL.
reloadIframe(HTMLIFrameElement iFrame, [bool? forceGet]) → Future<bool>: Reloads an IFrame document.
removeElementBackgroundBlur(Element element, [int? blurSize]) → void: Removes element background blur effect, set by setElementBackgroundBlur.
removeElementScrollColors(Element element) → List<String>?: Removes element scroll colors CSS properties set by setElementScrollColors.
removeExifFromImageFile(File file) → Future<String?>: Removes Exif from JPEG file.
replaceElement(Node n1, Node n2) → bool: Replaces n1 with n2 in n1 parent.
resetZoom() → void: Resets viewport zoom.
rotateCanvasImageSource(CanvasImageSource image, int width, int height, [dynamic angleDegree = 90]) → HTMLCanvasElement: Rotates image (a CanvasImageSource) with angleDegree.
rotateImageElement(HTMLImageElement image, [dynamic angleDegree = 90]) → HTMLCanvasElement: Rotates image with angleDegree.
scalePoints(List<Point<num>> points, double scale) → List<Point<num>>: Scales points to scale.
scalePointsXY(List<Point<num>> points, double scaleX, double scaleY) → List<Point<num>>: Scales points to scaleX and scaleY.
scrollTo(num? x, num? y, {bool smooth = true, int? delayMs, Object? scrollable}) → void: Scrolls viewport to x,y.
scrollToBottom({bool smooth = true, int? delayMs, Object? scrollable}) → void: Scrolls viewport to the bottom.
scrollToElement(HTMLElement element, {bool centered = true, bool vertical = true, bool horizontal = true, bool smooth = true, int? translateX, int? translateY, Object? scrollable}) → void: Scrolls the viewport to the element.
scrollToLeft({bool smooth = true, int? delayMs, Object? scrollable}) → void: Scrolls viewport to the left border.
scrollToRight({bool smooth = true, int? delayMs, Object? scrollable}) → void: Scrolls viewport to the right border.
scrollToTop({bool smooth = true, int y = 0, bool fixSafariIOS = false, int? delayMs, Object? scrollable}) → void: Scrolls viewport to the top.
scrollToTopDelayed(int delayMs) → void: Use scrollToTop instead.
selectCssRuleWithSelector(Pattern targetSelector) → List<CSSRule>: Returns a list of CssRule with targetSelector patterns.
setDivCentered(HTMLDivElement div, {bool centerVertically = true, bool centerHorizontally = true, bool checkBootstrapClasses = true}) → void: Sets div as centered content, using display property as table and sub div elements display property as table-cell.
setElementBackgroundBlur(Element element, [int? blurSize]) → void: Sets element background as a blur effect of size blurSize. Uses CSS property backdrop-filter.
setElementHREF(Element element, String href) → bool: Sets element href depending of the identified type.
setElementInnerHTML(HTMLElement element, String html, {Object? validator, bool unsafe = false}) → void: Sets the inner HTML of element with parsed result of html.
setElementScrollColors(Element element, int scrollWidth, String scrollButtonColor, [String? scrollBgColor]) → String?: Sets element scroll colors, using standard CSS property scrollbar-color and webkit pseudo element ::-webkit-scrollbar-thumb and ::-webkit-scrollbar-track
setElementSRC(Element element, String src) → bool: Sets the element src depending of the identified type.
setElementValue(Element? element, String value) → bool: Sets the element value depending of the identified type.
setMetaViewportScale({String? minimumScale, String? maximumScale}) → bool: Sets the meta viewport with minimumScale and maximumScale.
setTreeElementsBackgroundBlur(Element element, String className) → void
setTreeElementsDivCentered(Element element, String className, {bool centerVertically = true, bool centerHorizontally = true}) → void: Set all element sub div with className to centered content.
setZoom(String zoom) → void: Sets the viewport zoom.
showDialogElement(HTMLElement content, {double? transparency, String? padding}) → HTMLDivElement: Shows an Element dialog.
showDialogHTML(String? html, {double? transparency, String? padding, Object? validator, bool unsafe = false}) → HTMLDivElement?: Shows a html dialog.
showDialogImage(String src) → void: Shows an image (src) dialog.
showDialogText(String? text, {double? transparency, String? padding}) → HTMLDivElement?: Shows a text dialog.
toCanvasElement(CanvasImageSource imageSource, int width, int height) → HTMLCanvasElement: Converts imageSource to HTMLCanvasElement.
toDataURLBase64(String? mediaType, String base64) → String: Builds a DATA URL string.
toHTML(HTMLElement element) → String: Converts element to HTML.
touchEventToMouseEvent(TouchEvent event) → MouseEvent?: Converts a TouchEvent event to a MouseEvent.
translatePoints(List<Point<num>> points, num x, num y) → List<Point<num>>: Translate pints in x and y.
tryCall<R>(R call()) → R?

Typedefs

AccelerometerLocalCoordinateSystem = String
AlgorithmIdentifier = JSAny
AlignSetting = String
AllowSharedBufferSource = JSObject
AlphaOption = String
AnimationCallback = void Function()
AnimationPlayState = String
AnimationReplaceState = String
AppendMode = String
ArrayBufferView = JSObject
AudioContextLatencyCategory = String
AudioContextRenderSizeCategory = String
AudioContextState = String
AudioElement = HTMLAudioElement: All usages of this type alias should be updated to the more consistent HTMLAudioElement.
AudioSinkType = String
AudioWorkletProcessorConstructor = JSFunction
AutoKeyword = String
AutomationRate = String
AvcBitstreamFormat = String
BinaryData = JSObject
BinaryType = String
BiquadFilterType = String
BitrateMode = String
BlobCallback = JSFunction
BlobPart = JSAny
BodyInit = JSAny
BufferSource = JSObject
CanPlayTypeResult = String
CanvasDirection = String
CanvasElement = HTMLCanvasElement: All usages of this type alias should be updated to the more consistent HTMLCanvasElement.
CanvasFillRule = String
CanvasFontKerning = String
CanvasFontStretch = String
CanvasFontVariantCaps = String
CanvasImageSource = JSObject
CanvasLineCap = String
CanvasLineJoin = String
CanvasTextAlign = String
CanvasTextBaseline = String
CanvasTextRendering = String
ChannelCountMode = String
ChannelInterpretation = String
ClientType = String
ClipboardItems = JSArray<ClipboardItem>
CodecState = String
ColorGamut = String
ColorSpaceConversion = String
CompositeOperation = String
CompressionFormat = String
ConstrainBoolean = JSAny
ConstrainDOMString = JSAny
ConstrainDouble = JSAny
ConstrainPoint2D = JSObject
ConstrainULong = JSAny
ContextEvent = WebGLContextEvent: All usages of this type alias should be updated to the more consistent WebGLContextEvent.
CookieList = JSArray<CookieListItem>
CookieSameSite = String
COSEAlgorithmIdentifier = int
CreateHTMLCallback = JSFunction
CreateScriptCallback = JSFunction
CreateScriptURLCallback = JSFunction
CredentialMediationRequirement = String
CSSKeywordish = JSAny
CSSMathOperator = String
CSSNumberish = JSAny
CSSNumericBaseType = String
CSSPerspectiveValue = JSAny
CssStyleDeclaration = CSSStyleDeclaration: All usages of this type alias should be updated to the more consistent CSSStyleDeclaration.
CSSUnparsedSegment = JSAny
CustomElementConstructor = JSFunction
DecodeErrorCallback = JSFunction
DecodeSuccessCallback = JSFunction
DirectionSetting = String
DistanceModelType = String
DocumentReadyState = String
DocumentVisibilityState = String
DOMHighResTimeStamp = num
DOMParserSupportedType = String
EffectiveConnectionType = String
ElementValueGetter<T> = T? Function(Element element): Returns a value from an Element.
EncodedVideoChunkOutputCallback = JSFunction
EncodedVideoChunkType = String
EndingType = String
EndOfStreamError = String
EpochTimeStamp = int
ErrorCallback = JSFunction
EventHandler = EventHandlerNonNull?
EventHandlerNonNull = JSFunction
EventListener = JSFunction
FileCallback = JSFunction
FileSystemEntriesCallback = JSFunction
FileSystemEntryCallback = JSFunction
FileSystemHandleKind = String
FileSystemWriteChunkType = JSAny
FillMode = String
Float32List = JSObject
FontFaceLoadStatus = String
FontFaceSetLoadStatus = String
FormDataEntryValue = JSAny
FrameRequestCallback = JSFunction
FrameType = String
FullscreenNavigationUI = String
FunctionStringCallback = JSFunction
FunctionTest = bool Function()
GamepadHapticEffectType = String
GamepadHapticsResult = String
GamepadMappingType = String
GLbitfield = int
GLboolean = bool
GLclampf = num
GLenum = int
GLfloat = num
GLint = int
GLint64 = int
GLintptr = int
GLsizei = int
GLsizeiptr = int
GLuint = int
GLuint64 = int
GPUFlagsConstant = int
GyroscopeLocalCoordinateSystem = String
HardwareAcceleration = String
HdrMetadataType = String
HeadersInit = JSObject
HevcBitstreamFormat = String
HighlightType = String
HtmlElement = HTMLElement: All usages of this type alias should be updated to the more consistent HTMLElement.
HTMLOrSVGImageElement = JSObject
HTMLOrSVGScriptElement = JSObject
IDBCursorDirection = String
IDBRequestReadyState = String
IDBTransactionDurability = String
IDBTransactionMode = String
IdentityCredentialRequestOptionsContext = String
IdleRequestCallback = JSFunction
ImageBitmapSource = JSObject
ImageElement = HTMLImageElement: All usages of this type alias should be updated to the more consistent HTMLImageElement.
ImageFilter = CanvasImageSource Function(CanvasImageSource? image, int width, int height): Applies a filter to image, of width and height.
ImageOrientation = String
ImageSmoothingQuality = String
ImportExportKind = String
Int32List = JSObject
IntersectionObserverCallback = JSFunction
IPAddressSpace = String
IterationCompositeOperation = String
JSVoid = void: JS type equivalent for undefined for interop member return types.
KeyFormat = String
KeyType = String
KeyUsage = String
LatencyMode = String
LineAlignSetting = String
LineAndPositionSetting = JSAny
LockGrantedCallback = JSFunction
LockMode = String
MappedFunction = dynamic Function(dynamic o)
MatchesValue = bool Function(String value)
MediaDecodingType = String
MediaDeviceKind = String
MediaEncodingType = String
MediaKeyMessageType = String
MediaKeySessionClosedReason = String
MediaKeySessionType = String
MediaKeysRequirement = String
MediaKeyStatus = String
MediaProvider = JSObject
MediaSessionAction = String
MediaSessionActionHandler = JSFunction
MediaSessionPlaybackState = String
MediaStreamTrackState = String
Megabit = num
MessageEventSource = JSObject
MIDIPortConnectionState = String
MIDIPortDeviceState = String
MIDIPortType = String
Millisecond = int
MonitorTypeSurfacesEnum = String
MutationCallback = JSFunction
NavigationTimingType = String
NodeFilter = JSFunction
NotificationDirection = String
NotificationPermission = String
NotificationPermissionCallback = JSFunction
OffscreenRenderingContext = JSObject
OffscreenRenderingContextId = String
OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull?
OnBeforeUnloadEventHandlerNonNull = JSFunction
OnElementEvent = void Function(Element element)
OnElementTrackValueEvent<T> = bool Function(Element element, T? value)
OnErrorEventHandler = OnErrorEventHandlerNonNull?
OnErrorEventHandlerNonNull = JSFunction
OperationType = String
OrientationLockType = String
OrientationSensorLocalCoordinateSystem = String
OrientationType = String
OscillatorType = String
OTPCredentialTransportType = String
OverSampleType = String
PanningModelType = String
PasswordCredentialInit = JSObject
PaymentComplete = String
PerformanceEntryList = JSArray<PerformanceEntry>
PerformanceObserverCallback = JSFunction
PermissionState = String
PlaybackDirection = String
PositionAlignSetting = String
PositionCallback = JSFunction
PositionErrorCallback = JSFunction
PredefinedColorSpace = String
PremultiplyAlpha = String
PresentationStyle = String
PushEncryptionKeyName = String
PushMessageDataInit = JSAny
QueuingStrategySize = JSFunction
ReadableStreamReader = JSObject
ReadableStreamReaderMode = String
ReadyState = String
RecordingState = String
ReferrerPolicy = String
RefreshPolicy = String
RemotePlaybackAvailabilityCallback = JSFunction
RemotePlaybackState = String
RenderBlockingStatusType = String
RenderingContext = JSObject
ReportingObserverCallback = JSFunction
ReportList = JSArray<Report>
RequestCache = String
RequestCredentials = String
RequestDestination = String
RequestDuplex = String
RequestInfo = JSAny
RequestMode = String
RequestPriority = String
RequestRedirect = String
ResizeObserverBoxOptions = String
ResizeObserverCallback = JSFunction
ResizeQuality = String
ResponseType = String
RotationMatrixType = JSObject
RTCBundlePolicy = String
RTCDataChannelState = String
RTCDegradationPreference = String
RTCDtlsTransportState = String
RTCEncodedVideoFrameType = String
RTCErrorDetailType = String
RTCIceCandidateType = String
RTCIceComponent = String
RTCIceConnectionState = String
RTCIceGathererState = String
RTCIceGatheringState = String
RTCIceProtocol = String
RTCIceRole = String
RTCIceTcpCandidateType = String
RTCIceTransportPolicy = String
RTCIceTransportState = String
RTCPeerConnectionErrorCallback = JSFunction
RTCPeerConnectionState = String
RTCPriorityType = String
RTCRtcpMuxPolicy = String
RTCRtpTransceiverDirection = String
RTCRtpTransform = JSObject
RTCSctpTransportState = String
RTCSdpType = String
RTCSessionDescriptionCallback = JSFunction
RTCSignalingState = String
SameSiteCookiesType = String
SanitizerAttribute = JSAny
SanitizerElement = JSAny
SanitizerElementWithAttributes = JSAny
SchedulerPostTaskCallback = JSFunction
ScrollBehavior = String
ScrollLogicalPosition = String
ScrollRestoration = String
ScrollSetting = String
SecurityPolicyViolationEventDisposition = String
SelectionMode = String
SelfCapturePreferenceEnum = String
ServiceWorkerState = String
ServiceWorkerUpdateViaCache = String
ShadowRootMode = String
SlotAssignmentMode = String
SpeechRecognitionErrorCode = String
SpeechSynthesisErrorCode = String
StateEventListener = void Function(StateOperation op, State state, String key, dynamic value)
StateKeyListener = void Function(dynamic value)
SurfaceSwitchingPreferenceEnum = String
SystemAudioPreferenceEnum = String
TableKind = String
TaskPriority = String
TexImageSource = JSObject
TextTrackKind = String
TextTrackMode = String
TimerHandler = JSAny
TokenVersion = String
TouchType = String
TransferFunction = String
Uint32List = JSObject
UpdateCallback = JSFunction
UvmEntries = JSArray<UvmEntry>
UvmEntry = JSArray<JSNumber>
ValueCopier<T> = T? Function(T? value)
ValueType = String
VibratePattern = JSAny
VideoColorPrimaries = String
VideoElement = HTMLVideoElement: All usages of this type alias should be updated to the more consistent HTMLVideoElement.
VideoEncoderBitrateMode = String
VideoFrameOutputCallback = JSFunction
VideoFrameRequestCallback = JSFunction
VideoMatrixCoefficients = String
VideoPixelFormat = String
VideoTransferCharacteristics = String
VoidFunction = JSFunction
WakeLockType = String
WebCodecsErrorCallback = JSFunction
WebGL = WebGLRenderingContext: All usages of this type alias should be updated to the more consistent WebGLRenderingContext.
WebGLPowerPreference = String
WebTransportCongestionControl = String
WebTransportErrorSource = String
WorkerType = String
WriteCommandType = String
XMLHttpRequestBodyInit = JSAny
XMLHttpRequestResponseType = String
XPathNSResolver = JSFunction
XRHandedness = String
XRHandJoint = String
XRTargetRayMode = String

Exceptions / Errors

NullRejectionException: Exception for when the promise is rejected with a null or undefined value.

dom_tools_kit library

Classes