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

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.

An event which takes place in the DOM.

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

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

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

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.

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.

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

This Fetch API interface represents a resource request.

This Fetch API interface represents the response to a request.

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

The URLPattern API provides a web platform primitive for matching URLs based on a convenient pattern syntax.

The syntax is based on path-to-regexp. Wildcards, named capture groups, regular groups, and group modifiers are all supported.

// Specify the pattern as structured data.
const pattern = new URLPattern({ pathname: "/users/:user" });
const match = pattern.exec("/users/joe");
console.log(match.pathname.groups.user); // joe

// Specify a fully qualified string pattern.
const pattern = new URLPattern("https://example.com/books/:id");
console.log(pattern.test("https://example.com/books/123")); // true
console.log(pattern.test("https://deno.land/books/123")); // false

// Specify a relative string pattern with a base URL.
const pattern = new URLPattern("/:article", "https://blog.example.com");
console.log(pattern.test("https://blog.example.com/article")); // true
console.log(pattern.test("https://blog.example.com/article/123")); // false

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

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

addEventListener('unload', () => { console.log('All finished!'); });
...
dispatchEvent(new Event('unload'));

Shows the given message and waits for the enter key pressed. If the stdin is not interactive, it does nothing.

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

console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'

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

console.log(btoa("hello world"));  // outputs "aGVsbG8gd29ybGQ="

Cancels a timed, repeating action which was previously started by a call to setInterval()

const id = setInterval(() => {console.log('hello');}, 500);
...
clearInterval(id);

Cancels a scheduled action initiated by setTimeout()

const id = setTimeout(() => {console.log('hello');}, 500);
...
clearTimeout(id);

Shows the given message and waits for the answer. Returns the user's answer as boolean. Only y and Y are considered as true. If the stdin is not interactive, it returns false.

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.

dispatchEvent(new Event('unload'));

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

const response = await fetch("http://my.json.host/data.json");
console.log(response.status);  // e.g. 200
console.log(response.statusText); // e.g. "OK"
const jsonData = await response.json();

Shows the given message and waits for the user's input. Returns the user's input as string. If the default value is given and the user inputs the empty string, then it returns the given default value. If the default value is not given and the user inputs the empty string, it returns null. If the stdin is not interactive, it returns null.

A microtask is a short function which is executed after the function or module which created it exits and only if the JavaScript execution stack is empty, but before returning control to the event loop being used to drive the script's execution environment. This event loop may be either the main event loop or the event loop driving a web worker.

queueMicrotask(() => { console.log('This event loop stack is complete'); });

Remove a previously registered event listener from the global scope

const lstnr = () => { console.log('hello'); };
addEventListener('load', lstnr);
removeEventListener('load', lstnr);

Repeatedly calls a function , with a fixed time delay between each call.

// Outputs 'hello' to the console every 500ms
setInterval(() => { console.log('hello'); }, 500);

Sets a timer which executes a function once after the timer expires. Returns an id which may be used to cancel the timeout.

setTimeout(() => { console.log('hello'); }, 500);

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.

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

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.

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

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.

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.

Deno supports user timing Level 3 (see: https://w3c.github.io/user-timing) which is not widely supported yet in other runtimes. These types are here so that these features are still available when using the Deno namespace in conjunction with other type libs, like dom.

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

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

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

URLPatternResult is the object returned from URLPattern.exec.

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

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

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