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

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

Registers an event listener in the global scope, which will be called synchronously whenever the event type is dispatched.

Options for configuring an event listener via addEventListener.

Shows the given message and waits for the enter key pressed.

Decodes a string of data which has been encoded using base-64 encoding.

Specifies the type of binary data being received over a WebSocket connection.

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

Represents a named channel that any BroadcastChannel with the same name (across workers or isolates in the same Deno process) can use to send and receive messages, allowing one-to-many communication between execution contexts.

Creates a base-64 ASCII encoded string from the input string.

Represents a single named store of Request/Response pairs. Obtain a Cache via CacheStorage.open and use it to persist responses and later match incoming requests against them.

The global CacheStorage instance, providing access to the named Cache objects used to store and retrieve Request/Response pairs.

Represents the storage for named Cache objects. It provides the methods used to open, enumerate, look up, and delete caches, and is accessed via the global caches property.

Exits the current Deno process.

Indicates whether the current window (context) is closed. In Deno, this property is primarily for API compatibility with browsers.

The CloseEvent interface represents an event that occurs when a WebSocket connection is closed.

Configuration options for a WebSocket "close" event.

Specifies whether the image should be decoded using color space conversion. Either none or default (default). The value default indicates that implementation-specific behavior is used.

An API for compressing a stream of data.

Shows the given message and waits for the answer. Returns the user's answer as boolean.

The Console interface provides methods for logging information to the console, as well as other utility methods for debugging and inspecting code. Methods include logging, debugging, and timing functionality.

A global console object that provides methods for logging, debugging, and error reporting. The console object provides access to the browser's or runtime's debugging console functionality. It allows developers to output text and data for debugging purposes.

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

Create a new ImageBitmap object from a given source.

This Web Crypto API interface provides basic cryptographic functionality. It is accessed via the global crypto property, which gives access to cryptographically strong random number generation and to the low-level primitives exposed by SubtleCrypto through Crypto.subtle.

The global instance of Crypto that provides access to the Web Crypto API, including cryptographically secure random number generation via Crypto.getRandomValues, random UUID generation via Crypto.randomUUID, and the low-level primitives exposed by SubtleCrypto through Crypto.subtle.

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

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

An API for decompressing a stream of data.

Dispatches an event in the global scope, synchronously invoking any registered event listeners for this event in the appropriate order. Returns false if event is cancelable and at least one of the event handlers which handled this event called Event.preventDefault(). Otherwise it returns true.

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. The interface is available inside web workers.

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.

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.

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

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.

A DOMRect describes the size and position of a rectangle.

The DOMRectReadOnly interface specifies the standard properties (also used by DOMRect) to define a rectangle whose properties are immutable.

An event which takes place in the DOM.

The EventListenerObject interface represents an object that can handle events dispatched by an EventTarget object.

Represents a connection to a server that sends server-sent events, receiving updates pushed by the server as a stream of message events over a persistent HTTP connection that automatically reconnects when interrupted.

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

Fetch a resource from the network. It returns a Promise that resolves to the Response to that Request, whether it is successful or not.

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

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.

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

The entry point to WebGPU in Deno, accessed via the global navigator.gpu property.

Represents a physical GPU device that can be used to create a logical GPU device.

Represents a block of memory allocated on the GPU.

The rendering context that presents WebGPU-rendered images on an OffscreenCanvas. Obtained from OffscreenCanvas.getContext with the "webgpu" context id.

Used to record GPU commands for later execution by the GPU.

The primary interface for interacting with a WebGPU device.

The GPUError interface of the WebGPU API is the base interface for errors surfaced by GPUDevice.popErrorScope and the GPUDevice.uncapturederror_event event. Available only in secure contexts.

The GPUPipelineError interface of the WebGPU API describes a pipeline failure. Available only in secure contexts.

Represents a queue to submit commands to the GPU.

Represents a compiled shader module that can be used to create graphics or compute pipelines.

Represents a texture (image) in GPU memory.

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

ImageBitmap interface represents a bitmap image which can be drawn to a canvas.

The options of createImageBitmap.

A rendering context that displays the contents of an ImageBitmap on an OffscreenCanvas. Obtained from OffscreenCanvas.getContext with the "bitmaprenderer" context id.

The ImageBitmapSource type represents an image data source that can be used to create an ImageBitmap.

Specifies how the bitmap image should be oriented.

Deno provides extra properties on import.meta. These are included here to ensure that these are still available when using the Deno namespace in conjunction with other type libs, like dom.

The Intl namespace groups the ECMAScript Internationalization API constructors and functions.

Represents a part of a formatted date range produced by Intl.DateTimeFormat.formatRange().

Types that can be formatted using Intl.DateTimeFormat methods.

Augments the standard Intl.Locale interface with members not yet present in the bundled TypeScript library definitions.

Deno's localStorage API provides a way to store key-value pairs in a web-like environment, similar to the Web Storage API found in browsers. It allows developers to persist data across sessions in a Deno application. This API is particularly useful for applications that require a simple and effective way to store data locally.

The location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Accessible via globalThis.location.

The Location object describing the absolute URL of the main module, available when the program is started with the --location flag. Accessing it without --location throws.

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.

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.

Gets or sets the name of the global scope's browsing context.

Provides information about the Deno runtime environment and the system on which it's running. Similar to the browser Navigator object but adapted for the Deno context.

Provides access to the Deno runtime's Navigator interface, which contains information about the environment in which the script is running.

A canvas that can be rendered to off the main thread and without being attached to the DOM. It exposes drawing contexts via OffscreenCanvas.getContext and can produce a Blob or ImageBitmap from its contents.

Before unload event handler for the window. In Deno, this is primarily for API compatibility with browsers.

Error event handler for the window. Triggered when an uncaught error occurs in the global scope.

Load event handler for the window. In Deno, this is primarily for API compatibility with browsers.

Event handler for unhandled promise rejections. Triggered when a Promise is rejected and no rejection handler is attached to it.

Unload event handler for the window. In Deno, this is primarily for API compatibility with browsers.

Deno supports User Timing Level 3 which is not widely supported yet in other runtimes.

The global Performance instance, providing access to high-resolution timing via performance.now() and the user-timing marks and measures APIs.

Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the .mark() method) at an explicit point in an application.

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

Options which are used in conjunction with performance.mark. Check out the MDN performance.mark() documentation for more details.

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

Options which are used in conjunction with performance.measure. Check out the MDN performance.mark() documentation for more details.

Specifies whether the bitmap's color channels should be premultiplied by the alpha channel.

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