Context that is passed to a benchmarked function. The instance is shared
between iterations of the benchmark. Its methods can be used for example
to override of the measured portion of the function.
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.
Raised when trying to write to a resource and a broken pipe error occurs.
This can happen when trying to write directly to stdout or stderr
and the operating system is unable to pipe the output for a reason
external to the Deno runtime.
The interface returned from calling {@linkcode Deno.Command.output} or
{@linkcode Deno.Command.outputSync} which represents the result of spawning the
child process.
Raised when the underlying operating system reports that a connection has
been reset. With network servers, it can be a normal occurrence where a
client will abort a connection instead of properly shutting it down.
The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for
an asymmetric cryptography algorithm, also known as a public-key algorithm.
The permission descriptor for the allow-env and deny-env permissions, which controls
access to being able to read and write to the process environment variables
as well as access other information about the environment. The option
variable allows scoping the permission to a specific environment
variable.
The permission descriptor for the allow-ffi and deny-ffi permissions, which controls
access to loading foreign code and interfacing with it via the
Foreign Function Interface API
available in Deno. The option path allows scoping the permission to a
specific path on the host.
Provides information about a file and is returned by
{@linkcode Deno.stat}, {@linkcode Deno.lstat}, {@linkcode Deno.statSync},
and {@linkcode Deno.lstatSync} or from calling stat() and statSync()
on an {@linkcode Deno.FsFile} instance.
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".
A WebAssembly.Global object represents a global variable instance, accessible from
both JavaScript and importable/exportable across one or more WebAssembly.Module
instances. This allows dynamic linking of multiple modules.
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.
The permission descriptor for the allow-hrtime and deny-hrtime permissions, which
controls if the runtime code has access to high resolution time. High
resolution time is considered sensitive information, because it can be used
by malicious code to gain information about the host that it might not
otherwise have access to.
The async iterable that is returned from {@linkcode Deno.serveHttp} which
yields up {@linkcode RequestEvent} events, representing individual
requests on the HTTP server connection.
A WebAssembly.Instance object is a stateful, executable instance of a WebAssembly.Module.
Instance objects contain all the Exported WebAssembly functions that allow calling into
WebAssembly code from JavaScript.
Raised when the underlying operating system reports an EINTR error. In
many cases, this underlying IO error will be handled internally within
Deno, or result in an @{link BadResource} error instead.
Options which can be set when using {@linkcode Deno.makeTempDir},
{@linkcode Deno.makeTempDirSync}, {@linkcode Deno.makeTempFile}, and
{@linkcode Deno.makeTempFileSync}.
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.
A WebAssembly.Module object contains stateless WebAssembly code that has already been compiled
by the browser â this can be efficiently shared with Workers, and instantiated multiple times.
The permission descriptor for the allow-net and deny-net permissions, which controls
access to opening network ports and connecting to remote hosts via the
network. The option host allows scoping the permission for outbound
connection to a specific host and port.
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.
Raised when the underlying operating system indicates the current user
which the Deno process is running under does not have the appropriate
permissions to a file or resource, or the user did not provide required
--allow-* flag.
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.
The permission descriptor for the allow-read and deny-read permissions, which controls
access to reading resources from the local host. The option path allows
scoping the permission to a specific path (and if the path is a directory
any sub paths).
The permission descriptor for the allow-run and deny-run permissions, which controls
access to what sub-processes can be executed by Deno. The option command
allows scoping the permission to a specific executable.
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).
The permission descriptor for the allow-sys and deny-sys permissions, which controls
access to sensitive host system information, which malicious code might
attempt to exploit. The option kind allows scoping the permission to a
specific piece of information.
The WebAssembly.Table() object is a JavaScript wrapper object â an array-like structure
representing a WebAssembly Table, which stores function references. A table created by
JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript
and WebAssembly.
Context that is passed to a testing function, which can be used to either
gain information about the current test, or register additional test
steps within the current test.
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.
The permission descriptor for the allow-write and deny-write permissions, which
controls access to writing to resources from the local host. The option
path allow scoping the permission to a specific path (and if the path is
a directory any sub paths).
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.
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.
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.
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).
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.
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.
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.
