deno.javascript.txt

                                  ┏━━━━━━━━━━┓
                                  ┃   DENO   ┃
                                  ┗━━━━━━━━━━┛

                                  ┌─────────────┐
                                  │   VERSION   │
                                  └─────────────┘

VERSION ==>                       #2.2.5 (current, LTS)

Deno.version.deno                 #'X.Y.Z' version of CLI
                                  #Also printed by deno --version

deno ... --unstable-*             #Enable specific unstable API
ENVVAR DENO_UNSTABLE_*=true      !#Means API is unstable
CONFIG.unstable                   #STR_ARR

--unstable-unsafe-proto          !#Unless set, cannot use OBJ.__proto__
--unstable-temporal              !#Allow using Temporal

globalThis                        #Like DOM: same
self                              #`window` is not available

Deno                              #Global variable for all non-standard API
DENO API ==>                      #Deno.* + DOM support
Deno[Deno.internal].*             #Internal undocumented APIs

STANDARD LIBRARY ==>              #https://deno.land/std
                                  #Version: 2025.03.04
                                  #However, each package has its own version
                                  #  - not documented here
                                  #Each version is only compatible with a specific version of Deno
                                  #Published on JSR
@std/.../unstable-...             #Common pattern for adding new features|packages to @std
                                 !#Noted like this
@std/version.ts                   #
VERSION                           #'X.Y.Z'

ENVVAR
 DENO_NO_DEPRECATION_WARNINGS=1   #Unless set, print CLI warning when using deprecated API

UPATH                             #PATH|URL
UGLOB                             #UPATH|DIR|GLOB
[U]SPATH                          #[U]PATH or - (stdin)

                                  ┌─────────────┐
                                  │   INSTALL   │
                                  └─────────────┘

GITHUB RELEASES ==>               #With only Deno CLI, zipped, for each version and architecture

https://dl.deno.land
 /release-latest.txt              #Latest 'vX.Y.Z'

https://dl.deno.land/release      #Deno binary
 /vX.Y.Z/deno-CPU-OS.zip          #OS is aarch64 (macOS only) or x86_64
                                  #OS is unknown-linux-gnu, apple-darwin or pc-windows-msvc

VERSION MANAGER ==>               #asdf + asdf-deno
                                  #Not documented yet

deno_install                      #sh|Powershell script to install Deno.
                                  #Download GitHub release then extract to DENO_INSTALL_ROOT
                                  #Can pass specific X.Y.Z version as argument (def: latest)
                                  #Available at https://deno.land/install.sh|ps1 or via
                                  #scoop|homebrew|macports|chocolatey|snap|pacman|zypper|cargo
                                  #Can verify integrity at https://raw.githubusercontent.com/denoland/deno_install/main/SHA256SUM
                                  #Version 0.3.3
--yes|-y                          #No prompt
--no-modify-path                  #Unless sets, also update shell config files:
                                  #  - for sh|bash|fish|zsh
                                  #  - source DENO_INSTALL_ROOT/env, which adds DENO_INSTALL_BIN to ENVVAR PATH
                                  #  - source /usr/local/etc/bash_completion.d/deno.bash

ENVVAR DENO_NO_UPDATE_CHECK       #Unless set, fails when a newer Deno version is available

denoland/setup-deno               #GitHub action to install Deno.
                                  #Version 2.0.2
INPUTS|OUTPUTS.deno-version       #'latest|VERSION_RANGE|canary|rc|COMMIT_HASH' (def: '2.x')
INPUTS|OUTPUTS.deno-version-file  #Same as file. Either:
                                  #  - full contents
                                  #  - one line as 'deno VERSION'
INPUTS.deno-binary-name           #'FILENAME' (def: 'deno'). Binary name once installed
OUTPUTS.release-channel           #'release|canary|rc'

deno-bin                          #Install Deno via npm
                                  #Version is same as Deno

deno upgrade [VERSION]            #Upgrade Deno CLI
                                  #VERSION (def: latest) can also be 'rc', 'canary' or 'COMMIT_HASH'
--output                          #DENO_INSTALL_ROOT
--force|-f                        #Even if not out-of-date
--dry-run                         #
--cert                            #Certificate authority PEM (def: guessed)

deno install|uninstall
--root=DIR                        #Main global Deno DIR
                                  #Only with --global
ENVVAR DENO_INSTALL_ROOT          #With deno_install, ENVVAR is DENO_INSTALL
                                  #Can be used with GitHub action
                                  #Def: ~/.deno

deno init [DIR]                   #Initialize a new project
                                  #Def DIR: .
                                  #Creates:
                                  #  - dummy main.ts, main_test.ts
                                  #  - deno.json with CONFIG.tasks.dev 'deno run --watch main.ts'
--lib                             #When creating library:
                                  #  - main[_test].ts -> mod[_test].ts
                                  #  - CONFIG.name|version|exports set
--serve                           #When creating a server
--npm                             #'PACKAGE'. Calls `npm create PACKAGE`

                                  ┌────────────┐
                                  │   CONFIG   │
                                  └────────────┘

CONFIG                            #JSON|JSONC file
                                  #Location (in priority):
                                  #  - --config
                                  #  - [.../]deno.json[c]
CONFIG_DIR                        #DIR of CONFIG

deno bench|check|compile
 |eval|fmt|info|install|lint
 |publish|repl|run|task|serve|test
--[no-]config|-c CONFIG           #

                                  ┌─────────┐
                                  │   CLI   │
                                  └─────────┘


deno bench|coverage|fmt|lint|test
--ignore=PATH,...                 #Ignore files

deno compile|eval|run|serve
--ext EXT                         #Allowed file extensions. Def: [c]js[x]|[c]ts[x]
MIME TYPES ==>                    #Are used for URIs, using well-known ones for TypeScript|JavaScript
                                  #Should use text/jsx|tsx for JSX|TSX

deno ... --quiet|-q               #
deno doc|lint --json              #Output result in JSON format
deno bench|info --json           !#Same

deno completions SHELL            #Print completion script
                                  #SHELL: bash|fish|powershell|zsh|fig

ESCAPING COMMAS ==>               #Can use double commas, in CLI flag values

                                  ┌─────────┐
                                  │   RUN   │
                                  └─────────┘

deno [run] [USPATH [ARG...]]      #Execute a JavaScript|TypeScript file
                                  #If not found, does deno task ...

deno eval 'CODE' [ARG...]         #Execute a JavaScript|TypeScript string
                                  #Implies --allow-all
--print|-p                        #Print statement result to stdout

deno [repl]                       #Run REPL
                                  #Can use import|export statements
                                  #TypeScript is transpiled, but not type checked
-- ARGS...                        #To use to set Deno.args
--eval='CODE'                     #Executes 'CODE' on start
--eval-file=UPATH,...             #Same with a file
ENVVAR DENO_REPL_HISTORY          #REPL history. Empty to disable.
                                  #Def: DENO_DIR/deno_history.txt
_                                 #Last REPL value
_error                            #Last REPL uncaught exception
clear()                           #Clear screen

DEPLOY ==>                        #See deno deploy doc

                                  ┌────────────┐
                                  │   BINARY   │
                                  └────────────┘

DENO_INSTALL_BIN                  #DENO_INSTALL_ROOT/bin
                                  #Contains deno executable
                                  #Must be in ENVVAR PATH
Deno.execPath()->'PATH'          R#PATH to deno executable

deno install UPATH [ARG...]       #Copy UPATH JavaScript|TypeScript file to DENO_INSTALL_BIN/BINARY
                                  #Flags and ARGs are kept when running executable
--global|-g                       #If not specified, behaves like `deno add` instead
--name|-n BINARY                  #BINARY filename
                                  #Def: filename from UPATH without .EXT
                                  #  - if main|mod|index|cli, use parent DIR instead
                                  #Always strip any '@TAG'
                                  #Only with --global
--force|-f                        #Do not fail if destination file already exists
                                  #Only with --global
--entrypoint                      #Performs caching (see above)
                                  #Not with --global

deno uninstall BINARY             #Uninstall a script previously installed with deno install
--global|-g                       #If not specified, behaves like `deno remove` instead

#!/usr/bin/env -S deno run [...]  #Hashbang.
                                  #Cannot use #!/path/to/deno because needs `run` argument, i.e. must use -S
                                  #Can pass additional flags|ARGs in [...]
                                  #  - must use --ext=ts if file extension is not .[c]js[x]|ts[x]
                                  #Does not work on Windows without Bash

deno compile                     !#See deno compile doc

CLI FLAGS ==>                     #See deno flags doc

                                  ┌──────────────────┐
                                  │   CODE QUALITY   │
                                  └──────────────────┘

deno lint                         #See deno lint doc
deno fmt                          #See deno fmt doc

deno doc                          #See deno doc doc

deno test                         #See deno test doc
deno bench                        #See deno bench doc

performance
PerformanceEntry
PerformanceMark
PerformanceMeasure                #Like DOM, but no PerformanceObserver, PerformanceResource|Server|NavigationTiming

                                  ┌───────────┐
                                  │   DEBUG   │
                                  └───────────┘

deno eval|install|repl|run|serve
 |test
--inspect[-brk][=HOSTNAME]        #Like Node
--inspect-wait[=HOSTNAME]         #Like --inspect-brk but breakpoint is even earlier: no user code run

deno bench|compile|eval|info
 |install|repl|run|test
--strace-ops                      #Print stack trace of OPs (also called "bindings") since process started
                                  #OPs are like syscalls but inside Deno:
                                  #  - calls from JavaScript sandbox to privileged underlying code
                                  #  - most Deno.* corresponds to an OP

deno lsp                          #Start the language server
                                  #Controls Deno through IPC, getting information meant for IDEs
                                  #Not documented yet
DENO_DIR/registries/PPATH
 /FILE_HASHID                     #Language server cache

                                  ┌──────────┐
                                  │   TASK   │
                                  └──────────┘

CONFIG.tasks.TASK                 #TASK_CONFIG[.command]
TASK_CONFIG.command               #'COMMAND'
                                  #Def: run all TASKs which name starts with current 'TASK'
                                  #Uses custom cross-OS syntax similar to Bash|Unix
                                  #  - shebang
                                  #  - || && ; ! &
                                  #  - | |& $(...)
                                  #  - < > 2> &> >> <&NUM >&NUM NUM>&NUM2
                                  #  - ** * ? [...] (file expansion)
                                  #  - $$ $? $# $*
                                  #  - export ENVVAR=VAL $ENVVAR and ENVAR=VAL COMMAND
                                  #  - VAR=VAL $VAR
                                  #  - cp mv rm mkdir pwd sleep echo cat exit unset xargs head
                                  #  - /dev/null
                                  #Prepends node_modules/.bin/ to binaries if necessary

PACKAGE.JSON SCRIPTS ==>          #Also supported. Runs pre|post* hooks

TASK_CONFIG.description           #STR printed by `deno task`
TASK_CONFIG.dependencies          #'TASK'_ARR to run first, in parallel (according to ENVVAR DENO_JOBS)

deno task                         #List TASKs
deno task TASK [ARG...]           #Run TASK
                                  #Can use globbing *

--cwd DIR                         #Def: CONFIG_DIR
ENVVAR INIT_CWD                   #Current directory without --cwd applied

--eval COMMAND                    #

                                  ┌─────────┐
                                  │   URL   │
                                  └─────────┘

FILE PATHS|URL ==>                #See deno path doc
COMMON PATH ==>                   #See deno common doc

URL
URL.createObjectURL
URL.revokeObjectURL
URLSearchParams
URLPattern                        #Like DOM

deno bench|compile|eval|info
 |install|repl|run|serve|test
--location=URL                    #Required to use globalThis.location
                                  #Also used as base URI, e.g. for fetch(), new Worker(), import() and ROOT_FILE_HASHID
                                  #Try to avoid
location                          #Like DOM but readonly
                                  #  - LOCATION.assign|replace|reload() always throw

ext:*                             #Source code from Deno core|CLI

                                  ┌────────────┐
                                  │   IMPORT   │
                                  └────────────┘

IMPORTS ==>                       #Are normal URLs, like in browsers.
VERSIONING ==>                    #As part of URL, usually @VERSION. Recommended.

import(VAR|URI)                 NR#Requires same PERMISSIONs as fetch()
                                  #Unlike import('...') or import ... 'URL'

import ... '*.json'
 assert { type: 'json' }          #Supported

import.meta.*                     #Fails on REPL
import.meta.url
import.meta.filename
import.meta.dirname
import.meta.resolve(STR)->'URL'   #Like DOM

ENVVAR
 DENO_UNSTABLE_SLOPPY_IMPORTS=1  !#Allow omitting .EXT, or use .js instead of .ts
--unstable-sloppy-imports         #Can also import DIR instead of DIR/index.EXT

Deno.mainModule                   #'URL' of first loaded file
                                  #Filename '$deno$repl.ts' if REPL
                                  #Requires read PERMISSION to its DIR
import.meta.main                  #BOOL. True if first loaded file

deno bench|check|compile|doc
 |eval|info|install|repl|run|serve
 |test                            #IMPORT_MAP_PATH. Like DOM except:
--import-map=IMPORT_MAP_PATH      #  - can import 'IURL/...', even if 'IURL' does not end with /
CONFIG.importMap                  #The resulting identifiers can be anything Deno handles, e.g. URIs, npm:*, etc.
CONFIG.imports|scopes             #Inline IMPORT_MAP.*

deps.ts                           #Convention of a top-level file which does all remote imports
                                  #then re-exports them.
                                  #Alternative to using an IMPORT_MAP that:
                                  #  - works for libraries
                                  #  - allows custom logic
dev_deps.ts                       #Same for development dependencies

mod.ts                            #Convention name for main file

deno info UPATH|jsr:PKG           #Prints dependencies tree
                                  #Including:
                                  #  - each file size, and the total
                                  #  - TypeScript transpiled file location

                                  ┌───────────────┐
                                  │   LOCK FILE   │
                                  └───────────────┘

LOCK                              #Lock file
LOCK.version                      #Always '4'
LOCK.specifiers
 ['npm|jsr:PACKAGE[@RANGE]']      #'VERSION'
LOCK.npm|jsr.PACKAGE@VERSION      #'CHECKSUM' for a given package
 .integrity                       #Ensures imports do not change
                                  #Not for file://...

deno bench|check|compile
 |doc|eval|info|install|outdated
 |repl|run|serve|test
--[no-]lock[=PATH]                #PATH, false or true (same as './deno.lock')
CONFIG.lock[.path]                #Def: true if there is a CONFIG, false otherwise
                                  #LOCK file location to read|write.
deno bench|check|compile|eval
 |install|repl|run|serve|task|test
--frozen                          #On mismatch CHECKSUM, fail
--frozen=false                    #On mismatch CHECKSUM, update it
                                  #Also, removes unused URIs
CONFIG.lock.frozen                #BOOL (def: false). Prevents --frozen=false

                                  ┌────────────┐
                                  │   REMOTE   │
                                  └────────────┘

deno bench|check|compile|doc
 |eval|info|install|repl|run|serve
 |test
--no-remote                       #Do not allow remote imports
deno bench|compile|eval|info
 |install|repl|run|serve|test
--cached-only                     #Only allow remote imports if cached

deno bench|check
 |compile|eval|info|install|repl
 |run|serve|test
--vendor
CONFIG.vendor                     #BOOL (def: false). Create VENDOR_DIR at ./vendor

VENDOR_DIR                        #Local copy of remote imports
VENDOR_DIR/import_map.json        #IMPORT_MAP to use
VENDOR_DIR/DOMAIN/PATH            #Source files

ENVVAR DENO_AUTH_TOKENS           #'STR@HOST;...' where each STR is either:
                                  #  - 'TOKEN': for Authorization: Bearer TOKEN [C]
                                  #  - 'USER:PASSWORD': for Authorization: Basic BASE64(USER:PASSWORD) [C]
                                  #HOST can be 'HOSTNAME[:PORT]', 'IPv4[:PORT]' or '[IPv6][:PORT]'
                                  #Use those headers when importing URLs from matching HOSTNAME
                                  #For GitHub:
                                  #  - TOKEN: personal access token with `repo` scope
                                  #  - HOSTNAME: raw.githubusercontent.com

REGISTRY ==>                      #Any URL works, but some registries are often used:
                                  #  - deno.land (see its doc)

                                  ┌───────────┐
                                  │   CACHE   │
                                  └───────────┘

FILE_HASHID                       #ID based on file location
                                  #If PPATH, it is just the filename instead
ROOT_FILE_HASHID                  #FILE_HASHID of the root location (in priority):
                                  #  - --location
                                  #  - --config explicit flag
                                  #  - if REPL: cwd
                                  #  - Deno.mainModule
PPATH                             #http[s]/DOMAIN or file/PATH

ENVVAR DENO_DIR                   #Set the cache directory
                                  #Def: global cache directory, e.g. ~/.cache/deno/ on Linux
                                  #In GitHub action, can be used with actions/cache and:
                                  #  - INPUTS.path ${{env.DENO_DIR}}
                                  #  - INPUTS.key ${{hashFiles('deno.lock')}}
deno info                         #Shows path of DENO_DIR[/remote|npm|gen|registries|location_data]
                                  #Also of DOM cache, which is at TMP_DIR/deno_cache
deno clean                        #Deletes DENO_DIR

DENO_DIR/remote/PPATH/            #Cache for remote imports

CACHING ==>                       #deno run|test|install|... caches remote imports used by UGLOB, recursively
                                  #Future runs of this module will trigger no downloads or compilation unless --reload is specified.

deno bench|check
 |compile|doc|eval|info|install
 |repl|run|serve|test
--reload|-r [URL,...]             #Invalidate and redownload cache.
                                  #All caches: source code, TypeScript check|transpile, etc.
                                  #Def URL: everything
                                  #URL can be just the prefix, including:
                                  #  - https://deno.land/std
                                  #  - https://deno.land/x/MODULE
                                  #  - npm:
                                  #  - npm:MODULE

deno bench|check|compile
 |eval|info|install|repl|run|test
--[no-]deno-modules-dir          !#BOOL (def: false). Create a deno_modules DIR
CONFIG.denoModulesDir             #Like DENO_DIR/remote/PPATH but only for current project

                                  ┌──────────┐
                                  │   NODE   │
                                  └──────────┘

import 'node:*'                   #Node core modules are ponyfilled
                                  #Not implemented yet:
                                  #  - important
                                  #     - CLUSTER
                                  #     - V8 except getHeapStatistics|cachedDataVersionTag()
                                  #  - less important
                                  #     - *Fips, secureHeapUsed()
                                  #     - PERFORMANCE.* that is Node.js specific
                                  #     - UDP multicast|broadcast
                                  #     - TCP file descriptors
                                  #  - not important
                                  #     - DNS.resolve*() OPTS.ttl
                                  #     - generatePrime() OPTS.safe|add|rem
--unstable-bare-node-builtins    !#Allow import '...' instead of import 'node|npm:...'
--unstable-detect-cjs            !#Support PACKAGE.type 'commonjs' in package.json
                                  #Also loads *.js[x]|ts[x] as CommonJS if no PACKAGE.type 'module'
--unstable-node-globals          !#Expose Node.js globals: global, Buffer, setImmediate(), clearImmediate()

/// <reference                    #Import Node.js core types
 types="npm:@types/node"/>        #Only needed if used in application code, not in dependencies code

DENO LIBRARY IN NODE ==>          #Node.js does not support URL imports yet
                                  #Also, most Deno libraries are in TypeScript-only, while Node.js requires those to be transpiled
                                  #I.e. a Deno library requires a build step, then publishing to npm
                                  #This is not the case for the standard library, i.e. cannot be used in Node.js

NODE TO DENO TRANSFORM ==>        #See denoify doc
DENO TO NODE TRANSFORM ==>        #See dnt and node_shims doc

                                  ┌─────────┐
                                  │   NPM   │
                                  └─────────┘

import                            #Import a npm module
 'npm:NPM_MODULE[@VERSION][/...]' #Include its dependencies, recursively
                                  #Does not work with deno compile nor --vendor
deno run npm:* [-- ARGS]          #Run a npm module binary
                                  #Works even if MODULE not installed (like npx does)
                                  #If no binary, run its programmatic entrypoint in case it has side effects

deno add|install|run|test         #Allow running package.json [pre|post]install scripts
--allow-scripts=PATH,...          #Require --node-modules-dir

deno bench|check|compile|doc
 |eval|info|install|repl|run|serve
 |test
--no-npm                          #Do not allow npm:*
ENVVAR NPM_CONFIG_REGISTRY        #Def: 'https://registry.npmjs.org'

DENO_DIR/npm/DOMAIN/NPM_MODULE/   #NPM_MODULE. Like DENO_DIR/remote, but for npm modules
NPM_MODULE/VERSION                #npm module contents
NPM_MODULE/registry.json          #OBJ with package.json, checksums and latest version tag
                                  #For each published version of NPM_MODULE, even not used one

.npmrc                            #Can be used, for _auth|_authToken only
                                  #Including in ~

                                  ┌──────────────────┐
                                  │   NODE MODULES   │
                                  └──────────────────┘

deno bench|check|compile
 |eval|info|install|repl|run|serve
 |test
--[no-]node-modules-dir           #One of:
CONFIG.nodeModulesDir             #  - 'auto'
                                  #     - creates node_modules DIR
                                  #  - 'manual'
                                  #     - use node_modules DIR if present
                                  #     - do not create|write it: `npm|yarn|pnpm install` does instead
                                  #  - 'none' (def): do not use node_modules DIR

node_modules/NPM_MODULE           #Symlink to NPM_MODULE_DIR/NPM_MODULE
node_modules/.deno
 /NPM_MODULE@VERSION/node_modules #NPM_MODULE_DIR
NPM_MODULE_DIR/NPM_MODULE         #NPM_MODULE's contents. Like DENO_DIR/npm/DOMAIN/NPM_MODULE/VERSION
NPM_MODULE_DIR/DEP_NPM_MODULE     #NPM_MODULE's dependency. Symlink to its NPM_MODULE_DIR

                                  ┌──────────────────┐
                                  │   PACKAGE.JSON   │
                                  └──────────────────┘

PACKAGE.JSON RESOLUTION ==>       #When importing bare identifiers and there is a package.json,
                                  #resolve them using its `*dependencies` configuration.
ENVVAR DENO_NO_PACKAGE_JSON       #Disables using package.json

NPM WORKSPACES ==>                #Can be used instead of CONFIG.workspace

ENVVAR
 DENO_UNSTABLE_NPM_LAZY_CACHING
--unstable-npm-lazy-caching      !#Install only dependencies used in imports, as opposed to ones referenced in package.json

                                  ┌────────────────┐
                                  │   WORKSPACES   │
                                  └────────────────┘

CONFIG.workspace[.members]        #'DIR'_ARR. Monorepo DIRs
                                  #'DIR' must start with .
                                  #Each workspace should have a deno.json CONFIG2
                                  #Current workspace changes based on cwd
                                  #Cannot be nested

import 'PKG'                      #In a monorepo package, can import siblings, using their CONFIG.name

CONFIG.*                          #Monorepo DIRs inherit from parent
                                  #They can override it, but only specific CONFIG.* ones (see online doc)

ROOT OPERATIONS ==>               #Many are done on each monorepo DIR, including deno publish

deno oudated|task
--recursive|-r                    #Run in each monorepo DIR
--filter|-f                       #Monorepo 'DIR'_ARR to run
                                  #Requires --recursive

                                  ┌────────────────┐
                                  │   TYPESCRIPT   │
                                  └────────────────┘

Deno.version.typescript           #'X.Y.Z' version of TypeScript
                                  #Also printed by deno --version

tsconfig.json                     #Can be used.
CONFIG.typescript.compilerOptions #Alternative to using tsconfig.json
TSCONFIG DEFAULTS ==>             #Uses different defaults:
                                  #  - --strict
                                  #  - --lib ['deno.window']
                                  #  - --target 'esnext' (unless --lib overridden)
                                  #  - --module 'esnext'
                                  #  - --moduleDetection 'force'
                                  #  - --esModuleInterop
                                  #  - --allowJs
                                  #  - --useUnknownInCatchVariables
                                  #  - --useDefineForClassFields
                                  #  - --noImplicitUseStrict
                                  #  - --noImplicitOverride
                                  #  - --jsx 'react'
                                  #  - --inlineSourceMap
                                  #  - --isolatedModules
TSCONFIG MISSING FLAGS ==>        #Many config flags are not used by deno, including:
                                  #  - --exactOptionalPropertyTypes
                                  #  - --noPropertyAccessFromIndexSignature
                                  #Some tsc features are also missing, and their related flags: incremental builds, emit, etc.
--lib                             #tsconfig --lib can have:
                                  #  - 'deno.js': Deno.*
                                  #  - 'deno.unstable' (def when using --unstable): Deno.* that are --unstable
                                  #  - 'deno.window' (def): DOM + 'deno.js'
                                  #  - 'deno.worker': WORKERGLOBAL.*
                                  #  - 'dom.asynciterable': DOM that uses ASYNC_ITERABLE (e.g. RSTREAM)
                                  #Incompatibilities:
                                  #  - 'deno.windows' and 'dom[.iterable]|webworker*'
                                  #  - 'deno.worker' and 'webworker*'
                                  #     - i.e. when targetting browsers, should use --lib ['dom*|webworker*', 'deno.ns', 'deno.unstable'] instead
                                  #  - 'deno.worker' and 'deno.window'
                                  #     - i.e. should only apply --lib ['deno.worker'] on WORKERs
                                  #     - usually with /// <reference no-default-lib="true"/> + /// <reference lib="deno.worker"/>

FILE EXTENSIONS ==>               #In imports, must explicitely use either *.[c]js[x] or *.[c]ts[x]

// @deno-types="*.d.ts"           #Locate the *.d.ts of a *.js import
import ... '*.js'                 #Needed because Deno does not look for sibling *.d.ts nor @types/* modules
                                  #Not needed when importing *.ts
                                  #Not applied to consumers, i.e. only meant for consuming a *.js package

/// <reference types="*.d.ts"/>   #Like `import type` except it is kept after transpiling.
                                  #I.e. meant when producing a package delivered as *.js
X-TypeScript-Types: *.d.ts [S]    #Alternative as HTTP header, when imported as URI

CONFIG.typescript
 .compilerOptions.types           #'URL'_ARR of types to import

deno bench|compile|eval
 |install|publish|repl|run|serve
 |test
--[no-]check[=STR]                #Check TypeScript types with tsc. STR can be:
                                  #  - false (def with run|eval|repl): none
                                  #  - true (def otherwise): local imports
                                  #  - remote: remote imports
                                  #  - all: local|remote imports

deno check UGLOB...               #Only check TypeScript types, do not run.
--all                             #Also check remote imports
--doc                             #Also type-check ```js[x]|ts[x] code blocks in JSDoc instead
--doc-only                        #Type-check ```js[x]|ts[x] code blocks in JSDoc|Markdown instead

DENO_DIR/check_cache_v1           #TypeScript type check cache. SQLite database

TRANSPILING ==>                   #TypeScript automatically transpiled with swc
DENO_DIR/gen/PPATH                #TypeScript transpiling cache.
DENO_DIR/gen/PPATH/FILE_HASHID.js #Transpiled file contents
DENO_DIR/gen/PPATH/FILEHASHID.meta#OBJ:
                                  #  - source_hash 'SHA': source file contents checksum
                                  #  - emit_hash 'SHA': transpiled file contents checksum

deno types                        #Print Deno's TypeScript types declarations
                                  #Automatically included when using deno

TYPESCRIPT TESTS TESTING ==>      #See deno test types doc

                                  ┌─────────┐
                                  │   JSX   │
                                  └─────────┘

CONFIG.compilerOptions.jsx.*      #Can be used
                                  #JSX is automatically transpiled

                                  ┌─────────────────┐
                                  │   PERMISSIONS   │
                                  └─────────────────┘

deno bench|compile|install|repl
 |run|serve|test
--allow-read|-R[=DIR|FILE,...]    #Allow reading|writing files
--allow-write|-W[=DIR|FILE,...]   #If DIR, recursive
                                  #Not necessary for stdin|stdout|stderr
--allow-net|-N                    #Allow opening|connecting to sockets:
 [=HOST|IP[:PORT],...]            #  - TCP|UDP: Deno.connect|listen|start*()
                                  #  - DNS: Deno.resolve*()
                                  #  - HTTP: fetch()
                                  #  - WebSocket
                                  #Not necessary with Unix sockets
--allow-import[=URL,...]          #Allow `import URL`
                                  #Always allowed: jsr.io, deno.land, esm.sh, cdn.jsdelivr.net, raw|gist.githubusercontent.com
                                  #Also always allow `deno run URL`
--allow-env|-E[=ENVVAR,...]       #Allow reading|writing ENVVARs (Deno.env)
                                  #Can use * at end
--allow-sys|-S[=FUNC,...]         #Allow access to OS information
                                  #FUNC is Deno.FUNC() among 'loadavg|hostname|systemMemoryInfo|networkInterfaces|osRelease|osUptime|uid|gid|cpus'
--allow-run=BINARY|URL,...        #Allow subprocesses (Deno.Command|kill)
                                  #Subprocesses do not inherit PERMISSIONs
--allow-ffi[=UPATH,...]          !#Allow Deno.dlopen()

--allow-all|-A                    #Allow all permissions
--deny-*                          #Inverse of --allow-*, meant to be used together with --allow-all
NOTATION ==>              RWNESUFH#Notation to mean require --allow-read|write|net|env|sys|run|ffi|hrtime
                                  #--allow-read|net often means depends if URL|PATH is used

ENVVAR DENO_NO_PROMPT
--no-prompt                       #Forbid PERMISSIONs instead of prompting

ENVVAR DENO_TRACE_PERMISSIONS=STR #'mozilla' or 'system'
                                  #Prints stack trace on PERMISSION errors

Deno.permissions                  #PERMISSIONS. Inspired by DOM, but several differences.
PERMISSIONS.query[Sync]
 (PERM_REQ)->[>]PERM_STATUS       #Get whether a permission is granted
PERMISSIONS.request[Sync]         #Same but if PERM_STATUS.state 'prompt':
 (PERM_REQ)->[>]PERM_STATUS       #  - if stdin interactive, prompt for it
                                  #  - otherwise, PERM_STATUS.state 'denied'
PERMISSIONS.revoke[Sync]
 (PERM_REQ)->[>]PERM_STATUS       #Set PERM_STATUS.state 'denied'

PERM_REQ.name                     #'read|write|net|env|sys|run|ffi|hrtime'
PERM_REQ.path                     #UPATH
                                  #Only with read|write|ffi
PERM_REQ.host                     #'HOST|IP[:PORT]'
                                  #Only with net
PERM_REQ.variable                 #'ENVVAR'
                                  #Only with env
PERM_REQ.kind                     #'FUNC'
                                  #Only with sys
PERM_REQ.command                  #'BINARY'|URL
                                  #Only with run

PERM_STATUS.state                 #One of:
                                  #  - 'granted': --allow-* used, or request() accepted
                                  #  - 'prompt': --allow-* not used, and no request() yet
                                  #  - 'denied': --allow-* not used, and request() denied
PERM_STATUS.onchange
 = FUNC(EVENT)                    #When PERM_STATUS.state changes

Deno.errors.NotCapable            #PERMISSIONs error
Deno.errors.PermissionDenied      #Unauthorized, e.g. OS file permissions, etc.

                                  ┌────────┐
                                  │   V8   │
                                  └────────┘

Deno.version.v8                   #'X.Y.Z.BUILD' version of v8
                                  #Also printed by deno --version

ENVVAR DENO_V8_FLAGS
--v8-flags[='--FLAG ...']         #
--no-code-cache                   #Disallow V8 code caching

deno bench|compile|eval|info
 |install|repl|run|serve|test
--seed=NUM                        #Random number generator seed

                                  ┌───────────┐
                                  │   ASYNC   │
                                  └───────────┘

TIMEOUT ==>                       #See deno delay doc
ABORT ==>                         #See deno abort doc
DEBOUNCE ==>                      #See deno debounce doc
THROTTLE ==>                      #See deno throttle doc
RETRY ==>                         #See deno retry doc
ASYNC MAP ==>                     #See deno pooledMap doc
ASYNC SPLIT ==>                   #See deno tee doc
ASYNC MERGE ==>                   #See deno muxAsyncIterator doc

CRON ==>                          #See deno cron doc

ReadableStream
ReadableStreamDefaultReader
ReadableStreamByobReader
WritableStream
WritableStreamDefaultWriter
TransformStream
ByteLengthQueuingStrategy
CountQueuingStrategy              #Like DOM

EventTarget
Event
CustomEvent
DOMException
ErrorEvent
ProgressEvent                     #Like DOM, but no: OPTS.capture

Deno.errors.WouldBlock            #Syscall is sync, although should be async
Deno.errors.Interrupted           #Syscall interrupted (EINTR)

                                  ┌────────────────┐
                                  │   FUNCTIONAL   │
                                  └────────────────┘

FILTER OBJECTS ==>                #See deno filter doc
FILTER OBJECT PROPERTIES ==>      #See deno omit_pick doc
MAP OBJECTS ==>                   #See deno map doc
FIND OBJECT VALUE ==>             #See deno find doc
DEEP MERGE ==>                    #See deno deep merge doc

ARRAY TAKE|DROP ==>               #See deno take_drop doc
ARRAY REDUCE ==>                  #See deno reduce doc
ARRAY ZIP ==>                     #See deno zip doc
ARRAY GROUP BY ==>                #See deno group doc
ARRAY SORT|MIN|MAX ==>            #See deno sort_min_max doc
ARRAY SUM ==>                     #See deno sum doc
ARRAY PARTITION ==>               #See deno partition doc
ARRAY PERMUTATION ==>             #See deno permutation doc
ARRAY FIND UNIQUE ==>             #See deno find doc
ARRAY FIND NON-NULLISH ==>        #See deno find doc
ARRAY MAP NON-NULLISH ==>         #See deno map_non_nullish doc

SET OPERATION ==>                 #See deno set_operation doc
UNIQUE ARRAY ITEMS ==>            #See deno distinct doc

JOIN TO STRING ==>                #See deno join_to_string doc

                                  ┌─────────────┐
                                  │   CONSOLE   │
                                  └─────────────┘

console                           #Like DOM

Deno.std*.isTerminal()->BOOL
FILE.isTerminal()->BOOL           #True if TTY
Deno.consoleSize()->OBJ           #Returns OBJ: columns|row NUM
                                  #Throws if not a TTY

Deno.stdin.setRaw(BOOL[, OPTS])   #When false (def):
FILE.setRaw(...)                  #  - echoes input to output
                                  #  - buffer input until next newline (i.e. line-wise input instead of character-wise)
                                  #  - buffered input can be removed with Backspace|Delete
                                  #  - can quit with CTRL-D
                                  #  - emit sounds (bell)
                                  #  - normalize any non-ASCII to ASCII (by removing MSB)
                                  #  - '\r\n' -> '\n'
                                  #When false or OPTS.cbreak true (def: false):
                                  #  - can quit with CTRL-C, CTRL-Z (not on Windows)
                                  #In any case:
                                  #  - no readline|Emacs keybindings (CTRL-A, etc.)
                                  #  - cannot move cursor (Left|Right|Home|End)

alert
confirm
prompt                            #See deno prompt doc

HAS COLOR ==>                     #See deno color_enabled doc
STRIP COLOR ==>                   #See deno strip_color doc
SET COLOR ==>                     #See deno set_colors doc

LOGGING ==>                       #See deno log doc
SPINNER ==>                       #See deno spinner doc
PROGRESS BAR ==>                  #See deno progress bar doc

                                  ┌───────────────────┐
                                  │   SERIALIZATION   │
                                  └───────────────────┘

Deno.inspect                      #See deno inspect doc

PRINTF ==>                        #See deno printf doc
HUMAN DURATION ==>                #See deno fmt_duration doc
HUMAN FILE SIZE ==>               #See deno bytes doc

BASE64/HEX ==>                    #See base64_58_32_85_hex doc
JSON SEQUENCES ==>                #See deno JSON sequence doc
JSONC ==>                         #See deno JSONC doc
YAML ==>                          #See deno YAML doc
INI ==>                           #See deno INI doc
MSGPACK ==>                       #Not documented yet
CBOR ==>                          #Not documented yet

ImageData
ImageBitmap                       #Like DOM

                                  ┌────────────┐
                                  │   STRING   │
                                  └────────────┘

HTML ESCAPING ==>                 #See deno escape doc
REGEXP ESCAPING ==>               #See deno regexp escape doc

REVERSE ==>                       #See deno reverse doc
CASE ==>                          #See deno case doc
SLUGIFY ==>                       #See deno slugify doc
LEVENSHTEIN ==>                   #See deno levenshtein doc

SEMVER ==>                        #See deno semver doc

                                  ┌───────────────┐
                                  │   DATE TIME   │
                                  └───────────────┘

DATE/TIME ==>                     #See deno datetime doc

                                  ┌─────────┐
                                  │   CPU   │
                                  └─────────┘

navigator.hardwareConcurrency     #Like DOM. NUM

Deno.osUptime()->NUM             S#NUM of secs OS has been up
Deno.loadavg()->NUM_ARR          S#1|5|15m load average
                                  #On Windows, always [0,0,0]
Deno.cpuUsage()->OBJ             S#OBJ: user|system NUM (time usage, in microseconds)

navigator.gpu.*
GPU ==>                           #Not documented yet

                                  ┌────────────┐
                                  │   MEMORY   │
                                  └────────────┘

Deno.memoryUsage()->MEMORY_USAGE  #Process memory
MEMORY_USAGE.rss                  #NUM (in bytes). Total memory used
MEMORY_USAGE.heapTotal            #NUM (in bytes). Heap memory available
MEMORY_USAGE.heapUsed             #NUM (in bytes). Heap memory used
MEMORY_USAGE.external             #NUM (in bytes). External memory used

Deno.systemMemoryInfo()
 ->SYS_MEMORY                    S#System-wide memory
SYS_MEMORY.total                  #Total RAM
SYS_MEMORY.free                   #RAM available
SYS_MEMORY.swapTotal|swapFree     #Same for swap memory
SYS_MEMORY.buffers                #Memory used by OS buffers
SYS_MEMORY.cached                 #Memory used by page cache and slabs
SYS_MEMORY.available              #Memory that can be used to start processes without swapping

                                  ┌─────────────┐
                                  │   PROCESS   │
                                  └─────────────┘

Deno.pid                          #NUM. Process ID
Deno.ppid                         #NUM. Parent process ID
Deno.uid|gid()->NUM|null         S#Process UID|GID. null on Windows

Deno.chdir(UPATH)                R#Change cwd
Deno.cwd()->'PATH'                #Can throw NotFound

Deno.env                         E#ENV
ENV.get('ENVVAR')[->'VAL']        #
ENV.has('ENVVAR')->BOOL           #True even if empty ''
ENV.set('ENVVAR', 'VAL')          #
ENV.delete('ENVVAR')              #
ENV.toObject()->OBJ               #

DOTENV ==>                        #See deno dotenv doc

Deno.stdin                        #Inherits CLOSER|READER[_SYNC]. Current process stdin.
Deno.stdin.readable               #RSTREAM

Deno.stdout|stderr                #Inherits CLOSER|WRITER[_SYNC]. Current process stdout.
Deno.stdout|stderr.writable       #WSTREAM

OS ==>                            #See deno OS doc

                                  ┌──────────┐
                                  │   EXIT   │
                                  └──────────┘

Deno.exit([NUM])                  #Def NUM: 0. Process exit
close()                           #Similar to DOM. Like Deno.exit(0) except closed is true
closed                            #Similar to DOM. true if close() was called and inside unload
Deno.exitCode                     #NUM. Like Node.js

globalThis.add|removeEventListener
globalThis.dispatchEvent          #Similar to DOM
onload = FUNC(EVENT)              #Similar to DOM. On end of initial macrotask (not microtask)

onbeforeunload = FUNC(EVENT)      #Similar to DOM. On implicit process exit, i.e. due to no more macrotasks.
                                  #Can preventDefault, which waits for new microtasks, then calls beforeunload again.
                                  #Can run new microtasks, if preventDefault.
onunload = FUNC(EVENT)            #Similar to DOM. On explicit non-error process exit, e.g. Deno.exit()
                                  #Cannot preventDefault nor run new microtasks.

globalThis|WORKERGLOBAL.onerror   #Similar to DOM. On process exit due to uncaught exceptions.
 = FUNC(ERROREVENT)               #Top-level scope|macrotask is considered async (to support top-level await),
                                  #i.e. only applies to other sync macrotasks.
                                  #Can preventDefault. Can run new microtasks, if preventDefault.
Deno.errors.NAME                  #Deno known error classes
Deno.errors.NotSupported          #API not implemented yet

onunhandledrejection              #Similar to DOM. On process exit due to unhandled promises.
 = FUNC(PROMREJEVENT)             #Can preventDefault. Can run new microtasks, if preventDefault.
reportError(VAL)                  #Like DOM

                                  ┌────────────┐
                                  │   SIGNAL   │
                                  └────────────┘

SIGNAL                            #'SIG*'. OS-dependent.
                                  #On Windows, only 'SIGINT|SIGBREAK' supported
Deno.add|removeSignalListener
 (SIGNAL, FUNC())                 #

Deno.kill(PID_NUM[, SIGNAL])     U#Send SIGNAL (def: 'SIGTERM') to a process
                                  #If PID_NUM negative, send to progress group instead
                                  #  - throws on Windows
CHILD_PROCESS.kill([SIGNAL])      #Send SIGNAL (def: 'SIGTERM') to CHILD_PROCESS
CHILD_PROCESS
 [Symbol.asyncDispose()]()->>     #.kill() + awaits exit

                                  ┌───────────────────┐
                                  │   CHILD PROCESS   │
                                  └───────────────────┘

CHILD PROCESSES ==>>              #See deno command doc

new Worker('URL'|URL[, OPTS])     #Like DOM, but:
                                  #  - 'URL' requires --location
                                  #  - no OPTS.credentials
                                NR#Requires same PERMISSIONs as fetch()
OPTS.type                         #Must be 'module'
--unstable-worker-options        !#Like PERMISSIONS.request(). Either:
OPTS.deno.permissions             #  - OBJ:
                                  #     - key is read|write|...
                                  #     - value is one of:
                                  #        - STR_ARR|BOOL: depending on PERMISSION type
                                  #        - 'inherit': same as process
                                  #  - 'inherit' (def)
                                  #  - 'none'

MessageChannel
MessagePort
MessageEvent                      #Like DOM
BroadcastChannel
--unstable-broadcast-channel     !#Like DOM

structuredClone(VAL[, OPTS])->VAL #Like DOM

                                  ┌────────────────┐
                                  │   IDENTIFIER   │
                                  └────────────────┘

ULID ==>                          #See deno ulid doc

                                  ┌────────────────────┐
                                  │   DATA STRUCTURE   │
                                  └────────────────────┘

BIDIRECTIONAL MAP ==>             #See deno bidirectional map doc

BINARY SEARCH TREE ==>            #See deno red black tree doc
BINARY HEAP ==>                   #See deno binary heap doc

                                  ┌──────────────┐
                                  │   CONTENTS   │
                                  └──────────────┘

BINARY ==>                        #See deno binary doc
I/O ==>                           #See deno io doc

NEWLINE FORMAT ==>                #See deno format newline doc
NEWLINE DETECTION ==>             #See deno detect newline doc

                                  ┌───────────┐
                                  │   FILES   │
                                  └───────────┘

FILE OPEN|CLOSE|SYNC ==>          #See deno open doc
FILE ENSURE|CREATE ==>            #See deno ensure doc
FILE DELETE ==>                   #See deno remove doc
FILE TRUNCATE ==>                 #See deno truncate doc

FILE EXISTENCE ==>                #See deno exists doc
FILE METADATA ==>                 #See deno stat doc

FILE MOVE ==>                     #See deno rename doc
FILE COPY ==>                     #See deno copy doc
FILE TEMPORARY ==>                #See deno temp doc

SYMLINK READ ==>                  #See deno readlink doc
SYMLINK CREATE ==>                #See deno symlink doc
HARD LINKS ==>                    #See deno link doc

FILE LOCK ==>                     #See deno flock doc
WATCH ==>                         #See deno watch doc

FILE READ ==>                     #See deno file_read doc
FILE WRITE ==>                    #See deno file_write doc

                                  ┌─────────────────┐
                                  │   DIRECTORIES   │
                                  └─────────────────┘

DIRECTORY CREATE ==>              #See deno mkdir doc
DIRECTORY LIST ==>                #See deno readdir doc
DIRECTORY WALK ==>                #See deno walk doc

GLOBBING MATCH ==>                #See deno glob doc
GLOBBING CHECK ==>                #See deno isglob doc
GLOBBING LIST ==>                 #See deno expand_glob doc

                                  ┌────────────┐
                                  │   STREAM   │
                                  └────────────┘

RSTREAM|WSTREAM|TSTREAM           #Like DOM

STREAMS CREATE ==>                #See deno_streams_create doc
STREAMS MAP ==>                   #See deno_stream_map doc
STREAMS SLICE ==>                 #See deno_stream_slice doc
STREAMS SPLIT ==>                 #See deno_stream_split doc
STREAMS COMBINE ==>               #See deno_stream_combine doc

                                  ┌───────────┐
                                  │   STORE   │
                                  └───────────┘

KEY-VALUE STORE ==>               #See deno kv doc

localStorage                      #Like DOM.
sessionStorage                    #Unique per ROOT_FILE_HASHID
                                  #Stores in DENO_DIR/ROOT_FILE_HASHID/local_storage, as SQLite database
                                  #Max 10MB

                                  ┌─────────────┐
                                  │   NETWORK   │
                                  └─────────────┘

TCP ==>                           #See deno tcp doc
TLS ==>                           #See deno tls doc
UDP ==>                           #See deno udp doc
DNS ==>                           #See deno dns doc
QUIC ==>                          #See deno quic doc
WEBSOCKET ==>                     #See deno websocket doc
SERVER-SENT EVENTS ==>            #See deno server-sent events doc

Deno.hostname()->STR             S#System hostname

Deno.networkInterfaces()
 ->NETWORK_INTERFACE_ARR         S#
NETWORK_INTERFACE.name            #STR, e.g. 'lo', 'wlp113s0', etc.
NETWORK_INTERFACE.family          #'IPv4|6'
NETWORK_INTERFACE.address         #'IP'
NETWORK_INTERFACE.netmask         #STR
NETWORK_INTERFACE.scopeid         #NUM or (if IPv4) null
NETWORK_INTERFACE.cidr            #'IP/NUM'
NETWORK_INTERFACE.mac             #STR. MAC address

@std/net/
 unstable-get-network-address    !#
getNetworkAddress
 (['IPv4|6'])->'IP'              S#Def: 'IPv4'

@std/net/get-available-port
getAvailablePort([OPTS])->PORT_NUM#
OPTS.preferredPort                #PORT_NUM. Try that port first. If already in use, get any available instead

Deno.errors.AddrInUse             #Start server on address|port already used
Deno.errors.AddrNotAvailable      #Start server on address|port that does not exist (EADDRNOTAVAIL)

Deno.errors.NotConnected          #Socket connection ended or never started (ENOTCONN)
Deno.errors.ConnectionAborted     #Socket connection aborted (ECONNABORTED)
Deno.errors.ConnectionReset       #Socket connection reset
Deno.errors.ConnectionRefused     #Socket connection refused
Deno.errors.NetworkUnreachable    #Cannot reach server

                                  ┌──────────┐
                                  │   HTTP   │
                                  └──────────┘

XHR                               #Not provided by Deno

fetch(...)                        #Like DOM except:
                                  #  - file: URIs supported, but only if absolute or with --location
                                  #  - no cookies
                                  #  - no concept of origins (CORS, REQ.mode, RES.type 'opaqueredirect', etc.)
                                  #  - no REQ.keepalive
                                  #  - no REQ.credentials
                                  #  - no REQ.cache
                                  #  - no REQ.referrer[Policy]
                                  #  - no REQ.integrity
                                  #  - no REQ.window
                                  #Requires PERMISSIONs:
                                 R#  - file URL
                                 N#  - remote URL
Request
Response
Headers
FormData                          #Like DOM

navigator.userAgent               #Like DOM. 'Deno/X.Y.Z'

caches                            #Like DOM, but no:
CacheStorage                      #  - add[All]|matchAll|keys()
Cache                             #  - CACHE_STORAGE.match()
                                  #  - OPTS with match|delete()

WebTransport                     !#Like DOM

REQQ.client                       #HTTP_CLIENT
Deno.createHttpClient([HCOPTS])
 ->HTTP_CLIENT                    #Customize HTTP request option
HTTP_CLIENT                       #
HTTP_CLIENT.close()
HTTP_CLIENT[Symbol.dispose]()     #

HCOPTS.http1|http2                #BOOL (def: true)
HCOPTS.allowHost                  #BOOL (def: false). Allow passing Host [C]
HCOPTS.poolMaxIdlePerHost         #NUM. Max sockets to pool
HCOPTS.poolIdleTimeout            #NUM|false. How long to keep sockets in pool

ENVVAR HTTP_PROXY
ENVVAR HTTP[S]_PROXY
ENVVAR NO_PROXY                   #Can be used. For all HTTP requests, including imports
HCOPTS.proxy                      #HTTP_PROXY
HTTP_PROXY.url                    #'URL'
HTTP_PROXY.basicAuth
 .username|password               #STR

Deno.errors.Http                  #Too many HTTP redirects

deno serve
HTTP SERVER ==>                   #See deno http doc
HTTP FILE SERVER ==>              #See deno file server doc
HTTP STATUS ==>                   #See deno http_status doc
HTTP METHODS ==>                  #See deno http_methods doc
HTTP HEADERS ==>                  #See deno http_headers doc
HTTP ERRORS ==>                   #See deno http_errors doc
HTTP COOKIES ==>                  #See deno cookies doc
HTTP COOKIES SIGN ==>             #See deno cookie sign doc
HTTP NEGOTIATION ==>              #See deno http_negotiation doc
HTTP ETAG ==>                     #See deno etag doc
HTTP USER AGENT ==>               #See deno user agent doc

OAUTH ==>                         #deno_kv_oauth, which works with Deno.Kv
                                  #Not documented yet

                                  ┌─────────────────┐
                                  │   PERFORMANCE   │
                                  └─────────────────┘


LRU CACHE ==>                     #See deno LRU cache doc
MEMOIZE ==>                       #See deno memoize doc

--unstable-otel                  !#Adds OpenTelemetry metrics/tracing
                                  #Not documented yet

                                  ┌────────────────────────┐
                                  │   CRYPTO/COMPRESSION   │
                                  └────────────────────────┘

CompressionStream
DecompressionStream               #Like DOM

WEB CRYPTO API ==>                #Like DOM
@std/crypto                       #Adds:
                                  #  - key rotation
                                  #  - additional hash algorithms
                                  #Not documented yet

VARINT ==>                        #See deno varint doc
TAR ==>                           #See deno tar doc

                                  ┌────────────┐
                                  │   RANDOM   │
                                  └────────────┘

INTERVAL RANDOMNESS ==>           #See deno interval random doc
PGC32 ==>                         #See deno PGC32 doc (seeded random)

UUID ==>                          #See deno uuid doc

SHUFFLE ==>                       #See deno shuffle doc
RANDOM SAMPLE ==>                 #See deno shuffle doc

                                  ┌─────────────────┐
                                  │   WEBASSEMBLY   │
                                  └─────────────────┘

WebAssembly                       #Like DOM, but no: externref, Tag(), Exception()

wasmbuild                         #Helper to use WASM written in Rust in Deno
                                  #Not documented yet

import ... from '*.wasm'          #

                                  ┌─────────┐
                                  │   FFI   │
                                  └─────────┘

Deno.dlopen(UPATH, FLIBRARY)     F#Opens a C library.
 ->FDLIB                          #Must be *.so (Linux), *.dylib (macOS), *.dll (Windows)
FLIBRARY.NAME                     #FSTATIC or FFUNCTION. Exported symbol in C library
                                  #NAME is the one used in FDLIB.symbols.NAME

FSTATIC|FFUNCTION.name            #'NAME' (def: 'NAME') used in C library
FSTATIC|FFUNCTION.optional        #BOOL (def: false)
                                  #Whether value might be null. Otherwise, fails if not found

FSTATIC                           #Non-FUNC value
FSTATIC.type                      #FNTYPE

FFUNCTION                         #FUNC value
FFUNCTION.parameters              #FNTYPE_ARR of arguments
FFUNCTION.result                  #FNTYPE
FFUNCTION.nonblocking             #BOOL (def: false)
                                  #Whether async

FDLIB                             #Inherits CLOSER
                                  #Ref'd by the process
FDLIB.symbols.NAME                #One of:
                                  #  - NUM|BIGINT|BOOL|DPOINTER: for FSTATIC
                                  #  - (...)->[>]...: for FFUNCTION
                                  #  - null: only if optional

FNTYPE                            #One of:
                                  #  - 'u|i8|16|32' -> NUM
                                  #  - 'u|i64' -> BIGINT
                                  #  - 'f32|64' -> NUM
                                  #  - 'u|isize' -> NUM
                                  #  - 'bool' -> BOOL
                                  #  - 'pointer' -> FPOINTER
                                  #  - 'buffer' -> FPOINTER
                                  #  - 'function' -> FPOINTER
                                  #  - { struct FNTYPE_ARR } -> UINT8ARR

FPOINTER                          #Opaque OBJ representing a memory address
                                  #Underlying type is either:
                                  #  - 32 bits: NUM
                                  #  - 64 bits: NUM if <Number.MAX_SAFE_INTEGER, BIGNUM otherwise
Deno.UnsafePointer.create
 (NUM|BIGINT)->FPOINTER           #
Deno.UnsafePointer.value
 (FPOINTER)->NUM|BIGINT           #
Deno.UnsafePointer.equals
 (FPOINTER, FPOINTER2)->BOOL      #
Deno.UnsafePointer.offset
 (FPOINTER, NUM)->FPOINTER2       #
Deno.UnsafePointer.of(...)
Deno.UnsafeCallback.*
Deno.UnsafeFnPointer.*
Deno.UnsafePointerView.*          #FNPOINTER manipulation. Not documented yet

DENOSAURS PLUG ==>                #FFI helper module
                                  #Not documented yet
DENO_BINGEN ==>                   #Library helping with FFI written in Rust
                                  #Not documented yet
DENO_PYTHON ==>                   #Library helping with FFI written in Python
                                  #Not documented yet