nodejs.javascript.txt

                                  ┏━━━━━━━━━━━━┓
                                  ┃   NODEJS   ┃
                                  ┗━━━━━━━━━━━━┛

Todo:
  - document CRYPTO: Cryto|crypto|CryptoKey|SubtleCrypto global, generateKey[Sync](), CryptoKey, util.types.*key,
    getCipherInfo(), hkdf[Sync](), webcrypto, X509Certificate, NodeEdKey*, subtle, fingerprint512, --no-experimental-global-webcrypto
  - document http/2
  - document quic (including NET.createQuicSocket())

                                  ┌──────────────────┐
                                  │   COMMAND LINE   │
                                  └──────────────────┘

PURPOSE ==>                                     #Execute JavaScript code server-side
                                                #Based on Chrome JavaScript engine V8

VERSION ==>                                     #23.10.0 (current), 22.14.0 (active LTS), 20.19.0 (maintenance LTS), 18.20.7 (maintenance LTS)
                                                #Branches:
                                                #  - "current": latest major version. New one every 0.5 years
                                                #  - LTS: every even-numbered version
                                                #     - when not current anymore, becomes "active LTS" (only bug fixes) for 1.5 years
                                                #     - then "maintainance LTS" (only critical bug fixes) for 1 more year
                                                #  - non-LTS also have a maintainance period of 0.5 years
                                                #Features are often backported.
                                            NUM*#Means introduced by NUM.*.*

ES6 ==>                                         #Support is documented in JavaScript doc

node[js] [--] [FILE] [FILE_ARGS]                #Command-line

--entry-url                             22.10.0*#Parse FILE as a URI instead, one of:
                                        22.10.0*#  - relative URI, e.g. 'FILENAME'
                                        22.10.0*#  - 'file:///...'
                                        22.10.0*#  - 'data:text/javascript,JAVASCRIPT'

node[js] -e|--eval|-p|--print STR [--] [ARGS]   #nodejs is symlink to node (prefer the later as this is what nvm uses).
                                                #FILE is JavaScript file (def: stdin). Can be - too
                                                #With -e, evaluates STR
                                                #With -p, evaluates STR, and prints last return value.
                                                #  - cannot be used with --input-type=module
                                                #All CLI flags can use underscores instead of dashes

--run TASK [[--] ARGS]                   22.0.0*#Run PACKAGE.scripts.TASK [ARGS]
                                         22.0.0*#Looks into ./node_modules/.bin/
                                         22.3.0*#Also looks into .../node_modules/.bin/, and updates ENVVAR PATH
                                         22.0.0*#If TASK is missing, list available ones
                                         22.0.0*#Run within a shell (sh on Unix, cmd.exe on Windows). Single-quote ARGS
ENVVAR NODE_RUN_SCRIPT_NAME              22.3.0*#'TASK', during --run
ENVVAR NODE_RUN_PACKAGE_JSON_PATH        22.3.0*#'PATH' to package.json, during --run

-i
--interactive                                   #Enters REPL even if stdin does not come from a terminal
-c
--check                                         #Run-dry (syntax check)

--watch                                         #Restart process on file changes (including imported files)
--watch-path                                    #Changes which files are watched. Only Windows|macOS
--watch-preserve-output                 18.13.0*#Do not clear screen when --watch restarts process

--completion-bash                               #Output Bash completion script (for CLI flags)

#!/usr/bin/env node                             #Shabang to execute a Node file directly with ./FILE

npm                                             #Node packet manager (see doc)
corepack                                        #Packet manager's manager

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

NODE_OPTIONS=--OPT,... ENVVAR                   #Same as using node --OPT ...
--v8-options                                    #Prints available v8 options.
process.allowedNodeEnvironmentFlags             #Read-only SET with all available NODE_OPTIONS

--experimental-config-file=PATH.json    23.10.0*#PATH to CONF
CONF.schema                             23.10.0*#Must be set to 'https://nodejs.org/dist/vX.Y.Z/docs/node-config-schema.json'
CONF.nodeOptions.OPT                    23.10.0*#VAL. Sets CLI flag

--experimental-default-config-file      23.10.0*#Look for ./node.config.json

                                  ┌────────────┐
                                  │   TIMERS   │
                                  └────────────┘

clear|setTimeout|Interval(...)                  #Like DOM ones (see DOM doc), but extra members
clear|setImmediate(...)                         #Unlike DOM, error if INT > 2 ** 31 - 1 (25 days)
                                                #ID is not returned when using util.promisify()
ID.[un]ref()->ID                                #Yield the macrotask (see JavaScript doc)
ID.hasRef()->BOOL                               #
ID.refresh()->ID                                #Reset the counter
ID[Symbol.toPrimitive]()->ID_NUM                #
ID_NUM                                          #Can be passed to clear*(...)
ID[Symbol.dispose]()                    18.18.0*#Calls clear*(...)

queueMicrotask(FUNC())                          #Add a new microtask (see DOM|JavaScript doc)
process.nextTick(FUNC()[, ...])                 #Add a new microtask (see JavaScript doc)
                                                #As opposed to queueMicrotask(), always processed before other microtasks,
                                                #including when calling itself recursively.
                                                #Prefer queueMicrotask()

require('timers/promises')                      #
TIMERS.promises                         20.12.0*#
setTimeout(NUM[, VAL[, OPTS]])->>               #Resolves to VAL (def: undefined) after NUMms.
setImmediate([VAL[, OPTS]])->>                  #OPTS:
                                                #  - ref BOOL (def: true): yield macrotask
                                                #  - signal ABORT_SIGNAL: call clear* on cancel, and throws
                                                #Those OPTS are available to promisify(setTimeout|setImmediate) too
setInterval(NUM[, VAL[, OPTS]])                 #Same but for setInterval()
 ->ASYNC_ITERATOR                               #ASYNC_ITERATOR is resolving to VAL each time
scheduler.wait(NUM[, OPTS])->>                  #Like DOM. No OPTS.ref
scheduler.yield()->PROMISE                      #Like DOM.

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

TASK_ID                                         #Microtask ID
                                                #Is incrementing counter, with top-level microtask having ID 1
                                                #Specifics:
                                                #  - ID 0 means executed from C++, not JavaScript
                                                #  - PROMISE report parent microtask's, not their actual microtask ID, unless
                                                #    an enabled HOOK exists
                                                #  - async|await (but PROMISE) report parent microtask's, not their actual microtask ID
RESOURCE                                        #Any resource, firing 0, 1 or several microtasks (depends on RESOURCE_TYPE)
                                                #RESOURCE properties depend on RESOURCE_TYPE. They might not be populated yet in init()
RESOURCE_TYPE                                   #Can be:
                                                #  - TickObject: process.nextTick()
                                                #     - properties: callback FUNC, [args 'VAL'_ARR]
                                                #  - Immediate: setImmediate()
                                                #     - properties: _onImmediate FUNC, [_argv 'VAL'_ARR]
                                                #  - Timeout: setTimeout|setInterval()
                                                #     - properties:
                                                #        - _onTimeout FUNC
                                                #        - _idleTimeout NUM
                                                #        - _repeat null|NUM: same but null with setTimeout()
                                                #        - [_timerArgs 'VAL'_ARR]
                                                #  - TIMERWRAP: setTimeout|setInterval()
                                                #  - PROMISE:
                                                #     - on:
                                                #        - new Promise(FUNC), Promise.resolve|reject()
                                                #        - PROMISE.then|catch|finally(FUNC), await PROMISE
                                                #        - calling an async FUNC
                                                #  - TTYWRAP: console.*
                                                #     - properties: callback FUNC, [args 'VAL'_ARR]
                                                #  - SIGNALWRAP: OS signal
                                                #  - FSEVENTWRAP, FSREQWRAP, GETADDRINFOREQWRAP, GETNAMEINFOREQWRAP, HTTPPARSER,
                                                #    JSSTREAM, PIPECONNECTWRAP, PIPEWRAP, PROCESSWRAP, QUERYWRAP, SHUTDOWNWRAP,
                                                #    STATWATCHER, TCPCONNECTWRAP, TCPSERVER, TCPWRAP, UDPSENDWRAP, UDPWRAP,
                                                #    WRITEWRAP, ZLIB, SSLCONNECTION, PBKDF2REQUEST, RANDOMBYTESREQUEST, TLSWRAP: others

executionAsyncId()->TASK_ID                     #Current microtask
triggerAsyncId()->PARENT_TASK_ID                #Parent microtask, i.e. caller
executionAsyncResource()->RESOURCE              #Current microtask's RESOURCE

process.getActiveResourcesInfo()
 ->RESOURCE_TYPE_ARR                            #Return all current RESOURCEs

createHook(OPTS)->HOOK                          #Fires callbacks on new microtasks|resources, using OPTS:
                                                #  - init(TASK_ID, RESOURCE_TYPE, PARENT_TASK_ID, RESOURCE):
                                                #     - when RESOURCE is initialized.
                                                #  - before|after(TASK_ID):
                                                #     - before|after each microtask starts|ends
                                                #     - since some RESOURCE create no microtasks, or several,
                                                #       this might not be called, or be called several times
                                                #  - destroy(TASK_ID): when RESOURCE is destroyed
                                                #  - promiseResolve(TASK_ID):
                                                #     - when a PROMISE is resolved|rejected, including to another PROMISE2
                                                #     - only for RESOURCE_TYPE PROMISE
                                                #Exceptions thrown in callbacks are uncaught exceptions, but cannot be handled.
                                                #Doing async operations (i.e. creating microtasks) inside callbacks:
                                                #  - can cause infinite recursion
                                                #  - this includes console.*(), which can be replaced e.g. by
                                                #    fs.writeSync(1, util.format(VAL))
HOOK.enable|disable()->HOOK                     #HOOK callbacks will only be fired in enabled (disabled by def)

new AsyncResource('RESOURCE_TYPE'[, OPTS])      #Custom RESOURCE
                                                #OPTS:
                                                #  - triggerAsyncId PARENT_TASK_ID (def: executionAsyncId())
                                                #  - requireManualDestroy BOOL: if false (def), calls emitDestroy() when object
                                                #    is garbage collected
ASYNCRESOURCE.runInAsyncScope
 (FUNC[, THIS][, ...ARGS])                      #This is automatically create a new TASK_ID and call 'before|after' events
ASYNCRESOURCE.bind(FUNC[, THIS])->FUNC2         #Like ASYNCRESOURCE.runInAsyncScope.bind(FUNC)
AsyncResource.bind
 (FUNC[, 'RESOURCE_TYPE'][, THIS])              #Like (new AsyncResource('RESOURCE_TYPE')).bind(FUNC)
 ->FUNC2                                        #Def 'RESOURCE_TYPE': 'bound-anonymous-fn'
ASYNCRESOURCE.emitDestroy()                     #
ASYNCRESOURCE.asyncId()->TASK_ID                #
ASYNCRESOURCE.triggerId()->PARENT_TASK_ID       #

new EventEmitterAsyncResource(OPTS)             #EVENTEMITTER wrapper around ASYNC_RESOURCE
                                                #OPTS:
                                                #  - name 'RESOURCE_TYPE', triggerAsyncId, requireManualDestroy: passed to new AsyncResource()
                                                #  - captureRejections BOOL: passed to new EventEmitter()
EVENTEMITTER_ASYNC_RESOURCE
 .asyncResource                                 #ASYNC_RESOURCE
EVENTEMITTER_ASYNC_RESOURCE
 .emitDestroy|asyncId|triggerAsyncId            #Same as ASYNC_RESOURCE.*

--no-force-async-hooks-checks                   #Do not do extra runtime checks related to async hooks

new AsyncLocalStorage([OPTS])                   #Create STOREs, i.e. objects available inside a specific function and its closures (including async)
ASYNC_LOCAL_STORAGE.run(STORE, FUNC())          #Creates a STORE that only exists within the current async context.
                                                #An async context is the current function and its closures including async ones (promise or callback).
                                                #Creates a new async context
                                                #STORE is undefined outside that context.
                                                #STORE is cleaned up once the context stops.
                                                #STORE can be anything (e.g. an OBJ or MAP)
ASYNC_LOCAL_STORAGE.getStore()->STORE           #Retrieve the STORE
ASYNC_LOCAL_STORAGE.disable()                   #Make all STORE undefined until run*() called again
                                                #Should be called to cleanup ASYNC_LOCAL_STORAGE itself (not its STOREs)
ASYNC_LOCAL_STORAGE.enterWithStore(STORE)       #Make getStore() return STORE for the current synchronous context (current function and its sync closures)
ASYNC_LOCAL_STORAGE.exit                        #Opposite
 (FUNC([...ARGS])[, ...ARGS])                   #Creates a new async context
ASYNC_LOCAL_STORAGE.bind(FUNC)->FUNC    18.16.0*#Similar to ASYNCRESOURCE.bind()
ASYNC_LOCAL_STORAGE.snapshot()->FUNC    18.16.0*#Same as ASYNC_LOCAL_STORAGE.bind((FUNC, ...ARGS) => FUNC(...ARGS))

asyncWrapProviders                              #OBJ with all possible RESOUCE_TYPE and associated number ids

--experimental-async-context-frame       22.7.0*#Uses a different implementation for AsyncLocalStorage that is based on some new V8 API
                                         22.7.0*#instead of using HOOKs

                                  ┌──────────────────┐
                                  │   PROMISEHOOKS   │
                                  └──────────────────┘

V8.promiseHooks                                 #Module of the following methods
                                                #Event handlers fired on any PROMISEs.
                                                #Used under the hood by ASYNC_HOOKS, but without RESOURCEs

onEVENT(FUNC(...))->FUNC2()                     #Add an event handler.
                                                #FUNC2 removes it.
                                                #FUNC must not using PROMISEs to avoid infinite loops.
                                                #Available EVENTs:
                                                #  - init(PROMISE, PARENT_PROMISE): PROMISE creation
                                                #  - before|after(PROMISE):
                                                #     - before|after a child PROMISE starts|ends
                                                #     - may be called 0-n times
                                                #  - settled(PROMISE): PROMISE resolution|rejection
createHook(OBJ)->FUNC2()                        #Same using OBJ.EVENT(...) instead

                                  ┌──────────────┐
                                  │   DEBUGGER   │
                                  └──────────────┘

--inspect[-wait|-brk][=[HOST:]PORT] ...         #Launches node ... but with debugger server.
                                                #Must connect to it with a debugger client:
                                                #  - go to chrome://inspect and click on a link to open devtools
                                                #  - or directly click on the Node symbol in devtools
                                                #Also forwards console messages
                                                #Beginning behavior:
                                                #  - no -wait|-brk: breakpoints ignored until a client is connected
                                        20.15.0*#  - -wait: wait for client to be connected before running code
                                                #  - -brk: run code but breakpoint at first line of user code
                                                #HOST: def 127.0.0.1
                                                #PORT: def 9229, 0 for "any available"
                                                #Child processes must be started with node --inspect as well
--inspect-publish-uid=STR,...                   #How the debugging information is communicated among:
                                                #  - 'http' (def): endpoint at HOST:PORT/json/list
                                                #  - 'stderr' (def)

IRON-NODE ==>                                  ##Another way to debug is to use Electron.
JAM3 DEVTOOL ==>                               ##Those two apps do this
                                               ##There are many problems I encountered with those, so I prefer node --inspect

--node-memory-debug                             #Add some low-level memory debug messages

                                  ┌───────────┐
                                  │   ERROR   │
                                  └───────────┘

ERROR                                           #Are v8 errors, i.e. what follows is shared by Chrome
                                                #See JavaScript doc for more information, including on async stack trace
ERROR.stack                                     #Start with the innermost source line, before ERROR.name|message if either:
                                                #  - source maps are applied
                                                #  - uncaught exception

--stack-trace-limit=NUM                         #Sets Error.stackTraceLimit

NERROR                                          #Node internal error, as opposed to standard JavaScript ERROR
                                                #Often filesystem errors, including permissions
NERROR.code                                     #NERROR_NAME
                                                #Either:
                                                #  - E*: cross-OS
                                                #  - W*: Windows-specific
                                                #  - ERR_*: otherwise
                                                #E*|W*:
                                                #  - only if SYSTEMERROR
                                                #  - have an underlying NERROR_NUM (OS-specific number)

SYSTEMERROR                                     #NERROR related to OS/environment issue.
                                                #Not its own error type: it is an Error instance.
SYSTEMERROR.errno                               #-NERROR_NUM
UTIL.getSystemErrorName(-NERROR_NUM)->NEROR_NAME#
OS.constants.errno.NERROR_NAME                  #NERROR_NUM
UTIL.getSystemErrorMap()->MAP                   #Key is -NERROR_NUM, value is ARR of ['NERROR_NAME', 'DESCRIPTION']
UTIL.getSystemErrorMessage(-NERROR_NUM)
 ->'DESCRIPTION'                         23.1.0*#

SYSTEMERROR.syscall                             #STR (e.g. 'access')
SYSTEMERROR.path|dest                           #Src|dest 'PATH', if any
SYSTEMERROR.address|port                        #HOST|PORT, if any
SYSTEMERROR.info                                #Extra info, if any

--no-extra-info-on-fatal-exception              #Do not print Node.js versions on process errors (e.g. top-level uncaught
                                                #exceptions, unhandled promises, etc.)

                                  ┌────────────┐
                                  │   EVENTS   │
                                  └────────────┘

new EventEmitter([OPTS])                        #Base class of all objects receiving events
                                                #'EVENT' can be a SYM
                                                #Events are emitted synchronously
EVENTEMITTER.on|addListener
 ('EVENT', FUNC)->EVENTEMITTER                  #
EVENTEMITTER.once('EVENT', FUNC)->EVENTEMITTER  #
EVENTEMITTER.prepend[Once]Listener(...)         #Like on[ce](...) but adds to beginning of listeners list, not end
once(EVENTEMITTER|EVENTTARGET, 'EVENT'[, OPTS]) #Like EVENTEMITTER.once() but using PROMISE:
 ->PROMISE_ARG_ARR                              #  - resolved with ARG_ARR on emit('EVENT', ...ARGS)
                                                #  - rejected with VAL on emit('error', VAL) (unless 'EVENT' is 'error' itself)
                                                #OPTS:
                                                #  - signal ABORT_SIGNAL
on(EVENTEMITTER|EVENTTARGET, 'EVENT'[,OPTS])    #Same but for EVENTEMITTER.on(), as a an ASYNC_ITERATOR
 ->ASYNC_ITERATOR                               #OPTS:
                                                #  - signal ABORT_SIGNAL: on abort, throws AbortError
                                                #  - close 'EVENT'_ARR (def: []): stop on those events
                                                #  - highWaterMark|lowWaterMark NUM (def: Infinity|1):
                                                #     - only when EVENTEMITTER has .pause|resume() (e.g. STREAM)
                                                #     - pause STREAM on NUM of buffered events > highWatermark, resume on < lowWaterMark
                                                #     - NUM is number of events, not byte size
                                       <20.13.0*#     - previously called highWatermark|lowWatermark
                                                #Buffers events infinitely
                                                #  - on throw|return, discard them
EVENTEMITTER.off|removeListener('EVENT', FUNC)
  ->EVENTEMITTER                                #
EVENTEMITTER.removeAllListeners(['EVENT'])
  ->EVENTEMITTER                                #
EVENTEMITTER.emit('EVENT'[, ...])->BOOL         #True if there were listeners
                                                #If 'EVENT' is 'error' and there are no listeners, throws instead

EVENTEMITTER.listeners('EVENT')->FUNC_ARR
getEventListeners
 (EVENTEMITTER|EVENT_TARGET, 'EVENT')->FUNC_ARR #
EVENTEMITTER.rawListeners('EVENT')->FUNC_ARR    #Same but also with what Node.js adds, e.g. once() wrapper
EVENTEMITTER.listenerCount                      #Slightly faster than EVENTEMITTER.listeners(STR).length
 ('EVENT'[, FUNC])->NUM                 18.16.0*#Can filter for a specific listener FUNC only
EVENTEMITTER.eventNames()->'EVENT'_ARR          #
EVENTEMITTER.setMaxListeners(NUM)->EVENTEMITTER
setMaxListeners
 (NUM, EVENT_EMITTER|EVENT_TARGET...)           #0 for unlim. Beyond max, does not stops adding listeners, only print warning.
EVENTEMITTER.getMaxListeners()->NUM             #
getMaxListeners(EVENT_EMITTER|EVENT_TARGET...)
 ->NUM                                  18.17.0*#Same
EVENTEMITTER.defaultMaxListeners                #10
EVENTEMITTER.on                                 #Event when a new event handler is added or removed.
 ("new|removeListener", FUNC(EVENT, FUNC2))     #Added|removed FUNC2 might still [not] be in EVENTEMITTER.listeners(EVENT)

OPTS.captureRejections                          #BOOL. Enables Symbol.for('nodejs.rejection')
EventEmitter.captureRejections                  #Default value for OPTS.captureRejections (def: false)
EVENTEMITTER[Symbol.for('nodejs.rejection')]    #Can be set to a FUNC(VAL, 'EVENT', ...ARGS)
EVENTEMITTER[captureRejectionSymbol]            #Fired when an EVENTEMITTER handler returns a PROMISE rejected with VAL.
                                                #If not set, fire 'error' event handler FUNC(VAL) instead.
                                                #Not recursive (not done if 'nodejs.rejection' or 'error' event handler rejects a PROMISE themselves).

EventEmitter.errorMonitor                       #Special 'EVENT' that behaves like 'error' except if no 'error' listener is
                                                #defined, an error is still thrown afterwards

EventTarget                                     #Like DOM except:
                                                #  - can be async
                                                #  - no event nesting
                                                #Notable differences between DOM EventTarget and Node.js EventEmitter:
                                                #  - listeners are EVENTLISTENER: either FUNC or { handleEvent(EVENT) }
                                                #  - cannot add same listener several times to same OBJ
                                                #Exposed globally
NodeEventTarget                                 #Child of EventTarget that mixes most Node.js EventEmitter properties|methods:
                                                #  - only on|once|off|addListener|removeListener|removeAllListeners|emit
                                                #    listenerCount|eventNames|*etMaxListeners|defaultMaxListeners
                                                #Not exposed globally
Event                                           #Like DOM, including:
                                         19.5.0*#  - EVENT.initEvent()
                                                #Exposed globally
CustomEvent                                     #Like DOM
--experimental-global-customevent       <19.0.0*#Required to expose CustomEvent globally

                                  ┌───────────┐
                                  │   ABORT   │
                                  └───────────┘

new AbortController()                           #Like DOM
new AbortSignal()                               #Like DOM. Child of EventTarget
                                                #Most OPTS.signal used in this doc throw|reject with AbortError
                                                #Including:
                                                #  - AbortSignal.abort()
                                                #  - ABORT_SIGNAL.reason
                                                #  - AbortSignal.timeout(), ABORT_SIGNAL.throwIfAborted()
                                        18.17.0*#  - AbortSignal.any()

util.transferableAbortController()
 ->ABORT_CONTROLLER                     18.11.0*#Same as new AbortController() but can be used with postMessage|structuredClone() (not IPC sendMessage())
util.transferableAbortSignal
 (ABORT_SIGNAL)->ABORT_SIGNAL2          18.11.0*#Same but for AbortSignal

util.aborted(ABORT_SIGNAL, OBJ)->>      18.16.0*#Waits until aborted
                                        18.16.0*#OBJ must not be garbage collectable, otherwise promise will hang

events.addAbortListener                 18.18.0*#Like ABORT_SIGNAL.addEventListener('abort', EVENTLISTENER) except works even if:
 (ABORT_SIGNAL, EVENTLISTENER)->OBJ     18.18.0*#  - another listener calls EVENT.stopImmediatePropagation()
                                        18.18.0*#  - ABORT_SIGNAL already aborted
                                        18.18.0*#Returns OBJ, with OBJ[Symbol.dispose]() calling removeEventListener('abort')

                                  ┌─────────────────────────┐
                                  │   DIAGNOSTICS_CHANNEL   │
                                  └─────────────────────────┘

CHANNEL_NAME                                    #STR|SYM
                                                #Should be namespaced since this is global

channel('CHANNEL_NAME')->CHANNEL                #Global EVENT_EMITTER-like meant for debugging information
CHANNEL.publish(MESSAGE)                        #MESSAGE can be any VAL
CHANNEL.hasSubscribers                          #BOOL

subscribe('CHANNEL_NAME',
 FUNC(MESSAGE, 'CHANNEL_NAME'))                 #
unsubscribe('CHANNEL_NAME', FUNC)->BOOL         #BOOL is whether FUNC was subscribed to
hasSubscribers('CHANNEL_NAME')->BOOL            #

CHANNEL.runStores
 (MESSAGE, FUNC(...ARGS)->VAL
 [, CONTEXT[, ...ARGS]])->VAL           18.19.0*#Call CHANNEL.publish(MESSAGE), then run FUNC() with MESSAGE set as STORE
CHANNEL.bindStore(ASYNC_LOCAL_STORAGE   18.19.0*#Associate a CHANNEL with an ASYNC_LOCAL_STORAGE inside runStores() FUNC
 [, FUNC(STORE)->STORE])                18.19.0*#FUNC transforms STORE on runStores()
CHANNEL.unbindStore(ASYNC_LOCAL_STORAGE)18.1
 ->BOOL                                 18.19.0*#Returns false if not present

TRACING_CHANNEL                         18.19.0*#Collection of 5 CHANNELs gathering different MOMENTs of each event
                                        18.19.0*#MOMENT is [async]start|end or 'error'
tracing:TRACING_CHANNEL_NAME:MOMENT     18.19.0*#CHANNEL_NAME of a TRACING_CHANNEL
TRACING_CHANNEL_MESSAGE.result          18.19.0*#Set on MOMENT [async]end
TRACING_CHANNEL_MESSAGE.error           18.19.0*#Set on MOMENT [async]end|error

tracingChannel('TRACING_CHANNEL_NAME'|
 { MOMENT: CHANNEL, ... })
 ->TRACING_CHANNEL                      18.19.0*#
TRACING_CHANNEL.subscribe
 ({ MOMENT(MESSAGE), ... })             18.19.0*#
TRACING_CHANNEL.unsubscribe
 ({ MOMENT(MESSAGE), ... })->BOOL       18.19.0*#

TRACING_CHANNEL.traceSync(...)          18.19.0*#Like CHANNEL.runStores() but publishes start and (if no exception) end or (if exception) error MOMENTs
TRACING_CHANNEL.tracePromise(...)       18.19.0*#Same but with an async FUNC and asyncStart|End and error MOMENTs
TRACING_CHANNEL.traceCallback(...)      18.19.0*#Same but with a callback FUNC

                                  ┌──────────────────┐
                                  │   TRACE_EVENTS   │
                                  └──────────────────┘

createTracing([OPTS])->TRACING
--trace-events-enabled                          #Output tracing to a TRACE_FILE

TRACING|OPTS.categories                         #'CATEGORY'_ARR
--trace-event-categories=CATEGORY,...           #Pick tracing CATEGORYs
                                                #Def: v8,node,node.async_hooks
                                                #Also calls --trace-events-enabled
TRACING.getEnabledCategories()->'CATEGORY,...'  #

TRACING.enable|disable()                        #Whether to show trace events
                                                #Those are shown in chrome://tracing
TRACING.enabled                                 #BOOL

--trace-event-file-pattern=PATH                 #Output trace events to PATH
                                                #Can include ${rotation} and ${pid}
                                                #Def: 'node_trace.${rotation}.log'

AVAILABLE CATEGORIES ==>                        #
v8                                              #V8 GC, compiling and execution
node                                            #
node.bootstrap                                  #Node startup
node.environment                                #Node environment setup
node.realm                                      #Node global object
node.console                                    #console
node.perf                                       #Performance.*
node.perf.usertiming                            #Performance 'mark|measure'resource'
node.perf.timerify                              #Performance.timerify()
node.promises.rejections                        #PROMISEs unhandled or handled too late
node.async_hooks                                #ASYNC_HOOKS (PROMISE, etc.)
node.threadpoolwork.[a]sync                     #Blob|ZLIB|CRYPTO|node_api
node.fs.[a]sync                                 #FS except 'DIR'
node.fs_dir.[a]sync                             #FS for 'DIR'
node.net.native                                 #TCP
node.http                                       #HTTP
node.dns.native                                 #DNS
node.vm.script                                  #VM

TRACE_FILE                                      #v8 tracing file
                                                #Can be visualized with chrome://tracing or ui.perfetto.dev
TRACE_FILE.traceEvents                          #TRACE_EVENT_ARR
TRACE_EVENT.ph                                  #Event type among:
                                                #  - duration: 'B' (begin), 'E' (end)
                                                #  - complete: 'X'
                                                #  - instant: 'i'
                                                #  - counter: 'C'
                                                #  - async: 'b' (start), 'e' (end), 'n' (instant)
                                                #  - flow: 's' (start), 'f' (end), 't' (step)
                                                #  - sample: 'P'
                                                #  - object: 'N' (create), 'D' (delete), 'O' (snapshot)
                                                #  - metadata: 'M'
                                                #  - memory dump: 'V' (global), 'v' (process)
                                                #  - mark: 'R'
                                                #  - clock sync: 'c'
                                                #  - context: ','
TRACE_EVENT.name                                #Event name
TRACE_EVENT.cat                                 #'CATEGORY,...' tagging an event
TRACE_EVENT.dur                                 #NUMms duration
TRACE_EVENT.tdur                                #NUMms duration, including thread open|end
TRACE_EVENT.ts                                  #DATE_NUM. Start time, global
TRACE_EVENT.tts                                 #DATE_NUM. Start time, within the thread
TRACE_EVENT.pid                                 #Process ID
TRACE_EVENT.tid                                 #Thread ID
TRACE_EVENT.id                                  #Event-type specific ID
TRACE_EVENT.args                                #Event-type specific arguments

                                  ┌────────────┐
                                  │   GLOBAL   │
                                  └────────────┘

GLOBAL VARIABLES ==>                            #  - global|globalThis: global scope reference
                                                #  - clear|setImmediate|Interval|Timeout, Object, URL, console, encodeURI, WebAssembly, etc.: JavaScript globals
                                                #  - module, require, exports, __filename, __dirname: CommonJS globals
                                                #  - process, url: core modules
                                                #  - Buffer: core modules property
                                                #  - _, _error: REPL only
                                                #  - all core modules (e.g. http): in CLI only

--frozen-intrisics                              #Call Object.freeze() deeply on all global objects.

require('timers')                               #Module for clear|setImmediate|Interval|Timeout
                                                #Prefer globals as they work on browsers too

--disable-proto=STR                             #Disallow OBJ.__proto__ (often used for security vulnerabilities)
                                                #STR is 'throw' (throw on access) or 'delete' (remove it)
--disallow-code-generation-from-strings         #Disallow eval() and new Function() (but not VM)

                                  ┌───────────┐
                                  │   SCOPE   │
                                  └───────────┘

SCOPE ==>                                       #Variables are local to each file, except for MODULE.exports|require() or export|import

TOP-LEVEL ==>                                   #CommonJS, import(): any level
                                                #import: must be top-level

TOP-LEVEL CONTEXT ==>                           #CommonJS: exports, require, module, __filename, __dirname
                                                #ESM: only import, export, import.meta

TOP-LEVEL THIS ==>                              #CommonJS: module.exports
                                                #ESM: undefined

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

STEPS ==>                                       #  - resolve relative PATH to absolute PATH
                                                #  - fetch|read file
                                                #  - sets top-level context
                                                #  - parsing
                                                #  - running|evaluating
                                                #  - cache return value

PARSE-TIME VS RUNTIME ==>                       #CommonJS, import(): everything done runtime
                                                #import: everything done parse-time:
                                                #  - cannot do e.g. export { VAL as [DYNAMIC_VAR] }
                                                #  - cannot catch errors in try/catch (e.g. optional dependency)
                                                #  - better static analysis
                                                #  - VAR are implicitely const
                                                #  - also find imported|exported symbols (VAR) and link them

SYNC VS ASYNC ==>                               #CommonJS: sync
                                                #import:
                                                #  - async parsing (parse-time)
                                                #  - sync loading (runtime)
                                                #import(): async with PROMISE

CIRCULAR DEPENDENCIES ==>                       #import(), dynamic require(): no issues
                                                #top-level require():
                                                #  - retrieve `module.exports` (not individual properties) by reference (not value)
                                                #  - if accessed during file load, empty object (parent not done loading)
                                                #     - including destructuring during `require()`
                                                #  - but works after file load:
                                                #     - unless parent does `module.exports = VAL` (as opposed to `module.exports.VAR = VAL`), as it removes the reference
                                                #import:
                                                #  - retrieve individual properties by reference (not value)
                                                #  - if accessed synchronously, throws error (parent not done loading)
                                                #  - otherwise works

DEFAULT EXPORT ==>                              #CommonJS: it is the whole export (module.exports)
                                                #ESM: it is a property named 'default'

FORMAT ==>                                      #Decided by:
                                                #  - FILE.mjs|cjs -> ESM|CommonJS
                                                #  - FILE[.js] -> PACKAGE.type 'module|commonjs' (def: 'commonjs')
                                                #     - `package.json` can be in nested directories
                                                #  - stdin|--eval|--print -> --input-type module|commonjs
                                         23.6.0*#    or module|commonjs-typescript
                                        18.19.0*#  - FILE uses export, static (not dynamic) import, or import.meta -> ESM
                                        18.19.0*#     - slight performance cost at parsing time
                                       <20.19.0*#     - requires --experimental-detect-module
                                                #  - else -> commonjs

MIXING ==>                                      #ESM can import CommonJS:
                                                #  - module.exports VAL|OBJ is imported as default import
                                                #  - module.exports.VAR can also be imported as named import
                                                #     - does not work if module.exports.VAR is dynamically set
                                                #CommonJS cannot import ESM:
                                                #  - including if ESM is a package (node_modules)
                                                #  - but can use dynamic import(), which allows importing ESM
require('module')                               #Returns CommonJS require().
 .createRequire('/PATH'|'URL'|URL)              #'PATH|URL' is the relative base (relative itself to __dirname)
 ->require(STR)                                 #  - Must end with '/' if directory
                                                #Can be used to use CommonJS or load PATH.json|node in ESM
                                                #Usually createRequire(import.meta.url)

--experimental-require-module           20.17.0*#Allow calling require() to import ESM
                                        20.17.0*#The return value is the same as a dynamic import(), e.g. default exports are a `default` property
                                        20.17.0*#It also has {__esModule: true} if there is a `default` export
                                        22.12.0*#However, if ESM file does a single named export called 'module.exports', it is used as is by require()
                                        20.17.0*#Fails if either the current file or the imported one has a top-level await
                                       <20.19.0*#Flag not needed anymore
--experimental-print-required-tla        22.0.0*#When calling require() to import ESM and there is a top-level await, print its location
process.features.require_module         20.19.0*#BOOL. True when current file is ESM loaded by require()
--trace-require-module=STR              20.19.0*#Prints any require(ESM) if 'all'
                                        20.19.0*#If 'no-node-modules', do not print when requiring Node modules

DUAL PACKAGES ==>                               #Alternatives when supporting both old and new Node.js:
                                                #  - use different PACKAGE.exports.PATH for CommonJS and ESM
                                                #  - use different PACKAGE.exports.CONDITION for CommonJS and ESM
                                                #ESM can be either:
                                                #  - ESM source
                                                #     - this could be an issue as user could load twice (once with require(), once with import)
                                                #        - not an issue if no logic triggered on load nor top-level state
                                                #  - ESM small file that loads transpiled ESM source
                                                #     - so that exports are known parse-time and named imports can be used

--force-context-aware                           #Forbids native modules that do side effects during initialization

                                  ┌────────────────┐
                                  │   FILE TYPES   │
                                  └────────────────┘

require|import ... 'PATH[.js]'                  #

require|import ... 'PATH.json'
 with { type: 'json' }                  18.20.5*#

require('PATH.node')                            #Machine code file.
                                                #Loaded by dlopen()
                                                #exports available in void init(Handle<Object> exports)
                                                #Must use libraries: V8, libuv, others
                                                #Use node-gyp for packaging/compilation
                                                #On Windows, must first npm install -g windows-build-tools as admin
--no-addons                                     #Disable PATH.node
--experimental-addon-modules             23.6.0*#Required with ESM
                                        <23.6.0*#Previously, not possible with ESM

import ... from 'URI.wasm'                      #Only with ESM
--experimental-wasm-modules                     #Required for WebAssembly imports
--disable-wasm-trap-handler             20.15.0*#Implement bound checks using sync checks instead of OS signals
                                        20.15.0*#Much slower but does not require 10GB memory

import 'data:MIME,...'                          #For MIMEs text/javascript, application/json, application/wasm
                                                #Cannot do a nested import inside ...
                                                #Only with ESM

import 'node:ID'                                #Same as import 'ID' (core module), but valid URI
                                                #Available with require() too

                                  ┌──────────────┐
                                  │   COMMONJS   │
                                  └──────────────┘

require(STR)                                    #Load file STR:
                                                #  - 'ID': core module
                                                #  - 'FILE' (absolute or relative)
                                                #  - 'DIR' (absolute or relative):
                                                #     - DIR/package.json, using main 'PATH' (relative to DIR)
                                                #     - DIR/index[.EXT]
                                                #        - prints a warning for PACKAGE.main|exports file
                                                #  - 'MODULE[/PATH]':
                                                #     - i.e. anything that does not start with / or .
                                                #     - tries require('DIR2/MODULE'), with DIR2 [.../[..]]./node_modules/
                                                #Paths can omit extensions: .js, .mjs, .cjs, .json, .node
                                                #  - decide file type based on file extension
                                                #  - prints a warning for PACKAGE.main|exports file
                                                #If not found, throw ERROR with:
                                                #  - code "MODULE_NOT_FOUND"
                                                #  - requireStack 'PATH'_ARR
MODULE.require(...)                             #Reference to require(...)
-r|--require STR                                #Calls require() (CommonJS)
--import=PATH                           18.18.0*#Calls import() (ESM)

require.resolve(STR[, OPTS])->'/PATH'           #How require(STR) would resolve, based on __filename.
                                                #OPTS:
                                                #  - paths 'DIR'_ARR: alternative directories to look into.
                                                #    Their [.../[..]]./node_modules will always be searched.
require.resolve.paths(STR)->'DIR'_ARR           #Directories that would be looked into when require(STR) would resolve
import.meta.resolve(STR[, CURRENT_URL])         #Same as require.resolve() but for ESM
 ->'file://...'                                 #CURRENT_URL is STR|URL
                                                #Returns 'node:*' for core modules
                                                #ERROR with code 'ERR_MODULE_NOT_FOUND' if cannot find
                                       <18.19.0*#Used to return a PROMISE
--experimental-import-meta-resolve              #Needed to use CURRENT_URL with import.meta.resolve()
                                       <18.19.0*#Needed to use import.meta.resolve()

findPackageJSON                         22.14.0*#Find closest package.json starting from DIR or FILE's DIR
 ('MODULE|'FILE'|'DIR'|URL              22.14.0*#PATH2|URL2 is relative base of PATH|URL (optional if first argument is absolute)
 [, 'PATH2'|URL2])[->'PATH3']           22.14.0*#Returns undefined if not found
                                        22.14.0*#If 'MODULE', same as import.meta.resolve() instead

require.cache['/PATH']                          #require() cache (i.e. modules are only loaded once).
                                                #'/PATH' is require.resolve() result
                                                #Does not include builtins.
                                                #Can delete it to remove cache, or restart current code.

--preserve-symlinks                             #When require()|import a symlink, use symlink path instead of symlinked file's path for:
                                                #  - caching
                                                #  - module resolution (when walking up the tree)
                                                #Does not apply to main file
--preserve-symlinks-main                        #Same but only for main file

exports                                         #Return value (by reference if OBJ) when required. Must be assigned sync.
                                                #Can be any type.
MODULE.exports                                  #Reference to exports.
                                                #Must be used when want to overwrite, i.e. exports = VAL (as opposed to exports.VAR = VAL)

module                                          #Current MODULE, i.e. file being loaded.
                                                #There are builtin modules, which are the chapters of this doc.
require.main                                    #Root file (first to have been loaded) MODULE
process.mainModule                              #Same but updated if root file changed at runtime
MODULE.children                                 #MODULE[_ARR]|null

MODULE.isPreloading                             #BOOL. True when inside node -r
MODULE.loaded                                   #False for the first time the file is loaded (i.e. sync)
                                                #True for async functions
require('module').builtinModules                #List of system 'MODULE'_ARR (e.g. 'http') including internal ones
require('repl').builtinModules                  #Same
require('module').isBuiltin(STR)->BOOL          #true if 'node:ID' core module
process.getBuiltinModule
 (STR)->OBJ|undefined                   20.16.0*#Like import('node:ID') but sync

__filename                                      #Current file absolute path.
MODULE.filename                                 #Reference to __filename
MODULE.id                                       #For core modules, a string like "buffer". For others, module.filename.
__dirname                                       #Current file absolute dirname

CLI ==>                                         #Not defined: require.main, process.mainModule, __filename, __dirname
                                                #MODULE.loaded: false
                                                #MODULE.id: '<repl>'
                                                #MODULE.exports: empty OBJ
                                                #MODULE.filename null

--no-global-search-paths                        #Disable deprecated ENVVAR NODE_PATH and ~/.node_modules

DIAGNOSTICS_CHANNEL.subscribe
 ('module.require.start|end', FUNC(OBJ)) 22.4.0*#OBJ: id 'MODULE', parentFilename 'PATH'
DIAGNOSTICS_CHANNEL.subscribe
 ('module.require.error',
 FUNC(OBJ, ERROR))                       22.4.0*#OBJ: id 'MODULE', parentFilename 'PATH'

                                  ┌────────────────┐
                                  │   ES MODULES   │
                                  └────────────────┘

import|export ...
import('URI')->PROMISE                          #ES modules

import ... from 'URI'                           #Import from 'URI' not PATH
                                                #Need to be URI encoded
                                                #Must use file:/// if absolute
                                                #Can use fileURLToPath|pathToFileURL() to convert

RESOLUTION ==>                                  #Cannot omit file extension or use index.js
                                                #Use same algorithm to find node_modules (unlike browsers)
SELF IMPORT ==>                                 #Can import current package by name (e.g. in tests)

CACHING ==>                                     #Imports URIs can use #HASH or ?QUERY: included in cache key, providing importing file is ESM
                                                #I.e. can load twice a file by using different ?QUERY
                                                #import('URI') uses the same cache and cache logic

import.meta.url                                 #'file://...'. Should be used instead of __filename|__dirname
                                         23.0.0*#Might include ?QUERY or #HASH, when using --entry-url
import.meta.filename                    20.11.0*#Like __filename but for ESM. Same as fileURLToPath(import.meta.url)
                                        20.11.0*#Cannot be used with file imported with 'file://...'
                                        20.11.0*#Resolves symlinks
import.meta.dirname                     20.11.0*#Same but for __dirname. Same as dirname(import.meta.filename)

require('module').syncBuiltinESMExports()       #Can monkey-patch core modules by modifying their default import.
                                                #This must be called after it so that dynamic import(...) can use it

PACKAGE.exports                                 #'URI'[_ARR]. Like PACKAGE.main except:
                                                #  - priority over it
                                                #  - must start with '.'
                                                #  - only for import|require from 'MODULE[/...]' not relative|absolute paths|URI
                                                #Can be an ARR for fallbacks
                                                #  - only skips 'URI' that is not valid identifier with current Node.js version
                                                #     - e.g. not starting with '.'
                                                #  - i.e. only meant for forward compatibility with new Node.js features
                                                #Used with both CommonJS|ESM

PACKAGE.exports.CONDITION                       #'URI'[_ARR]. Like PACKAGE.exports except only if CONDITION matches.
                                                #Available CONDITION:
                                                #  - require: loaded by require()
                                                #  - import: loaded by ES import|import()
                                        20.19.0*#  - module-sync: loaded by either require() or ES import|import(), since both can load ESM
                                                #  - node: Node.js environment (loaded by require()|import)
                                                #  - types[@SEMVER]: TypeScript (version SEMVER)
                                                #  - browser: browser environment
                                                #  - default: always match, but least priority
                                                #  - custom ones, e.g. 'electron', 'deno', etc.
                                                #CONDITION can be nested.
                                                #Matched|tried in object properties order.
--conditions|-C=CONDITION,...                   #Specify custom CONDITION

PACKAGE.exports.PATH[.CONDITION]                #'PATH2'. Like PACKAGE.exports[.CONDITION] except remaps requester's 'URI' to another one
                                                #PATH must start with '.':
                                                #  - matched against 'MODULE' in imported path
                                                #  - can be single '.'
                                                #PATH must not end with "/"
                                                #PATH is exact match
                                                #PATH+PATH2 can contain wildcard '*':
                                                #  - must both contain it
                                                #  - if several matches, longer prefixes prevail
                                                #If no matches, errors.
                                                #Forbid any 'MODULE/...' without a matching PACKAGE.exports.PATH
                                                #  - including PACKAGE.exports {}|false

PACKAGE.imports.#PATH[.CONDITION]               #PATH2. Like PACKAGE.exports but for imports inside the module itself
                                                #Similar goal as IMPORT_MAP but
                                                #  - different syntax
                                                #  - usable by libraries not only top-level applicaions

DIAGNOSTICS_CHANNEL.subscribe
 ('module.import.asyncStart|End',
 FUNC(OBJ))                              22.4.0*#OBJ: id 'MODULE', parentURL URL
DIAGNOSTICS_CHANNEL.subscribe
 ('module.import.error',
 FUNC(OBJ, ERROR))                       22.4.0*#OBJ: id 'MODULE', parentURL URL

                                  ┌────────────┐
                                  │   LOADER   │
                                  └────────────┘

--experimental-loader PATH                      #Customize the behavior of import|import()
                                                #PATH must be ESM, and have a default export LOADER
                                                #When called several times, each LOADER is run, starting from last
                                                #  - including the implicit default LOADER, run last
                                                #Each of the methods below:
                                                #  - represent one step of the resolution to customize
                                                #  - are optional
                                                #  - must return either:
                                                #     - OBJ2, with OBJ2.shortCircuit true (def: false)
                                                #        - the previous LOADERs are not run
                                                #        - this moves on the next LOADER phase
                                                #     - FUNC(...)
                                                #        - the previous LOADERs are then run
                                                #        - ... are the current LOADER.*() arguments, except FUNC itself
                                                #           - they can be modified
                                                #        - this remains in the same LOADER phase, with potentially different arguments

module.register                         18.19.0*#Like --experimental-loader but programmatic
 ('PATH', import.meta.url[, OBJ])       18.19.0*#Prefer using --import + module.register() than --experimental-loader
module.register(URL[, OBJ])             18.19.0*#OBJ:
                                        18.19.0*#  - data OBJ2:
                                        18.19.0*#     - passed to LOADER.initialize()
                                        18.19.0*#     - uses structuredClone()
                                        18.19.0*#  - transferList VAL_ARR:
                                        18.19.0*#     - declare values used in OBJ.data that should be transfered as is
                                        18.19.0*#        - e.g. ARRBUFFER[VIEW]|MESSAGEPORT
                                        18.19.0*#     - like structuredClone() does
                                        18.19.0*#  - parentURL 'URL'

LOADER.initialize(OBJ)[->>]             18.19.0*#Run during --experimental-loader or module.register()

LOADER.resolve('PATH', OBJ, FUNC(...))          #'PATH' is relative path
 ->>OBJ2                                        #OBJ:
                                                #  - parentURL 'URL'|undefined: absolute base
                                                #     - is a URL, e.g. file: protocol with filesystem
                                                #     - undefined if entry point, including REPL
                                                #  - conditions 'CONDITION'_ARR: from PACKAGE.exports.CONDITION
                                                #  - importAttributes OBJ: from import("MDL", { with: OBJ }) or import ...  with OBJ
                                       <18.19.0*#     - previously called importAssertions, which is kept for backward compatibility but with warning
                                                #OBJ2:
                                                #  - url 'URL' (required): resolved absolute URL
                                                #  - format: 'module' (ESM), 'commonjs', 'json', 'builtin' (core module), 'wasm'
                                                #     - custom formats should use 'module'
                                                #     - meant as a hint for LOADER.load()
                                                #  - shortCircuit BOOL
                                                #  - importAttributes OBJ

LOADER.load('URL', OBJ, FUNC(...))              #'URL': same as returned by LOADER.resolve() OBJ2.url
 ->>OBJ2                                        #OBJ:
                                                #  - format STR: returned by LOADER.resolve(), i.e. can be undefined
                                                #  - conditions, importAttributes: same as LOADER.resolve()
                                                #OBJ2:
                                                #  - format (required): like LOADER.resolve()
                                                #  - source 'SOURCE'_STR|ARRBUFFER|UINT8_ARR (required): file content
                                                #  - shortCircuit BOOL

module.registerHook(OPTS)                23.5.0*#Similar to module.register() but:
                                         23.5.0*#  - run in the same thread as loaded file, and can mutate its globalThis
                                         23.5.0*#  - sync
OPTS.resolve|load                        23.5.0*#LOADER.* but sync

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

ENVVAR NODE_COMPILE_CACHE=DIR            21.1.0*#Caches bytecode to DIR/CACHE_VERSION_HASH/FILE_HASH
                                         21.1.0*#Slower on first run of a file, but faster subsequent startups
                                         21.1.0*#Should not be used together test coverage
enableCompileCache([DIR])->VAL           22.8.0*#Same but, def DIR is ENVVAR NODE_COMPILE_CACHE, or TMP_DIR/node-compile-cache
                                         22.8.0*#Only for dynamic imports, since static imports are already loaded
                                         22.8.0*#Returns OBJ:
                                         22.8.0*#  - status constants.compileCacheStatus.*:
                                         22.8.0*#     - 'ENABLED': was disabled before
                                         22.8.0*#     - 'ALREADY_ENABLED': was already enabled
                                         22.8.0*#     - 'FAILED': filesystem issue
                                         22.8.0*#     - 'DISABLED': NODE_DISABLE_COMPILE_CACHE=1
                                         22.8.0*#  - message 'ERROR': undefined unless 'FAILED'
                                         22.8.0*#  - directory 'DIR': undefined if 'FAILED|DISABLED'
ENVVAR NODE_DISABLE_COMPILE_CACHE=1      22.8.0*#

getCompileCacheDir()[->'DIR']            22.8.0*#

module.flushCompileCache()              22.10.0*#Write any currently buffered bytecode cache right away, instead of on exit
                                        22.10.0*#This allows other processes (including subprocesses) to use it without waiting for current process exit

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


--experimental-transform-types           22.7.0*#Transform TypeScript types
                                         22.7.0*#Does not do type checking
                                         22.7.0*#Implies --enable-source-maps
                                         22.7.0*#Does not support tsconfig.json-related features, e.g. --paths, --module, etc.
                                         22.7.0*#Supports *.ts|mts|cts but not *.tsx
                                         22.7.0*#Imports must use `type` and specify *.ts file extension (i.e. must use --allowImportingTsExtensions)

TYPES STRIPPING ==>                      23.6.0*#By default, does --experimental-transform-types but only ignore types, does not transform them
                                         23.6.0*#I.e. does not support: enums, namespaces, `declare module` parameter properties
                                         23.6.0*#Does not imply --enable-source-maps
--experimental-strip-types        22.6.0-23.5.0*#Required

module.stripTypeScriptTypes
 ('CODE'[, OPTS])->'CODE'               22.13.0*#Same but on inline 'CODE'
OPTS.mode                               22.13.0*#'strip' (def) or 'transform'
OPTS.sourceMap                          22.13.0*#BOOL (def: false). Generate a source map, if mode 'transform'
OPTS.sourceUrl                          22.13.0*#'URL'. Append sourceURL comment

process.features.typescript             22.10.0*#'strip|transform' when using the above flags

                                  ┌─────────────────┐
                                  │   SOURCE MAPS   │
                                  └─────────────────┘

--enable-source-maps                            #Use source maps for ERROR.stack
                                                #Does not work with ERROR.prepareStackTrace()
                                                #Also enables MODULE.findSourceMap|SourceMap
process.setSourceMapsEnabled(BOOL)              #Same. Only for files not loaded yet.
                                                #  - Current file is already loaded
                                                #  - Static imports are all already loaded when this executes, i.e. only
                                                #    applies to later dynamic imports
MODULE.setSourceMapsSupport(BOOL[, OBJ]) 23.7.0*#Same but with options OBJ:
                                         23.7.0*#  - nodeModules BOOL (def: false): enabled in node_modules
                                         23.7.0*#  - generatedCode BOOL (def: false): enabled in eval()
process.sourceMapsEnabled               18.19.0*#BOOL
MODULE.getSourceMapsSupport()->OBJ       23.7.0*#OBJ: enabled BOOL, nodeModules BOOL, generatedCode BOOL

new MODULE.SourceMap(SOURCEMAP_OBJ[, OPTS])     #SOURCEMAP.
                                                #SOURCEMAP_OBJ has source map v3 raw properties
                                                #(version|sources|sourceRoot|sourcesContent|names|file|mappings)
OPTS.lineLengths                                #NUM_ARR (def: guessed) with char length of each line
SOURCEMAP.payload                               #SOURCEMAP_OBJ
SOURCEMAP.findEntry(LINE_NUM, COL_NUM)->OBJ     #Use "mappings" to map compiled|generated file LINE_NUM|COL_NUM to
                                                #source|original file
                                                #OBJ:
                                                #  - generatedLine|Column NUM
                                                #  - originalLine|Column NUM
                                                #  - originalSource 'SOURCE_PATH'|null
                                        18.18.0*#  - name STR: range name
SOURCEMAP.findOrigin(LINE_NUM, COL_NUM) 18.18.0*#Same but in ancestor original file.
 ->OBJ                                  18.18.0*#OBJ: fileName STR, lineNumber|columnNumber NUM, name STR

MODULE.findSourceMap('PATH'[, ERROR])           #Parse SOURCEMAP using sourceMappingURL comment (inline or external)
 ->SOURCEMAP                                    #If inside an Error.prepareStackTrace(ERROR), should specify ERROR for caching reasons

SCRIPT.sourceMapURL                      19.1.0*#'URL', if SCRIPT contains sourceMappingURL. undefined otherwise

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

--permission                             20.0.0*#Enables the following methods
                                         20.0.0*#Also disable:
                                         20.0.0*#  - permissions for all --allow-* by default
                                         20.0.0*#  - native modules
--experimental-permission              <22.13.0*#Previous name

--allow-fs-read=STR                      20.0.0*#Allow reading file
                                         20.0.0*#STR is 'PATH' (recursively). Can include '*'
                                       <20.12.0*#  - absolute only
                                         20.0.0*#Includes importing files, including the main one.
--allow-fs-write=STR                     20.0.0*#Allow writing file
                                         20.0.0*#STR is 'PATH' like --allow-fd-read
--allow-worker                           20.0.0*#Allow new Worker() (which does not inherit permissions)
--allow-child-process                    20.0.0*#Allow CHILD_PROCESS spawning
--allow-addons                          20.12.0*#Allow native addons
--allow-wasi                            20.16.0*#Allow WASI

process.permission.has                   20.0.0*#Test permission
 ('PERMISSION'[, STR])->BOOL             20.0.0*#PERMISSION is 'fs[.read|write]'.
                                         20.0.0*#STR is same as --allow-* argument

                                  ┌────────────┐
                                  │   BUFFER   │
                                  └────────────┘

new Blob(...)                                   #Like DOM
                                                #Global object
                                        20.16.0*#Including BLOB.bytes()

new File(...)                           18.13.0*#Like DOM
                                         20.0.0*#Global object

[S][T][D][U][A]BUFFER                           #Means BUFFER|[STR]|[TYPED_ARR]|[DATAVIEW]|[UINT8ARR]|[ARRBUFFER]

Buffer                                          #Child of Uint8Array, with extra methods:
                                                #  - can change type, like DATAVIEW
                                                #  - typecasting to STR|OBJ
                                                #  - easier to concat, compare, swap
                                                #  - can test|write SUBUFFERs (instead of only UINT)
                                                #  - encode|decode with different ENCODINGs

new TYPED_ARR(BUFFER)                           #
new Buffer(...)                                 #Like new TYPED_ARR(...), but deprecated
Buffer.allocUnsafe[Slow](NUM)->BUFFER           #Like new TYPED_ARR(NUM), but does not fill with \0 unless --zero-fill-buffers
Buffer.alloc(NUM[, ...])->BUFFER                #Like Buffer.allocUnsafeSlow(NUM).fill(...) (def: \0)
Buffer.from(ARRBUFFER[, UINT[, UINT2]])->BUFFER
Buffer.from(TDBUFFER)->BUFFER
Buffer.from(ARRAYLIKE)->BUFFER                  #Like new TYPED_ARR(...)

Buffer.concat(UBUFFER_ARR[, UINT])->BUFFER      #Concatenates elements to single BUFFER
                                                #Stops at UINT bytes (if provided).

BUFFER.toString([...])->STR                     #If ..., does BUFFER.slice(...)
Buffer.from(STR)->BUFFER                        #
BUFFER.toJSON()->OBJ                            #OBJ: type 'Buffer', data NUM_ARR
Buffer.from(OBJ)->BUFFER                        #

BUFFER.buffer                                   #Like TYPED_ARR.buffer
REFERENCES ==>                                  #Two BUFFERs might re-use same underlying ARRBUFFER:
                                                #  - new TYPED_ARR(BUFFER), Buffer.alloc[UnsafeSlow](): no re-use
                                                #  - Buffer.from(ARRBUFFER), BUFFER.subarray(): re-use
                                                #  - Buffer.allocUnsafe(), Buffer.from(TDBUFFER|ARRAYLIKE|STR|OBJ), Buffer.concat(): use pool
POOL ==>                                        #A pool of ARRBUFFERs is automatically maintained, for memory allocation performance.
                                                #Each ARRBUFFER size is Buffer.poolSize (def: 8192)
                                                #  - should be power of 2, for performance
                                                #Buffer.allocUnsafe|from|concat() use them:
                                                #  - only a subrange of the ARRBUFFER
                                                #     - subrange size is according to BUFFER size
                                                #        - but might be a little bigger
                                                #        - e.g. force a power of 8 on my machine
                                                #     - i.e. cannot change other BUFFERs data
                                                #        - except with ARRBUFFER.resize|transfer()
                                                #  - only if BUFFER size < Buffer.poolSize / 2
                                                #  - the same ARRBUFFER is used until no more available size, in which case a new one is created|used

BUFFER.length
Buffer.byteLength(STDABUFFER)->NUM              #Like TYPED_ARR.byteLength

Buffer.isBuffer(VAL)->BOOL                      #
BUFFER.equals(UBUFFER2)->BOOL                   #
BUFFER.compare(UBUFFER2[, 4 NUM])->-1|0|1       #Sort comparison. NUMs are UBUFFER2 start|end and UBUFFER start|end
Buffer.compare(UBUFFER, UBUFFER2)->-1|0|1       #Same as BUFFER.compare(UBUFFER2)

BVAL                                            #Element values can be not only UINT but also 'CHAR'|SUBUFFER in:
                                                #  - [last]indexOf|includes()
                                                #  - fill() (repeat elements)
BUFFER.write(STR[, UINT[, UINT2]])->NUM         #Writes STR on BUFFER
                                                #UINT is offset (def: 0) and UINT2 is length (def: all)
BUFFER.copy(UBUFFER2[, 3 UINT])->UINT4          #Copies bytes from BUFFER at position UINT to UBUFFER2 from position UINT2 to
                                                #UINT3 (def: UBUFFER2.length)
Buffer.copyBytesFrom
 (TYPED_ARR[, UINT[, UINT2]])->BUFFER   18.16.0*#Returns BUFFER copy of TYPED_ARR, at position UINT (def: 0) for UINT2 bytes (def: all)

BUFFER.read*LE|BE(UINT)->VAL                    #Like DATAVIEW.get*(UINT) but:
                                                #  - BOOL argument -> LE|BE
                                                #  - can spell Uint -> UInt
BUFFER.read[Ui|I]nt[LE|BE](UINT, UINT2)->VAL    #Same but specifies integer size UINT2 (up to 48)
BUFFER.write*(VAL, ...)                         #

BUFFER.swap16|32|64()->BUFFER                   #Swaps every couple of 1|2|4 bytes. Return value is reference

kMaxLength                                      #Max BUFFER.length (8PB on my machine)
constants.MAX_LENGTH                    <22.0.0*#Previously 4GB on my machine
kStringMaxLength
constants.MAX_STRING_LENGTH                     #Max STR.length (500MB on my machine)

'ENCODING'                                      #Can be optional last argument to:
                                                #  - Buffer.alloc|from(STR)
                                                #  - Buffer.byteLength(...)
                                                #  - BUFFER.write()
                                                #  - BUFFER.[last]indexOf|includes|fill()
                                                #And optional first argument to:
                                                #  - BUFFER.toString()
                                                #Def: 'utf8'
Buffer.isEncoding('ENCODING')->BOOL             #
transcode(UBUFFER, "ENCODING", "ENCODING2")
 ->BUFFER2                                      #Returns BUFFER2 with ENCODING2, based on UBUFFER with ENCODING

Buffer.isAscii(TABUFFER)->BOOL          18.15.0*#Returns true if valid ASCII
Buffer.isUtf8(TABUFFER)->BOOL           18.14.0*#Returns true if valid UTF-8

                                  ┌────────────────────┐
                                  │   STRING_DECODER   │
                                  └────────────────────┘

new StringDecoder(['ENCODING'])                 #Returns DECODER. Def: "utf8"
                                                #Convert TDBUFFER -> STR
                                                #If not 'utf8', also convert UTF8 -> other encoding
                                                #I.e. similar to TextDecoder, or to Buffer.from(TDBUFFER).toString(['ENCODING'])

DECODER.write(TDBUFFER)->STR                    #Incomplete sequences are buffered (similar to TextDecoder.decode(..., { stream: true }))
DECODER.end([TDBUFFER])->STR                    #Returns incomplete sequences (similar to final TextDecoder.decode())
                                                #If TDBUFFER, does DECODER.write() first
                                                #Does not destroy DECODER: can still use it

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

promises.*
require('stream/promises').*                    #

ISTREAM VS OSTREAM ==>                          #Similar: mostly FIFO queues
                                                #However:
                                                #  - ISTREAM: producer pushes, consumer consumes|processes
                                                #  - OSTREAM: consumer pushes, producer consumes|processes

COMPARISON WITH ASYNC ITERABLES =>              #Similar to ASYNC_ITERABLEs:
                                                #  - ISTREAM.read()->SVAL <=> yield SVAL
                                                #  - OSTREAM.write(SVAL) <=> SVAL = yield
                                                #But has buffering:
                                                #  - ISTREAM: as if could call `yield` NUM times without waiting for ITERATOR.next()
                                                #  - OSTREAM: as if could call ITERATOR.next(SVAL) NUM times without waiting for a new `yield`

IOPTS|OOPTS.construct|read|write[v]|final
 |destroy|transform|flush(...)                  #Meant to be defined by stream producer, not consumer
ISTREAM|OSTREAM|TRANSFORM.prototype._METHOD(...)#Alternative to IOPTS|OOPTS.construct|read|write[v]|final|destroy|transform|flush(...)
                                                #I.e. producer define behavior by subclassing
                                                #  - instead of passing IOPTS|OOPTS during initialization or in constructor

new Readable([IOPTS])                           #ISTREAM
new Writable([OOPTS])                           #OSTREAM
IOPTS|OOPTS.construct(FUNC([ERROR]))            #Called on construction, after constructor in a different microtask
                                                #Delays any IOPTS.METHOD() until done
                                                #I.e. like constructor, but async

process.stdin|stdout|stderr                     #Standard streams
                                                #Writes to process.stdout|stderr are sync if piped to:
                                                #  - a file, on Unix|Windows
                                                #  - a terminal, on Unix
                                                #  - a pipe (including another process) or a socket, on Windows

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

IOPTS.read(UINT)                                #Pushes a SVAL on the buffer
                                                #Must `ISTREAM.push(SVAL)` 1-n times, sync|async
                                                #Must `ISTREAM.push(null)` on end
                                                #Must `ISTREAM.destroy(ERROR)` on sync|async error
                                                #UINT is highWaterMark
                                                #  - preferred size for SVAL
                                                #  - advisory only, i.e. can push:
                                                #     - less bytes: if not more available
                                                #     - more bytes: to buffer more than requested
                                                #Serialized:
                                                #  - delayed until previous one calls ISTREAM.push() once
                                                #  - unless buffer is not empty
                                                #Automatically repeated until ISTREAM.push() returns false
ISTREAM.push(SVAL|null)->BOOL                   #Add a SVAL at beginning of the buffer
                                                #If null, ends ISTREAM
                                                #Returns false:
                                                #  - if either:
                                                #     - current IOPTS.read(UINT) pushed >= UINT
                                                #     - ISTREAM has ended|aborted|errored
                                                #  - IOPTS.read() should use this to know whether to stop pushing SVALs
                                                #SVAL can be empty, although not recommended
                                        20.13.0*#SVAL can also be a TYPEDARR|DATAVIEW
ISTREAM.unshift(SVAL)->BOOL                     #Same but at end of the buffer
                                                #Meant for consumer to put back a SVAL just read
                                        20.13.0*#SVAL can also be a TYPEDARR|DATAVIEW

ISTREAM.read([UINT])->SVAL|null                 #Calls IOPTS.read()
                                                #  - IOPTS.read() can push to buffer async
                                                #  - but ISTREAM.read() does not wait for it, i.e. calls it like a sync FUNC
                                                #Then consumes a SVAL from the buffer, right away
                                                #  - consumes max UINT size
                                                #     - def: Infinity
                                                #     - can be 0
                                                #  - max 1GB
                                                #Returns null if buffer empty
                                                #On ISTREAM end|abort|error, buffer is kept and can still be consumed
ISTREAM.readableDidRead                         #BOOL. Whether ISTREAM.read() was called and returned non-null at least once
Readable.isDisturbed(ISTREAM|RSTREAM)->BOOL     #Whether either data was read or stream was aborted

ISTREAM.readableFlowing                         #Can be:
                                                #  - null:
                                                #     - initial|default state, neither paused nor not paused
                                                #  - true:
                                                #     - not paused
                                                #     - calls IOPTS.read()->SVAL repeatedly, waiting for each completion
                                                #     - SVAL discarded if no 'data' event
                                                #     - set by first ISTREAM.on('data')
                                                #     - cannot be set if any ISTREAM.on('readable')
                                                #  - false:
                                                #     - paused
                                                #     - set by first ISTREAM.on('readable')
ISTREAM.isPaused()->BOOL                        #Whether readableFlowing === false
ISTREAM.pause|resume()->ISTREAM                 #Sets ISTREAM.readableFlowing false|true
ISTREAM.on('pause|resume', FUNC())              #On ISTREAM.readableFlowing change

ISTREAM.on('data', FUNC(SVAL))                  #Called on ISTREAM.push(SVAL)
                                                #Consumes SVAL
                                                #Only emitted if ISTREAM.readableFlowing true
ISTREAM.on('readable', FUNC())                  #Called on ISTREAM.push(SVAL|null)
                                                #Must manually consume SVAL, i.e. repeat ISTREAM.read() until returns null

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

OOPTS.write(SVAL, 'ENCODING', FUNC([ERROR]))    #Consumes a SVAL from the buffer
                                                #Must call FUNC([ERROR]) once done
                                                #Always called serially
                                                #  - i.e. next OOPTS.write() wait for current one to complete
                                                #  - the SVALs from the pending OOPTS.write() are buffered
OOPTS.writev(OBJ_ARR, FUNC([ERROR]))            #Same but consuming multiple SVALs at once
                                                #OBJ: chunk SVAL, encoding 'ENCODING'
                                                #Called instead of OOPTS.write() if either:
                                                #  - OOPTS.write() not defined
                                                #  - more than one SVAL can be consumed from the buffer

OSTREAM.write(SVAL[, FUNC([ERROR])])->BOOL      #Pushes a SVAL to the buffer
                                                #Calls OOPTS.write[v]() exactly once
                                                #  - even if buffer is full
                                                #Returns false if buffer is full, or if already ended|aborted|errored
                                                #  - i.e. advisory only, might keep writing, or might write SVALs bigger than highWaterMark
                                                #FUNC called once done
                                                #  - FUNC(ERROR) called if OSTREAM already ended|aborted|errored
                                        20.13.0*#SVAL can also be a TYPEDARR|DATAVIEW
OSTREAM.end([...])->OSTREAM                     #Ends OSTREAM
                                                #If ..., calls OSTREAM.write(...) first
                                                #FUNC([ERROR]) called on 'finish' or error

OSTREAM.on('drain', FUNC())                     #Called when:
                                                #  - buffer was full, i.e. some OSTREAM.write() returned false
                                                #  - buffer is now empty
                                                #I.e. if OSTREAM.write()->false, should wait for OSTREAM.once('drain') before writing again
OSTREAM.writableNeedDrain                       #BOOL. True if 'drain' will be emitted in future

OSTREAM.cork()                                  #Delay OOPTS.write[v]() until OSTREAM.uncork|end(), i.e. force buffering
                                                #Does not change OSTREAM.write()'s return value
                                                #Can be called several times, in which case uncork() must be done several times.
                                                #Goal: call OOPTS.writev() all at once
                                                #  - e.g. when writing a lot of small I/O, to make them all flush at once
OSTREAM.uncork()                                #
OSTREAM.writableCorked                          #NUM of times to call uncork()

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

ISTREAM.on("end", FUNC())                       #On success, i.e. all chunks read, i.e. ISTREAM.read()->null
ISTREAM.readableEnded                           #BOOL. Whether 'end' called

OSTREAM.writableEnded                           #BOOL. Whether OSTREAM.end() called, even if not completed, successful or not
OOPTS.final(FUNC([ERROR]))                      #Called on OSTREAM.end() success
OSTREAM.on("finish", FUNC())                    #Called on OOPTS.final() success
OSTREAM.writableFinished                        #BOOL. Whether 'finish' called

ISTREAM|OSTREAM.on("error", FUNC(ERROR))        #On error
ISTREAM|OSTREAM.errored                         #ERROR|null
Stream.isErrored
 (ISTREAM|OSTREAM|RSTREAM|WSTREAM)->BOOL        #True on error

ISTREAM|OSTREAM.destroy                         #Destroy stream
 ([ERROR])->ISTREAM|OSTREAM                     #If no 'end|finish' yet, abort stream
                                                #If already destroyed, noop
                                                #Calls 'close', but not 'end|finish'
                                                #If ERROR, first calls 'error'
IOPTS|OOPTS.autoDestroy                         #BOOL. If true (def), call:
                                                #  - ISTREAM|OSTREAM.destroy() after 'end|finish'
                                                #  - ISTREAM|OSTREAM.destroy(ERROR) before 'error'
ISTREAM|OSTREAM.destroyed                       #BOOL. Whether ISTREAM|OSTREAM.destroy() called
IOPTS|OOPTS.destroy(ERROR|null, FUNC([ERROR]))  #On ISTREAM|OSTREAM.destroy()

ISTREAM[Symbol.asyncDispose]()->>       18.18.0*#Calls:
                                                #  - destroyed: noop
                                                #  - ended: ISTREAM.destroy()
                                                #  - otherwise: ISTREAM.destroy(ABORT_ERROR)
OSTREAM[Symbol.asyncDispose]()->>       20.16.0*#Same for OSTREAM
IOPTS|OOPTS.signal                              #ABORT_SIGNAL. Call destroy(ERROR) on ABORT_CONTROLLER.abort()
addAbortSignal                                  #On ABORT_CONTROLLER.abort(), call:
 (ABORT_SIGNAL, ISTREAM|OSTREAM|RSTREAM|WSTREAM)#  - ISTREAM|OSTREAM.destroy(ABORT_ERROR)
 ->STREAM                               18.16.0*#  - RSTREAM_CONTROLLER|WSTREAM_CONTROLLER.error(ABORT_ERROR)

ISTREAM.readable
OSTREAM.writable                                #BOOL. False after stream success|abort|error
Stream.isReadable(ISTREAM|RSTREAM)->BOOL
Stream.isWritable(OSTREAM|WSTREAM)->BOOL        #False after stream success|abort|error
ISTREAM.readableAborted
OSTREAM.writableAborted                         #BOOL. True if stream aborted|errored

ISTREAM|OSTREAM.on("close", FUNC())             #Emitted after IOPTS|OPTS.destroy()
IOPTS|OOPTS.emitClose                           #BOOL (def: true). Whether 'close' is emitted
OSTREAM.closed                                  #BOOL. Whether 'close' called

finished(STREAM[, OPTS], FUNC([ERROR]))->FUNC2()#Call FUNC([ERROR]) on completion of STREAM which can be:
promises.finished(STREAM[, OPTS])->>            #  - ISTREAM|OSTREAM|REQ|RES
                                                #     - success: on 'end|finish'
                                                #     - error: on abort|error
                                        18.14.0*#  - RSTREAM
                                                #     - success: on close|cancel
                                                #     - error: on error
                                        18.14.0*#  - WSTREAM
                                                #     - success: on close
                                                #     - error: on abort|error
                                                #FUNC2() undoes it
                                                #  - should not be done if `error` might be emitter later, since that would create an uncaught exception
                                                #`this` inside FUNC is STREAM
                                                #OPTS:
                                                #  - error BOOL (def: true): if false:
                                                #     - ignore 'error' event
                                                #     - still call FUNC(ERROR) on abort
                                                #     - noop with RSTREAM|WSTREAM
                                                #  - signal ABORT_SIGNAL:
                                                #     - call FUNC(ABORT_ERROR) + FUNC2() on ABORT_CONTROLLER.abort()
                                                #        - unless FUNC() already called
                                                #     - but does not end|abort|error STREAM itself
                                                #  - cleanup BOOL (def: false): calls FUNC2() on FUNC()
                                                #  - readable|writable BOOL
                                                #     - def: guessed
                                                #     - meant to pass `false` to only listen to ISTREAM|OSTREAM when it is both

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

ENCODING ==>                                    #Only for STR
                                                #Always 'buffer' if UINT8ARR|BUFFER
                                                #Not used if objectMode

ISTREAM.push|unshift(SVAL, 'ENCODING')          #SVAL's ENCODING (def: 'utf8')
IOPTS.encoding                                  #Convert SVAL returned by IOPTS.read(), from SUBUFFER to:
ISTREAM.readableEncoding                        #  - 'ENCODING': STR
ISTREAM.setEncoding('ENCODING')->ISTREAM        #  - null (def): BUFFER
                                                #I.e. return value of ISTREAM.read()

OSTREAM.write|end(SVAL, 'ENCODING'[, ...])      #SVAL's ENCODING
OOPTS.defaultEncoding                           #Default 'ENCODING' for OSTREAM.write|end(STR)
OSTREAM.setDefaultEncoding('ENCODING')->OSTREAM #Def: 'utf8'
OOPTS.write(SVAL, 'ENCODING', ...)              #SVAL's ENCODING, as specified by OSTREAM.write|end()
OOPTS.decodeStrings                             #BOOL. If true (def), convert SVAL passed to OOPTS.write[v](), from SUBUFFER to BUFFER
                                                #I.e. always calls OOPTS.write(Buffer.from(SVAL, 'ENCODING'), 'buffer', ...)
                                                #If false, keep SVAL|'ENCODING' as is

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

IOPTS|OOPTS.objectMode                          #BOOL. Whether SVAL is:
ISTREAM.readableObjectMode                      #  - false (def): SUBUFFER
OSTREAM.writableObjectMode                      #  - true: any VAL
                                                #`null` has always special meaning:
                                                #  - ISTREAM: end
                                                #  - OSTREAM: not allowed
                                                #Must be same between ISTREAM -> OSTREAM
                                                #  - but not OSTREAM -> ISTREAM, e.g. Transform

IOPTS|OOPTS.highWaterMark                       #UINT. Max buffer size
ISTREAM.readableHighWaterMark                   #Unit is:
OSTREAM.writableHighWaterMark                   #  - objectMode: NUM of VALs
                                                #  - otherwise: NUM of bytes (BUFFER|UINT8ARR), chars (STR)
                                                #Increased to UINT2 when using ISTREAM.read(UINT2) with higher value
                                                #  - rounded up to power of 2
getDefaultHighWaterMark(BOOL)->NUM      18.17.0*#Default IOPTS|OOPTS.highWaterMark
setDefaultHighWaterMark(BOOL, NUM)      18.17.0*#BOOL is objectMode
                                                #Def: 16 in objectMode, 64KB otherwise
                                        <22.0.0*#  - 16KB before

ISTREAM.readableLength
OSTREAM.writableLength                          #NUM buffered

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

new Duplex([OPTS])                              #IOSTREAM. Pair of ISTREAM and OSTREAM not piped to each other
IOSTREAM.*                                      #Like ISTREAM|OSTREAM.*
IOSTREAM.destroyed                              #ISTREAM.* && OSTREAM.*
OPTS.*                                          #Like IOPTS|OOPTS.*, including objectMode|highWaterMark (applied to both)
OPTS.readable|writable*                         #Like IOPTS|OOPTS.objectMode|highWaterMark
OPTS.readable|writable                          #BOOL (def: true). If false, ends ISTREAM|OSTREAM
OPTS.allowHalfOpen                              #BOOL (def: true). If false, on ISTREAM 'end', call OSTREAM.end()

new Transform([OPTS])                           #TRANSFORM. Pair of ISTREAM and OSTREAM piped to each other
TRANSFORM.*                                     #Like IOSTREAM.*
OPTS.*                                          #Like IOSTREAM
OPTS.transform(SVAL, 'ENCODING',                #Combines IOPTS.read() and OOPTS.write() (which are implemented under the hood)
 FUNC(ERROR|null, SVAL2|null))                  #If SVAL2 is null, ignore it
                                                #If ISTREAM buffer full, OSTREAM.write() resolves only on next ISTREAM.read()
OPTS.flush(FUNC(ERROR|null, SVAL|null))         #Called on OSTREAM.end() success, at same time as OOPTS.final()
                                                #Calls OSTREAM.push(SVAL), unless null
                                                #Meant for data that should be only written at the end

new PassThrough([OPTS])                         #TRANSFORM with OPTS.transform keeping SVAL as is

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

ISTREAM.pipe(OSTREAM[, OPTS])->OSTREAM          #Does ISTREAM.on("data", SVAL => OSTREAM.write(SVAL))
                                                #Automatically handles backpressure:
                                                #  - if OSTREAM buffer full -> ISTREAM.pause()
                                                #  - ISTREAM.resume() at beginning, or on OSTREAM.on('drain'), or on ISTREAM.unpipe()
                                                #If OPTS.end true (def):
                                                #  - call OSTREAM.end() on ISTREAM success
                                                #  - except on process.stdout|stderr
ISTREAM.unpipe([OSTREAM])->ISTREAM              #Stops pipe() (def: all)
                                                #Automatically called on ISTREAM success (not abort|error) or OSTREAM success|abort|error
                                                #If no more pipes, calls ISTREAM.pause()
OSTREAM.on("[un]pipe", FUNC(ISTREAM))           #Fired by ISTREAM.[un]pipe()

pipeline(SRC[, TRANSFORM...], DEST,             #Like SRC.pipe(TRANSFORM)....pipe(DEST) except:
 FUNC(ERROR, SVAL)[, OPTS])->OSTREAM            #  - has a final FUNC() like finished()
promises.pipeline                               #  - if one STREAM aborts|errors then call other STREAMs destroy(ERROR)
 (STR[, TRANSFORM...], DEST[, OPTS])->>SVAL     #Can use streams or sync|async iterables:
                                                #  - SRC:
                                                #     - ISTREAM
                                        18.16.0*#     - RSTREAM|TSTREAM
                                                #     - [ASYNC_]ITERABLE (including STDBUFFER)
                                                #     - ASYNC_GENERATOR({ signal })
                                                #  - TRANSFORM:
                                                #     - IOSTREAM
                                        18.16.0*#     - TSTREAM
                                                #     - ASYNC_GENERATOR(ASYNC_ITERABLE, { signal })
                                                #  - DEST:
                                                #     - OSTREAM
                                        18.16.0*#     - WSTREAM
                                                #     - FUNC(ASYNC_ITERABLE)->>SVAL
                                                #Can use ARR of arguments [SRC, TRANSFORM..., DEST] instead of variadic arguments
                                                #OPTS:
                                                #  - signal ABORT_SIGNAL: call all ISTREAM|OSTREAM.destroy(ERROR) on ABORT_CONTROLLER.abort()
                                                #  - end BOOL (def: true): whether to DEST.end() on all SRCs|TRANSFORMs success

compose(VAL...)->IOSTREAM                       #Like pipeline() except returning an IOSTREAM that is not read|consumed right away
                                                #If single VAL, same as Duplex.from()
                                        18.16.0*#Including using RSTREAM|WSTREAM|TSTREAM
                                        20.10.0*#Including child CLASSes of those
ISTREAM.compose(VAL[, OPTS])->RSTREAM   18.16.0*#Like compose(ISTREAM, VAL)
                                        18.16.0*#OPTS:
                                        18.16.0*#  - signal ABORT_SIGNAL

duplexPair([OPTS])->IOSTREAM_ARR        20.17.0*#Returns 2 * new Duplex([OPTS])
                                        20.17.0*#When writing VAL to one IOSTREAM, calls IOSTREAM2.push(VAL) on the other
                                        20.17.0*#IOSTREAM's write success ('final') calls IOSTREAM2.push(null) and waits for its 'end'
                                        20.17.0*#I.e. "piped" to each other

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

Readable.from(SVAL_[ASYNC_]ITERABLE[, IOPTS])   #Repeats IOPTS.read() until buffer full, by iterating over ITERABLE.next()
 ->ISTREAM                                      #When ITERABLE done: ITERABLE.return() + end ISTREAM
                                                #When ITERABLE throws: ITERABLE.throw(ERROR) + ISTREAM.destroy(ERROR)
                                                #SVAL cannot be null
                                                #Def IOPTS:
                                                #  - objectMode: true
                                                #  - highWaterMark 1 (except when ITERABLE is STR|BUFFER)
                                                #Has performance shortcuts when ITERABLE is STR|BUFFER

Duplex.from(VAL)->IOSTREAM                      #Converts to IOSTREAM:
                                                #  (read-only)
                                                #  - ISTREAM: kept as is
                                        18.16.0*#  - RSTREAM: uses Readable.fromWeb() under-the-hood
                                                #  - [ASYNC_]ITERABLE: uses Readable.from() under-the-hood
                                                #     - including STDBUFFER
                                                #  - BLOB: same, using BLOB.arrayBuffer() under-the-hood
                                                #  - PROMISE_undefined: read no VAL
                                                #  (write-only)
                                                #  - OSTREAM: kept as is
                                        18.16.0*#  - WSTREAM: uses Writable.fromWeb() under-the-hood
                                                #  - FUNC()->>: write no VAL
                                                #  (read|write)
                                                #  - IOSTREAM: kept as is
                                                #  - ASYNC_GENERATOR(ASYNC_ITERABLE, { signal })
                                                #     - writing make `yield` return SVAL
                                                #     - reading gets `yield SVAL`
                                                #     - partially uses Readable.from() under-the-hood
                                                #  - TSTREAM: uses Duplexity.fromWeb() under-the-hood
                                                #  - OBJ: readable|writable VAL (any of the above types)
                                                #When read|write, unlike new Duplex():
                                                #  - DUPLEX end -> ISTREAM|OSTREAM end (but not reverse)
                                                #  - DUPLEX abort|error <-> ISTREAM|OSTREAM abort|error
                                                #  - OSTREAM abort|error -> ISTREAM abort|error (but not reverse)

                                  ┌─────────────────────┐
                                  │   STREAM READ ALL   │
                                  └─────────────────────┘

ISTREAM.iterator([OPTS])->SVAL_ASYNC_ITERATOR   #Repeatedly calls|returns ISTREAM.read()->SVAL until 'end'
                                                #On ISTREAM abort|error, throws
                                                #If OPTS.destroyOnReturn true (def): calls ISTREAM.destroy() before ITERATOR.return()
                                                #If ISTREAM has autoDestroy, calls ISTREAM.destroy(ERROR) before ITERATOR.throw(ERROR)
                                                #ASYNC_ITERATOR.stream is ISTREAM
ISTREAM[Symbol.asyncIterator]()                 #Same, but no OPTS
 ->SVAL_ASYNC_ITERATOR                          #I.e. ISTREAM is an SVAL_ASYNC_ITERABLE

ISTREAM.toArray([OPTS])->>ARR                   #Reads all values
                                                #OPTS:
                                                #  - signal ABORT_SIGNAL: throw ABORT_ERROR on ABORT_CONTROLLER.abort()

text(ISTREAM|RSTREAM|ASYNC_ITERABLE)->>STR
buffer(ISTREAM|RSTREAM|ASYNC_ITERABLE)->>BUFFER
blob(ISTREAM|RSTREAM|ASYNC_ITERABLE)->>BLOB
arrayBuffer                                     #See DOM doc
 (ISTREAM|RSTREAM|ASYNC_ITERABLE)->>ARRBUFFER   #Read whole input and convert it to another type
json(ISTREAM|RSTREAM|ASYNC_ITERABLE)->>VAL      #Like text() + JSON.parse()

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

ISTREAM.map                                     #Add a mapping function applied when reading values.
 (FUNC(VAL[, OPTS])[->[>]VAL[, OPTS2]])         #Does not read values itself.
 ->ISTREAM                                      #OPTS[2]:
                                                #  - signal ABORT_SIGNAL: throw ABORT_ERROR on ABORT_CONTROLLER.abort()
                                                #OPTS2:
                                                #  - concurrency NUM (def: 1)
                                        18.19.0*#  - highWaterMark NUM
                                                #     - def: OPTS2.concurrency - 1
                                                #     - always add OPTS2.concurrency to it
ISTREAM.filter
 (FUNC(VAL[, OPTS])[->[>]BOOL[, OPTS2]])
 ->ISTREAM                                      #Same but like ARR.filter()
ISTREAM.flatMap|some|every|reduce|forEach|find  #Same but like ARR.flatMap|some|every|reduce|forEach|find(FUNC(...), ...)
 (FUNC(...[, OPTS]), ...[, OPTS2])              #Same OPTS[2], except no OPTS2.highWaterMark
ISTREAM.drop|take(NUM[, OPTS])->ISTREAM         #Same but like ARR.drop|take(), i.e. exclude or only pick first NUM elements
                                                #OPTS: signal ABORT_SIGNAL

                                  ┌────────────────┐
                                  │   STREAM/WEB   │
                                  └────────────────┘

ReadableStream
ReadableStreamDefaultReader
ReadableStreamByobReader
WritableStream
WritableStreamDefaultWriter
TransformStream                                 #See DOM doc
ByteLengthQueuingStrategy                       #Global objects
CountQueuingStrategy                    20.17.0*#Can use RBSTREAM_READER.read()'s OPTS.min

ReadableStream.from(ASYNC_ITERABLE)
 ->RSTREAM                               20.6.0*#See DOM doc

Stream.Readable.fromWeb(RSTREAM[, ROPTS])
 ->ISTREAM                                      #ROPTS: only objectMode|highWaterMark|signal|encoding
Stream.Readable.toWeb(ISTREAM)->RSTREAM         #
Stream.Writable.fromWeb(WSTREAM[, WOPTS])
 ->OSTREAM                                      #WOPTS: only objectMode|highWaterMark|signal|decodeStrings
Stream.Writable.toWeb(OSTREAM)->WSTREAM         #
Stream.Duplex.fromWeb(TSTREAM[, OPTS])
 ->DUPLEX                                       #OPTS: only objectMode|highWaterMark|signal|encoding|decodeStrings|allowHalfOpen
Stream.Duplex.toWeb(DUPLEX)->TSTREAM            #

                                  ┌─────────┐
                                  │   TTY   │
                                  └─────────┘

ISTREAM|OSTREAM.isTTY
isatty(FD_INT)->BOOL                            #true|undefined if is READSTREAM|WRITESTREAM

ReadStream                                      #ISTREAM of a text terminal.
                                                #For process.stdin unless !isTTY
                                                #Child of TCPSOCKET, but without destroy(), connect event nor *address*
                                                #Will keep process alive until destroyed.
READSTREAM.isRaw                                #If false (def):
                                                #  - 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, CTRL-C, CTRL-Z
                                                #  - emit sounds (bell)
                                                #  - normalize any non-ASCII to ASCII (by removing MSB)
                                                #  - '\r\n' -> '\n'
                                                #In either case:
                                                #  - use replace mode (not insert mode)
                                                #  - no Emacs keybindings (CTRL-A, etc.)
                                                #  - can move cursor (Left|Right|Home|End)
READSTREAM.setRawMode(BOOL)                     #
READSTREAM.bytesRead                            #So far (including newlines)

WriteStream                                     #Same as READSTREAM but for OSTREAM of a text terminal
                                                #For process.stdout|stderr unless !isTTY
WRITESTREAM.columns|rows                        #UINT. Automatically updated.
                                                #Under the hood, uses OS-specific syscalls (ioctl on Unix, GetConsoleScreenBufferInfo() on Windows)
WRITESTREAM.getWindowSize()->[COL_NUM, ROW_NUM] #Returns WRITESTREAM.columns|rows
WRITESTREAM.on("resize", FUNC())                #Called when process.on('SIGWINCH'). Only differences:
                                                #  - it is on WRITESTREAM, i.e. only set if STREAM.isTTY
                                                #  - it is not emitted when terminal size did not change, e.g. signal was emitted programmatically

WRITESTREAM.getColorDepth([process.env])->NUM   #Number of bits per channel: 1|4|8|24
                                                #Used by console.*() and REPL
                                                #Based on heuristic on process.env and os.release():
                                                #  - terminal ENVVAR:
                                                #     - TERM:
                                                #        - 'dumb': 1 bit
                                                #        - 'screen*|xterm*|vt100*|rxvt*|*color*|*ansi*|cygwin|*linux*|*con*x*
                                                #          |eterm|cons25|console|cygwin|dtterm|gnome|hurd|jfbterm|konsole|kterm|mlterm|putty|st': 4 bits
                                                #        - 'xterm-256*': 8 bits
                                                #     - TERM_PROGRAM:
                                                #        - 'HyperTerm|MacTerm': 24 bits
                                                #        - 'Apple_Terminal': 8 bits
                                                #        - 'iTerm.app':
                                                #           - ENVVAR TERM_PROGRAM_VERSION with version >=3: 24 bits
                                                #           - otherwise: 8 bits
                                                #     - COLORTERM:
                                                #        - 'truecolor|24bit': 24 bits
                                                #        - otherwise: 4 bits
                                                #  - Windows, based on Windows 10 build:
                                                #     - >= 14931: 24 bits
                                                #     - >= 10586: 8 bits
                                                #     - otherwise: 4 bits
                                                #  - CI (ENVVAR CI defined):
                                                #     - ENVVAR TRAVIS|CIRCLECI|APPVEYOR|GITLAB_CI or CI_NAME 'codeship': 4 bits
                                                #     - ENVVAR TEAMCITY_VERSION recent: 4 bits (older: 1 bit)
                                                #  - otherwise: 1 bit
ENVVAR FORCE_COLOR=0|1|2|3                      #Force getColorDepth() to assume color support for 1|4|8|24 bits per channel
ENVVAR NO_COLOR=1                               #Same as FORCE_COLOR=0
ENVVAR NODE_DISABLE_COLORS=1                    #Same as FORCE_COLOR=0 but also change REPL (prefer NO_COLOR)
WRITESTREAM.hasColors([NUM][, process.env])     #Returns true if 2 ** getColorDepth([process.env]) >= NUM
 ->BOOL                                         #I.e. NUM should be 2 (2**1), 16 (2**4) (def), 256 (2**8) or 16 million (2**24)

                                  ┌──────────────┐
                                  │   READLINE   │
                                  └──────────────┘

INTERFACE                                       #Interactive TTY

createInterface(OPTS)->INTERFACE                #OPTS:
                                                #  - input ISTREAM
                                                #  - output OSTREAM
                                                #  - terminal BOOL (def: OSTREAM.isTTY):
                                                #     - do not use raw mode
                                                #     - handle sequences:
                                                #        - removing chars (Backspace|Delete|CTRL-H|D|U|K|W)
                                                #        - exiting (CTRL-C|D|Z)
                                                #        - moving cursor (Left|Right|Home|End|CTRL-A|E|B|F)
                                                #        - clear screen (CTRL-L)
                                                #     - use tab completion
                                                #     - use history
                                                #        - including history navigation (Up|Down|CTRL-N|P)
                                                #     - use emitKeypressEvents()
                                                #  - completer(STR[, FUNC(ERROR, ARR)])[->ARR]:
                                                #     - used to tab completion
                                                #     - ARR: [STR2_ARR, STR]
                                                #        - STR is original string
                                                #        - STR2_ARR are possible matches.
                                                #           - if have common prefix, autocompletes
                                                #  - historySize NUM (def: 30) (0 for none): in-memory, not persisted
                                                #  - removeHistoryDuplicates BOOL (def: false): new history lines that are duplicate
                                                #    of a previous one removes that older one
                                                #  - history STR_ARR (def: []): initial history
                                                #  - prompt STR (def: '> ')
                                                #  - crlfDelay NUM (def: 100, cannot be lower): if input reads \r and \n
                                                #    successively but more than NUMms apart, treat them as two newlines, not one
                                                #  - escapeCodeTimeout NUM (def: 500) (in ms): how long to wait when starting an ESC sequence
                                                #  - tabSize NUM (def: 8)
                                                #  - signal ABORT_SIGNAL: call INTERFACE.close() on abort
INTERFACE.close()                               #Called by ISTREAM.end() and CTRL-C|D|Z
INTERFACE.on("close", FUNC())                   #
INTERFACE[Symbol.dispose]()             18.18.0*#Calls INTERFACE.close()

FILE_HANDLE.readLines([OPTS])          18.11.0*#Like createInterface() but over a file
 ->INTERFACE                           18.11.0*#OPTS are passed to FS.createReadStream(OPTS)

INTERFACE.on("line", FUNC(STR))                 #Fired each time a line is read from ISTREAM.
INTERFACE[Symbol.asyncIterator]                 #Defined
INTERFACE.line                                  #STR input in the current line. Flushed after each newline/'line' event
INTERFACE.cursor                                #Cursor horizontal position within current line
INTERFACE.getCursorPos()->OBJ                   #Current cursor position in the screen. Takes into account wrapping.
                                                #OBJ: rows NUM, cols NUM

INTERFACE.write(STR[, OBJ])                     #Prints STR on OSTREAM
                                                #Use CTRL|META|SHIFT-STR if OBJ: ctrl|meta|shift: true, name: STR
                                                #Be careful as it will be read by ISTREAM, if ISTREAM and OSTREAM point to same thing (e.g. terminal).
                                                #  - like process.stdout.write(), but as opposed to console.*()

INTERFACE.setPrompt(STR)                        #Change OPTS.prompt (see above)
INTERFACE.getPrompt()->STR                      #
INTERFACE.prompt([BOOL])                        #Write in beginning of current OSTREAM line the OPTS.prompt
                                                #If false (def), move cursor back to beginning of line

INTERFACE.question(STR, [OPTS, ]FUNC(STR2))     #Replace current prompt by STR on OSTREAM, and fires FUNC(STR2) on line event instead of normal line event.
                                                #OPTS:
                                                #  - signal ABORT_SIGNAL: stop waiting on cancel

INTERFACE.pause|resume()                        #Like ISTREAM.pause|resume()
                                                #ISTREAM still accept input but buffers it, and reads it once resumed.
                                                #pause() is called by SIGCONT or SIGTSTP (CTRL-Z)
                                                #resume() is called by write(), prompt() and question()
INTERFACE.on("pause|resume", FUNC())            #
INTERFACE.on("SIGINT|SIGTSTP|SIGCONT", FUNC())  #

INTERFACE.on("history", FUNC(STR_ARR))          #When history changes
                                                #Can be used to edit history or persist it

clearLine(OSTREAM, NUM[, FUNC()])->BOOL         #Can be 0 (entire line, \e[2k) or -1|1 (to the left|right of cursor, \e[0k, \e[1k)
                                                #FUNC|BOOL are from the underlying OSTREAM.write()
cursorTo(OSTREAM, NUM, NUM2[,FUNC()])->BOOL     #Move cursor absolutely (\e[NUMa, \e[NUMb)
moveCursor(OSTREAM, NUM[, NUM2][,FUNC()])->BOOL #Move cursor relatively (\e[NUM2c, \e[NUM2d)
clearScreenDown(OSTREAM[, FUNC()])->BOOL        #Clear all following lines (\e0j). To clear screen, combine with cursorTo(OSTREAM, 0, 0)

emitKeypressEvents(ISTREAM[, INTERFACE])        #Enable ISTREAM.on('keypress')
                                                #If ISTREAM (e.g. process.stdin) is connected to an INTERFACE, should specify it to disable completion on copy-pasted input
                                                #ISTREAM must be in raw mode.
ISTREAM.on('keypress', FUNC(STR, OBJ))          #STR is what to print (e.g. 'a', undefined or '') (for a, LeftArrow and CTRL-C)
                                                #OBJ:
                                                #  - name STR (e.g. 'a' or 'pageup')
                                                #  - sequence STR (e.g. 'a' or '\x1B[5~')
                                                #  - code STR (e.g. 'a' or '[5~')
                                                #  - shift|ctrl|meta BOOL
                                                #Can use ESC sequences
                                                #As opposed to 'data', it is for each character, not for bulk:
                                                #  - e.g. when copy-pasting, 'data' will be emitted once but 'keypress' once per character
                                                #Under the hood, it actually adds a 'data' event handler:
                                                #  - i.e. it puts ISTREAM in flowing mode
                                                #  - i.e. to undo must do ISTREAM.off('keypress') then ISTREAM.pause()

READLINE.promises
require('readline/promises')                    #P_READLINE
P_READLINE.createInterface([OPTS])              #Like INTERFACE except:
 ->P_INTERFACE                                  #  - no OPTS.signal
                                                #  - question() return PROMISE
new P_READLINE.Readline                         #P_READLINE_I. Like readline.*:
 (OSTREAM[, OPTS])->READLINE                    #  - for clearLine|cursorTo|moveCursor|clearScreenDown(...)
                                                #  - but:
                                                #     - buffers all calls until commit()->PROMISE or rollback()
                                                #     - does not use FUNC callbacks
                                                #OPTS:
                                                #  - autoCommit BOOL (def: false): if true, call commit() after each READLINE.*
READLINE.commit()->PROMISE                      #
READLINE.rollback()                             #

                                  ┌──────────┐
                                  │   REPL   │
                                  └──────────┘

REPLSERVER                                      #Child of INTERFACE, meant for read-eval-print loop.

start([OPTS])->REPLSERVER                       #Forwards to INTERFACE:
                                                #  - forwards OPTS.input|output|prompt|historySize|terminal|completer
                                                #  - def OPTS.input|output is process.stdin|stdout
                                                #  - def OPTS.completer is JavaScript autocompletion
                                                #OPTS:
                                                #  - eval(STR, CONTEXT, FILENAME, FUNC(ERROR, VAL)):
                                                #     - input handler:
                                                #        - STR is input (including final newline)
                                                #        - VAL is passed to OPTS.writer()
                                                #        - FILENAME is 'repl' if default REPL
                                                #        - if ERROR is new Recoverable(''), keep prompt ongoing (e.g. for multiline input)
                                                #           - current input is added to next input
                                                #     - def:
                                                #        - VM.createScript(STR, {filename: FILENAME, displayErrors: true})
                                                #        - then SCRIPT.runInContext(REPLSERVER.context, {breakOnSigint: OPTS.breakEvalOnSigint, displayErrors: true})
                                                #  - writer(VAL)->STR:
                                                #     - serialization
                                                #     - def: util.inspect() using util.inspect.defaultOptions except:
                                                #        - showProxy true
                                                #        - colors OPTS.useColors (def: process.stdout.hasColors())
                                                #  - ignoreUndefined BOOL (def: false): if true, doesn't print output when it is undefined
                                                #  - useGlobal BOOL (def: false): see below
                                                #  - replMode either:
                                                #     - REPL_MODE_STRICT: "use strict"
                                                #     - REPL_MODE_SLOPPY (def): inverse
                                                #  - breakEvalOnSigint BOOL: if true (def: false), stops on CTRL-C
                                                #  - preview BOOL (def: true): show autocomplete and output preview
REPLSERVER.on("exit", FUNC())                   #
REPLSERVER.on("reset", FUNC())                  #When ".clear" or resetContext() is called.

REPLSERVER.context                              #Global CONTEXT object
                                                #If OPTS.useGlobal false (def):
                                                #  - is a new CONTEXT (using VM.createContext())
                                                #  - contains all core modules, e.g. GLOBAL.child_process
                                                #Also contains the following:
_                                               #Last expression evaluated
_error                                          #Last uncaught exception

REPL COMMANDS ==>                               #
.exit
CTRL-D                                          #
.break
CTRL-C                                          #
.editor                                         #Start multiline session
REPLSERVER.resetContext()
.clear                                          #Reinitialize REPLSERVER.context
.help                                           #
REPLSERVER.defineCommand                        #Custom .COMMAND [...ARGS]
 ('COMMAND', OBJ|FUNC(...ARGS))                 #OBJ:
                                                #  - action(...ARGS)
                                                #  - help STR
REPLSERVER.displayPrompt([BOOL])                #Like INTERFACE.prompt(BOOL) except if there is currently some input, use '...' prompt instead
                                                #Meant to be used inside defineCommand() OBJ.action()
REPLSERVER.clearBufferedCommand()               #Discard|ignore the line currently entered
                                                #Meant to be used inside defineCommand() OBJ.action()

REPLSERVER.setupHistory                         #Must be called to use history.
 ('PATH', FUNC(ERROR, REPLSERVER))              #Can search for history using CTRL-R
.save FILE                                      #Save all input so far to FILE
.load FILE                                      #Input FILE

DEFAULT REPL ==>                                #Uses REPL except:
                                                #  - calls REPLSERVER.setupHistory('PATH')
                                                #     - using ENVVAR NODE_REPL_HISTORY (def: ~/.node_repl_history)
                                                #  - OPTS.terminal can be set with ENVVAR NODE_NO_READLINE=1
                                                #  - OPTS.replMode can be set with ENVVAR NODE_REPL_MODE 'sloppy|strict'
                                                #  - OPTS.historySize can be set with ENVVAR NODE_REPL_HISTORY_SIZE (def: 1000)
                                                #  - OPTS.breakEvalOnSigint true
                                                #  - can override defaults util.inspect() options (for OPTS.writer()) with util.inspect.replDefaults

ENVVAR NODE_REPL_EXTERNAL_MODULE                #'PATH' to a file to execute instead of built-in REPL

                                  ┌───────────┐
                                  │   DGRAM   │
                                  └───────────┘

createSocket(STR|OPTS[, FUNC(BUFFER, OPTS)])    #OPTS:
 ->UDPSOCKET                                    #  - type "udp4|6"
                                                #  - reuseAddr BOOL (def: false): make UDPSOCKET.bind() reuse an address already bound
                                                #  - lookup FUNC (def: DNS.lookup)
                                                #  - recvBufferSize|sendBufferSize NUM: in|out buffer size
                                                #  - ipv6Only BOOL (def: false)
                                                #  - signal ABORT_SIGNAL: call close() on cancel
                                        22.12.0*#  - reusePort BOOL (def: false): like TCPSERVER.listen()
                                        22.13.0*#  - sendBlockList|receiveBlockList BLOCKLIST
                                                #STR is OPTS.type
                                                #FUNC is 'message' event handler.
UDPSOCKET.address()                             #{ address, port, family } (like TCPSERVER.address())

UDPSOCKET.bind(OBJ[, FUNC()])                   #Start listening. OBJ:
UDPSOCKET.bind(PORT_NUM[, 'ADDR'][, FUNC()])    #  - port PORT_NUM
                                                #  - address 'ADDR' (def: all available)
                                                #FUNC() is 'listening' event handler
                                                #Program will block until UDPSOCKET.close() is called. Can also use UDPSOCKET.[un]ref()
UDPSOCKET.on("listening", FUNC())               #After bind()
UDPSOCKET.on("message", FUNC(BUFFER, OBJ))      #OBJ is like UDPSOCKET.address()
UDPSOCKET.close([FUNC()])                       #FUNC is close event handler
UDPSOCKET.on("close", FUNC())                   #
UDPSOCKET[Symbol.asyncDispose]()        18.18.0*#Calls UDPSOCKET.close()
UDPSOCKET.on("error", FUNC(ERROR))              #

UDPSOCKET.connect(PORT_NUM[, 'ADDR'][, FUNC()]) #Connects to other port.
                                                #Def 'ADDR': '127.0.0.1' (udp4) or '::1' (udp6)
UDPSOCKET.disconnect()                          #
UDPSOCKET.on("connect", FUNC())                 #After connect()
UDPSOCKET.remoteAddress()->OBJ                  #OBJ: address, family, port (like TCPSERVER.address())

UDPSOCKET.send                                  #Sends to PORT_NUM, address 'ADDR'.
(STDUBUFFER[_ARR][, UINT, UINT2],               #Payload is first arg, from byte UINT, length UINT2
PORT_NUM, 'ADDR'[, FUNC(ERROR, UINT3)])         #If bind() has not been called, UDPSOCKET gets assigned a random port, and an adress "0.0.0.0"
                                                #When done, fires FUNC: UINT3 is the number of bytes sent.
                                                #Max. STDUBUFFER size is the MTU, which must be found with PMTUD.
                                                #'ADDR' is optional

UDPSOCKET.setRecv|SendBufferSize(NUM)           #
UDPSOCKET.getRecv|SendBufferSize()->NUM         #
UDPSOCKET.getSendQueueSize()->NUM               #
UDPSOCKET.getSendQueueCount()->NUM              #

UDPSOCKET.setBroadcast(BOOL)                    #
UDPSOCKET.setMulticastLoopback(BOOL)            #
UDPSOCKET.setMulticastInterface(STR)            #
UDPSOCKET.add|dropMembership(STR[, STR2])       #Routing options
UDPSOCKET.add|dropSourceSpecificMembership
 (STR3, STR[, STR2])                            #Same but specifies source STR3
UDPSOCKET.set[Multicast]TTL(UINT)               #

DIAGNOSTICS_CHANNEL.subscribe
 ('upd.socket', FUNC(OBJ))                      #OBJ: socket UDPSOCKET

                                  ┌─────────┐
                                  │   NET   │
                                  └─────────┘

createServer([OBJ, ][FUNC(TCPSOCKET)])          #FUNC is 'connection' event handler
 ->TCPSERVER                                    #OBJ:
                                                #  - allowHalfOpen BOOL: see below
                                                #  - pauseOnConnect BOOL (def: false): if true, calls TCPSOCKET.pause()
                                        18.17.0*#  - highWaterMark NUM: same as ISTREAM|OSTREAM
                                        22.13.0*#  - blockList BLOCKLIST

TCPSERVER.listen                                #Makes the TCSERVER:
(PORT_NUM|'PORT'[, 'ADDR'][, UINT][, FUNC()])   #  - listen to PORT_NUM|'PORT':
                                                #     - if 0, random port
                                                #     - can fire 'error' event with ERROR.code "EADDRINUSE" if another process
                                                #       already uses this port.
                                                #  - listen to 'ADDR':
                                                #     - def: INADDR_ANY, i.e. any available IP on the machine will work
                                                #  - UINT:
                                                #     - max number of pending connections, i.e. TCP sent SYN packet, but not
                                                #       ACK yet.
                                                #     - refuse connection if above max.
                                                #     - def: 511 (which is pretty ok)
                                                #     - OS limits are determined by sysctl settings like tcp_max_backlog
                                                #       and somaxconn (which is 511 in my system)
                                                #  - FUNC is 'listening' event hander
                                                #Can only be called once.
TCPSERVER.listen('PATH'[, UINT][, FUNC()])      #Same but by explictely creating a socket at 'PATH' (should be in /tmp)
TCPSERVER.listen(OBJ[, UINT][, FUNC()])         #Same but for either:
                                                #  - { fd: UINT }: with file descriptor, not on Windows
                                                #  - TCPSERVER|TCPSOCKET
TCPSERVER.listen(OBJ[, FUNC()])                 #Same with OBJ:
                                                #  - port, host, path, backlog UINT
                                                #  - readableAll|writableAll BOOL (def: false): file permission for the socket
                                                #  - ipv6Only BOOL (def: false)
                                                #  - signal ABORT_SIGNAL: call close() on abort
                                        22.12.0*#  - reusePort BOOL (def: false):
                                                #     - allow multiple clients to connect to same port, with OS distributing it
                                                #     - only for specific OS (mostly recent Linux)
TCPSERVER.on("listening", FUNC())               #Fired when listen() is called.
TCPSERVER.listening                             #BOOL
TCPSERVER.close([FUNC()])                       #Stops the server from accepting new connections:
                                                #  - keeps existing ones
                                                #  - when existing ones have stopped, emits "close" event
                                                #FUNC is 'close' event listener
TCPSERVER.on("close", FUNC())                   #Fired on TCPSERVER.close()
TCPSERVER[Symbol.asyncDispose]()        18.18.0*#Calls TCPSERVER.close()
TCPSERVER.address()->OBJ                        #Returns OBJ:
                                                #  - port UINT
                                                #  - address STR
                                                #  - family 'IPv4|IPv6'
                                  18.0.0-18.3.0*#     - 4|6 instead
                                                #After listen() has been called
TCPSERVER.[un]ref()->TCPSERVER                  #Yield the macrotask (see JavaScript doc)
                                                #listen() call ref(), and stop() or stop event handlers call unref()

TCPSERVER.on("connection", FUNC(TCPSOCKET))     #Fired when a TCP connection is initiated.
TCPSERVER.on("error", FUNC(ERROR))              #Fired when connection problem. Will fire TCPSERVER.close()
TCPSERVER.maxConnections                        #Def: null
                                                #Above that, will refuse connections.
                                                #0|null drops current ones
                                        <21.0.0*#  - previously meant no limits.
TCPSERVER.dropMaxConnections             23.1.0*#BOOL. If false (def), TCPSERVER.maxConnections is disabled with CLUSTER
TCPSERVER.on("drop", FUNC(OBJ))                 #When connection refused due to maxConnections. OBJ:
                                                #  - local|remotePort UINT
                                                #  - local|remoteAddress STR
                                                #  - remoteFamily 'IPv4|IPv6'
TCPSERVER.getConnections([FUNC(ERROR, UINT)])   #Number of connections

DIAGNOSTICS_CHANNEL.subscribe
 ('net.server.socket', FUNC(OBJ))               #OBJ: socket TCPSOCKET
DIAGNOSTICS_CHANNEL.subscribe
 ('net.server.listen:asyncStart',
 FUNC(OBJ))                             20.16.0*#OBJ: server TCPSERVER, options OBJ. On TCPSERVER.listen(OBJ) start
DIAGNOSTICS_CHANNEL.subscribe
 ('net.server.listen:asyncEnd',
 FUNC(OBJ))                             20.16.0*#OBJ: server TCPSERVER. On TCPSERVER.listen() success
DIAGNOSTICS_CHANNEL.subscribe
 ('net.server.listen:error', FUNC(OBJ)) 20.16.0*#OBJ: server TCPSERVER, error ERROR. On TCPSERVER.listen() failure

connect|createConnection(OPTS[, FUNC()])        #Same as new Socket(OPTS) followed by TCPSOCKET.connect(OPTS, FUNC)
  ->TCPSOCKET                                   #OPTS can also have:
                                                #  - timeout NUM: calls TCPSOCKET.setTimeout(NUM)
TCPSOCKET                                       #IOSTREAM but:
                                                #  - no readable event, read() or unshift() (but still data event)
                                                #  - nothing about piping
                                                #  - close event handler: FUNC(BOOL): true if close because of error
                                                #  - error event handler: FUNC(ERROR)
new Socket([OBJ])                               #OBJ:
                                                #  - fd: UINT
                                                #  - readable|writable BOOL (def: false): only when fd was used
                                                #  - allowHalfOpen BOOL (def: false):
                                                #     - if true, when other socket closes connection, doesn't automatically
                                                #       call end()
                                                #     - which means:
                                                #        - can still write to it (but non-readable)
                                                #        - must manually call end()
                                                #  - signal ABORT_SIGNAL: call destroy() on abort
TCPSOCKET.connect(ARGS[, FUNC()])               #ARGS:
                                                #  - OBJ:
                                                #     - port PORT_NUM|'PORT'
                                                #     - host 'ADDR'
                                                #     - localAddress|localPort
                                                #     - localFamily 'IPv4|v6'
                                        18.13.0*#     - autoSelectFamily BOOL (def: false):
                                                #        - attempts at guessing OPTS.localFamily by trying to connect with each
                                                #        - might result in connection* events emitted multiple times
                                        18.13.0*#     - autoSelectFamilyAttemptTimeout NUM (in ms, def: 250)
                                                #     - noDelay BOOL: if false (def), use Nagle's algorithm (see TCP doc)
                                        22.13.0*#     - blockList BLOCKLIST
                                                #     - keepAlive BOOL (def: false): TCP keepalive
                                                #     - keepAliveInitialDelay NUM (def: 0)
                                                #     - path 'PATH' (only for UNIX sockets, only option then)
                                                #     - onread OBJ:
                                                #        - callback(NUM, BUFFER)[->BOOL]:
                                                #           - called on new data
                                                #           - NUM is BUFFER length
                                                #           - can return false to pause
                                                #        - buffer BUFFER|UINT8ARR[()]: to store each data chunk
                                                #     (see DNS.lookup())
                                                #     - family 4|6|null
                                                #     - hints
                                                #     - lookup (def: DNS.lookup())
                                                #  - HOST[, PORT]
                                                #  - "PATH"
                                                #FUNC() is 'connect' event handler.
TCPSOCKET.pending                               #BOOL: true before connect() or before 'connect' event
TCPSOCKET.connecting                            #BOOL: true after connect() but before 'connect' event
TCPSOCKET.on                                    #Fired after hostname resoution, but before TCP connection.
 ('lookup', FUNC(ERROR, 'IP', VAL, 'HOST'))     #VAL is family 4|6|null
TCPSOCKET.on('connectionAttempt',
 FUNC(ERROR, 'IP', PORT_NUM, 4|6))              #Connection start
TCPSOCKET.on('connect', FUNC())         20.12.0*#Connection success
TCPSOCKET.on('connectionFailed',
 FUNC(ERROR, 'IP', PORT_NUM, 4|6))      20.12.0*#Connection failure, except timeout
TCPSOCKET.on('connectionTimeout',
 FUNC(ERROR, 'IP', PORT_NUM, 4|6))      20.12.0*#Connection failure, timeout
TCPSOCKET.on('ready', FUNC())                   #
TCPSOCKET.destroy([ERROR])                      #No more read|write. Only necessary when error happened.
                                                #If ERROR, 'error' event is fired
TCPSOCKET.destroyed                             #BOOL
TCPSOCKET.resetAndDestroy()->TCPSOCKET          #Send RST packet thn TCPSOCKET.destroy()
TCPSOCKET.[un]ref()->TCPSOCKET                  #Like TCPSERVER

--no-network-family-autoselection        20.0.0*#Like setDefaultAutoSelectFamily(false)
--enable-network-family-autoselection   18.18.0*#Like setDefaultAutoSelectFamily(true)
setDefaultAutoSelectFamily(BOOL)        18.18.0*#Change default value of ARGS.autoSelectFamily BOOL of TCPSOCKET.connect()
getDefaultAutoSelectFamily()->BOOL      18.18.0*#Default is:
                                         20.0.0*#  - true
                                        18.18.0*#  - previously was false
setDefaultAutoSelectFamilyAttemptTimeout
 (NUM)                                  18.18.0*#Change default value of ARGS.autoSelectFamilyAttemptTimeout NUM of TCPSOCKET.connect()
getDefaultAutoSelectFamilyAttemptTimeout
 ()->NUM                                18.18.0*#
--network-family-autoselection-attempt
 -timeout                               20.13.0*#
TCPSOCKET.                              18.18.0*#'IP:PORT' attempted by ARG.autoSelectFamily
 autoSelectFamilyAttemptedAddresses     18.18.0*#undefined if ARG.autoSelectFamily false

TCPSOCKET.setTimeout(UINT[, FUNC()])->TCPSOCKET #Emits timeout event after UINTms of idleness.
                                                #Not emitted after TCPSOCKET is destroyed.
                                                #0 (def) disables.
                                                #By def, timeout handler does not do anything, but can end|destroy()
                                                #FUNC is 'timeout' event handler
                                                #Uses setTimeout(), i.e. done at macrotask level, i.e. might take longer than
                                                #UINTms if long macrotasks.
                                                #Error handling:
                                                #  - exceptions thrown in FUNC are uncaught exceptions.
                                                #  - TCPSOCKET.emit('error', ERROR) is usually better
TCPSOCKET.on('timeout', FUNC())                 #

TCPSOCKET.setNoDelay(BOOL)->TCPSOCKET           #Like OPTS.noDelay
TCPSOCKET.setKeepAlive(BOOL, UINT)->TCPSOCKET   #Like OPTS.keepAlive[InitialDelay]
TCPSOCKET.bytesRead|Written                     #So far

TCPSOCKET.address()->OBJ                        #Like TCPSERVER
TCPSOCKET.local|remotePort|Address              #
TCPSOCKET.remoteFamily                          #'IPv4|6'
isIp('ADDR')->0|4|6                             #
isIpv4|6('ADDR')->BOOL                          #

new SocketAddress([OPTS])                       #OPTS: address, family, flowlabel, port
SocketAddress.parse('IPv4|v6[:PORT]')
 ->SOCKET_ADDRESS                       22.13.0*#
SOCKET_ADDRESS.address                          #STR (def: '127.0.0.1' or '::' depending on whether 'ipv4|ipv6  ')
SOCKET_ADDRESS.family                           #'ipv4' (def) or 'ipv6'
SOCKET_ADDRESS.flowlabel                        #NUM (IPv6 only)
SOCKET_ADDRESS.port                             #NUM

new BlockList()                                 #
BlockList.isBlockList(VAL)->BOOL        22.13.0*#
BLOCKLIST.rules                                 #Read-only STR_ARR among:
                                                #  - 'Address: TYPE ADDRESS'
                                                #  - 'Range: TYPE ADDRESS-ADDRESS2'
                                                #  - 'Subnet: TYPE ADDRESS/CIDR'
                                                #TYPE is 'ipv4|ipv6'
                                                #The following methods add to it.
ADDRESS                                         #Either 'ADDRESS' or SOCKET_ADDRESS
BLOCKLIST.addAddress
 (ADDRESS[, 'TYPE'])                            #
BLOCKLIST.addRange
 (ADDRESS, ADDRESS2[, 'TYPE'])                  #
BLOCKLIST.addSubnet
 (ADDRESS, CIDR_NUM[, 'TYPE'])                  #
BLOCKLIST.check(ADDRESS[, 'TYPE'])
 ->BOOL                                         #True if ADDRESS match at least one BLOCKLIST.rules

DIAGNOSTICS_CHANNEL.subscribe
 ('net.client.socket', FUNC(OBJ))               #OBJ: socket TCPSOCKET

                                  ┌─────────┐
                                  │   TLS   │
                                  └─────────┘

getCiphers()->STR_ARR                           #All suite of SSL ciphers are [PREFIX-]ALGO[-HASH]
                                                #ALGO: AES128|256, 3DES, DES, Camellia128|256, IDEA, RC4, SEED
                                                #PREFIX:
                                                #  - ECDH[E]-ECDSA|RSA: for AES, DES, RC4
                                                #  - DH[E]-DSS|RSA: for AES, Camellia, SEED
                                                #  - EDH-DSS|RSA: for DES
                                                #  - PSK: for AES, 3DES, RC4
                                                #  - SRP-[DSS|RSA]: for AES, 3DES
                                                #HASH ([-]#ALGO means ALGO with[out] PREFIX SPK|SRP):
                                                #  - sha: -#AES*, Camellia*, RC4, SEED
                                                #  - gcm-sha256: -#AES128
                                                #  - gcm-sha384: -#AES256
                                                #  - sha256: -#AES*
                                                #  - cbc3-sha: -#DES
                                                #  - cbc-sha: IDEA, #AES
                                                #  - md5: RC4 (unless any PREFIX)
                                                #  - ede-cbc-sha: #DES
                                                #Can be changed with node --tls-cipher-list=LIST
TLSSOCKET.getSharedSigalgs()->STR_ARR           #Returns SSL ciphers for signatures shared by client and server, ordered by preference
TLSSOCKET.getEphemeralKeyInfo()->OBJ            #Gets information about cipher's (only [EC]DH) use of perfect forward secrecy:
                                                #  - type '[EC]DH'
                                                #  - name STR
                                                #  - size NUM
--tls-default-ciphers=STR,...                   #Default value for OBJ.ciphers of createSecureContext()
TLS.DEFAULT_CIPHERS                     18.16.0*#

TLS.createSecureContext(OBJ)->SECURECONTEXT     #OBJ:
                                                #  - key STR[_ARR]|BUFFER|OBJ_ARR:
                                                #     - server private key, in PEM format
                                                #     - OBJ is { pem STR|BUFFER, passphrase STR }
                                                #        - passphrase is optional
                                                #  - cert STR[_ARR]|BUFFER[_ARR]: server certificate, in PEM format
                                                #  - pfx STR[_ARR]|BUFFER[_ARR]|OBJ_ARR:
                                                #     - key+cert+ca in PFX or PKCS12 format
                                                #     - OBJ is { buf STR|BUFFER[, passphrase STR] }
                                                #  - ca STR[_ARR]|BUFFER[_ARR]:
                                                #     - list of root certificates, in PEM format
                                                #     - def: TLS.rootCertificates
                                                #     - otherwise, can be used to authorize self-signed certificates
                                        20.18.0*#  - allowPartialTrustChain BOOL (def: false): trust intermediate certificates
                                                #  - passphrase STR: passphrase used to decrypt the server private key (when a private key is encrypted)
                                                #  - crl STR[_ARR]: CRLs, in PEM format
                                                #  - secureProtocol STR:
                                                #     - "SSLv2|3|TLSv1_[client|server_]method": forces SSL version for client and|or server
                                                #        - no client|server means both
                                                #     - def: uses the best one accepted by client
                                                #  - honorCipherOrder BOOL:
                                                #     - if true, server will choose cipher preference, not client
                                                #     - list is designated by ciphers STR
                                                #     - def: false, but true recommended
                                                #  - ciphers STR:
                                                #     - defaults to "*AES*:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA"
                                                #     - AES are in order: 128 > 256, SHA384 > SHA256, ECDHE > DHE, RSA > ECDSA
                                                #  - sigalgs 'STR:...': same for signature algorithms
                                                #  - sessionTimeout (def: 300, in sec): expiration for TLS identifiers and session tickets
                                                #  - ticketKeys BUFFER: 48 bytes divided in three 16 bytes parts: prefix, HMAC, AES key
                                                #     - can use TLSSERVER.getTicketKeys()->BUFFER and TLSSERVER.setTicketKeys(BUFFER)
                                                #  - sessionIdContext STR:
                                                #     - STR concatened in front of SSL session ID.
                                                #     - if requestCert is true, it is a MD5 nonce. Otherwise, it is "".
                                                #  - ecdhCurve STR (def: "auto"): for ECDH
                                                #  - dhparam STR|BUFFER:
                                                #     - for DH
                                        18.16.0*#     - can also be 'auto'
                                                #  - secureOptions { CRYPTO.SSL_OP_*: VAL }: OpenSSL options
                                                #  - min|maxVersion 'TLSv1[.1|2|3]'
                                                #     - def: TLS.DEFAULT_MIN|MAX_VERSION (def: 'TLSv1.2|3')
                                                #     - can be set with --tls-min|max-v1.0|1|2|3
                                                #     - TLSv1.3 only for Node >=11
                                                #  - enableTrace BOOL (def: false): print TLS packets to stderr, for debugging
                                                #  - hints NUM: like DNS.lookup()
TLS.rootCertificates                            #STR_ARR. Default well-known root CAs
                                                #Are known builtin, either:
                                                #  - node --use-bundled-ca (def): Mozilla CA store
                                         23.8.0*#  - node --use-system-ca: local machine
                                                #     - not on Linux
                                                #  - node --use-openssl-ca:
                                                #     - OpensSSL CA store, modified by distributions, can be modified by ENVVARs
                                                #     - can use ENVVAR SSL_CERT_DIR=DIR and SSL_CERT_FILE=FILE
                                                #Can also be augmented with ENVVAR NODE_EXTRA_CA_CERTS=FILE
TLS.getCACertificates([STR])->STR2_ARR  23.10.0*#Like TLS.rootCertificates, but only for specific type STR:
                                        23.10.0*#  - 'bundled': like --use-bundled-ca
                                        23.10.0*#  - 'system': like --use-system-ca
                                        23.10.0*#  - 'extra': like NODE_EXTRA_CA_CERTS
                                        23.10.0*#  - 'default' (def): all of the above

TLSSERVER                                       #Child of TCPSERVER:
                                                #  - since it inherits from TCPSERVER, can accept TCP connections, not only SSL ones.
                                                #  - all TLSSERVER will fire for both SSL and normal TCP connections.
                                                #Authorization:
                                                #  - if rejectUnauthorized is true:
                                                #     - non-authorized SSL are still accepted (and communication is encrypted)
                                                #     - but can be checked as non-authorized
                                                #  - certificate check will follow CA chain until CA roots:
                                                #  - authorization also checks the domain in certificate === host being connected
createServer(OBJ[, FUNC(TLSSOCKET)])->TLSSERVER #OBJ:
                                                #  - any SECURECONTEXT.* property
                                                #  - any NET.createServer() options
                                                #  - requestCert BOOL (def: false): request authentication (with certificate) of other end (i.e. client)
                                                #  - rejectUnauthorized BOOL (def: true): throw error to other end if cannot authentify it
                                                #  - handshakeTimeout (def: 120000, in ms): when timing out, emits tlsClientError
                                                #  - ALPNProtocols SUBUFFER[_ARR]: list of application protocols that can be used, ordered by priority.
                                        18.19.0*#  - ALPNCallback(OBJ)[->STR]:
                                        18.19.0*#     - like ALPNProtocols, but with custom logic
                                        18.19.0*#     - called on client connection with ALPN request
                                        18.19.0*#     - OBJ: servername STR, protocols STR_ARR
                                        18.19.0*#     - must return a protocol, or undefined
                                                #  - SNICallback('HOST', FUNC(ERROR, OBJ)):
                                                #     - when client asks for SNI, calls it with requested server 'HOST'
                                                #        - if success, must call FUNC(null, OBJ2), where OBJ2 is TLSSOCKET.secureContext
                                                #     - can also use TLSSERVER.addContext('HOST', SECURECONTEXT)
                                                #FUNC is 'secureConnection' event handler
TLSSERVER.setSecureContext(OBJ)                 #OBJ: any SECURECONTEXT.* property
TLSSERVER.on("secureConnection",FUNC(TLSSOCKET))#Like TCPSERVER.on("connection"), but for SSL.
                                                #Only fired by SSL connections, not normal TCP ones.
TLSSERVER.on
("tlsClientError", FUNC(ERROR, TLSSOCKET))      #See handshakeTimeout
TLSSERVER.on("newSession",FUNC(ID,DATA,FUNC2()))#Fired when client creates new session: ID is the session ID, DATA the shared secret.
                                                #Must fire FUNC2 when done
TLSSERVER.on("resumeSession",                   #Fired when client wants to resume a session. Must call FUNC2() to do so:
FUNC(ID, FUNC2(ERROR, DATA)))                   #  - DATA is the one stored with newSession event
                                                #  - if no new session, ERROR|DATA should be null

connect([PORT_NUM[,'HOST']]OBJ[,FUNC(TLSSOCKT)])#Like TCP.connect(), but for TLS (client connection). OBJ members are:
  ->TLSSOCKET                                   #  - secureContext SECURECONTEXT or SECURECONTEXT.* directly
                                                #  - rejectUnauthorized, ALPNProtocols: like createServer()
                                                #     - except rejectUnauthorized is true by def.
                                                #  - session: like new TLSSocket()
                                                #  - timeout: like TCP.connect() OPTS.timeout
                                                #  - host 'HOST', port PORT_NUM, path 'PATH'
                                                #  - socket TCPSOCKET|IOSTREAM: use an existing TCPSOCKET (host+port can be ommitted then)
                                                #  - onread OBJ: like TCPSOCKET.onread
                                                #  - servername: for SNI, hostname to choose
                                                #  - checkServerIdentity('HOST', CERT_BUFFER): if throw error, refuse connection
                                                #  - minDHSize NUM (def: 1024)
                                                #  - lookup FUNC: DNS lookup, def: DNS.lookup()
                                                #  - allowHalfOpen: like NET.createServer()
                                                #  - pskCallback('HINT')->{ psk TDBUFFER, identity STR }|null
                                                #  - highWaterMark NUM
                                                #FUNC is 'secureConnect' event handler
                                                #Returns a TLSSOCKET.

TLSSOCKET                                       #Child of TCPSOCKET, but for SSL.
                                                #Contains other end's authentication status and certificate, providing requestCert: true has been used.
new TLSSocket(TCPSOCKET, OBJ)                   #OBJ:
                                                #  - secureContext SECURECONTEXT or SECURECONTEXT.* directly
                                                #  - requestCert, rejectUnauthorized, ALPNProtocols, SNICallback: like createServer()
                                                #  - session BUFFER
                                                #  - requestOCSP BOOL (def: false):
                                                #     - OCSP is alternative protocol to use CRL
                                                #        - ask to Certificate authority instead of using CRL list
                                                #     - TLSSERVER.on('OCSPRequest', FUNC(BUFFER, BUFFER2, FUNC(ERROR, BUFFER3))):
                                                #        - BUFFER[2] are primary|issuer DER-encoded certificates
                                                #        - BUFFER3: see just below
                                                #     - TLSSOCKET.on('OCSPResponse', FUNC(BUFFER3))
                                                #  - isServer BOOL
                                                #  - server TCPSERVER
TLSSOCKET.on("secureConnect", FUNC())           #Like TCPSOCKET.on("connect"), but for SSL.
TLSSOCKET.on('session', FUNC(BUFFER))           #On new TLS session|ticket.
                                                #Same BUFFER as connect() and new TLSSocket() OPTS.session
TLSSOCKET.getPeerCertificate([BOOL])->OBJ       #Returns other end's certificate.
                                                #OBJ:
                                                #  - subject, issuer, valid_from|to, fingerprint[256], pubkey, etc.
                                         19.1.0*#  - ca BOOL
                                                #If true, returns full chain, i.e. OBJ.issuer
TLSSOCKET.getCertificate()->OBJ                 #Same but for current end.
TLSSOCKET.encrypted                             #Always true. To distinguish from TCPSOCKET.
TLSSOCKET.authorized                            #False if certificate was not signed by CA specified in ca: STR_ARR
                                                #If false, reason might be given in TLSSOCKET.authorizationError STR
TLSSOCKET.getCipher()->OBJ                      #Current SSL cipher used as OBJ:
                                                #  - name STR (e.g. 'AES128-SHA256')
                                                #  - standardName STR: IETF name (e.g. 'TLS_RSA_WITH_AES_128_CBC_SHA256')
                                                #  - version STR (e.g. 'TLSv1.2')
TLSSOCKET.getProtocol()->STR                    #Among 'SSLv3|TLSv1[.1|2]|unknown'
TLSSOCKET.alpnProtocol                          #Protocol selected among ALPNProtocols (see above)
TLSSOCKET.servername                            #For SNI, chosen 'HOST'
TLSSOCKET.renegotiate(OBJ[, FUNC(ERROR)])       #OBJ: rejectUnauthorized, requestCert
                                                #Automatically done after session expires:
                                                #  - TLS.CLIENT_RENEG_LIMIT (def: 3) times every TLS.CLIENT_RENEG_WINDOW (def: 600, in sec),
                                                #to avoid DDoS as it takes resources
TLSSOCKET.disableRenegotiation()                #
TLSSOCKET.setMaxSendFragment(NUM)->BOOL         #Def|max: 16384. Min: 512.
                                                #True on success.
                                                #Smaller: smaller latency but slower.
TLSSOCKET.getSession()->OBJ                     #OBJ: ASN.1 encoded
TLSSOCKET.getTLSTicket()->BUFFER                #
TLSSOCKET.get[Peer]Finished()->BUFFER           #Returns the "Finished" message, i.e. a hash of the handshake
TLSSOCKET.exportKeyingMaterial
 (NUM, STR[, BUFFER])->BUFFER2                  #Returns keying material, used to prevent some network attacks
TLSSOCKET.setKeyCert(OBJ)                22.5.0*#Sets TLS private key and certificate
                                         22.5.0*#OBJ is SECURECONTEXT.key|cert
                                         22.5.0*#Mostly meant for ALPNCallback

--trace-tls                                     #
TLSSOCKET.enableTrace()                         #Same as SECURECONTEXT.enableTrace

TLSSERVER.on
 ('keylog', FUNC(BUFFER, TLSSOCKET))            #TLS key in NSS SSLKEYLOGFILE format. Usually used with Wireshark to decrypt SSL traffic.
TLSSOCKER.on('keylog', FUNC(BUFFER))            #Can be emitted multiple times: concatenation of BUFFER is the whole file.
--tls-keylog=FILE                               #Same but written to a file

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

STATUS_CODES                                    #{ STATUS_NUM: 'STATUS_NAME', ... }
                                                #Misses 419
METHODS                                         #STR_ARR of HTTP methods, including common ones, WEBDEV and more obscure ones

HTTPSERVER                                      #Child of TCPSERVER
createServer([OPTS, ][FUNC()])->HTTPSERVER      #FUNC is 'request' event handler
                                                #OPTS:
                                                #  - IncomingMessage|ServerResponse FUNC: to replace constructors of REQ|RES
                                                #  - maxHeaderSize NUM: see --max-http-header-size
                                                #  - noDelay|keepAlive[InitialDelay]:
                                                #     - like TCPSOCKET.connect()
                                                #     - but noDelay default is true
                                                #  - requestTimeout|headersTimeout|keepAliveTimeout: like HTTPSERVER.*
                                                #  - connectionCheckingInterval NUM (in ms, def: 3e4, i.e. 30s): to check for headersTimeout|requestTimeout
                                                #  - uniqueHeaders 'VAR'_ARR: if those headers sent multiple times, joined with '; '
                                        20.16.0*#  - rejectNonStandardBodyWrites BOOL (def: false): does not allow response with body if HEAD, 204 or 304
                                        18.14.0*#  - joinDuplicateHeaders BOOL (def: false): join duplicate headers with ', ' instead of discarding them
                                        18.17.0*#  - highWaterMark NUM: like NET.createServer()
HTTPSERVER.on("request", FUNC(REQ, RES))        #Fired on client request
HTTPSERVER.on("checkContinue", FUNC(REQ, RES))  #Fired on client request with Expect: 100-continue [C]
                                                #If request is ok, should use RES.writeContinue() to sends a 100 status code
                                                #to the client.
HTTPSERVER[Symbol.asyncDispose]()       18.18.0*#Calls HTTPSERVER.close()
HTTPSERVER.closeAllConnections()         18.2.0*#Like HTTPSERVER.close() except existing connections are closed too
HTTPSERVER.closeIdleConnections()        18.2.0*#Same but only close idle connections
                                         19.0.0*#I.e. same as close()
HTTPSERVER.on                                   #Fired on client request with CONNECT method
("connect", FUNC(REQ, TCPSOCKET, BUFFER))       #Client's body is in BUFFER.
HTTPSERVER.on                                   #Fired on client request with Upgrade [C]
("upgrade", FUNC(REQ, TCPSOCKET, BUFFER))       #Client's body is in BUFFER.
HTTPSERVER.on("clientError",FUNC(ERR,TCPSOCKET))#Fired on connection problem.
                                                #Def: TCPSOCKET.destroy()
                                                #ERR has members:
                                                #  - bytesParsed NUM
                                                #  - rawPacket BUFFER

HTTPSERVER|REQ.maxHeadersCount                  #Maximum number of headers incoming (def: 2000, 0 for unlim)
HTTPSERVER.maxHeaderSize
--max-http-header-size NUM                      #Def: 16KB. If above, fires 'clientError'.
                                                #If no 'clientError' handler, returns 431.
HTTPSERVER.maxRequestsPerSocket                 #NUM (def: 0)
                                                #When reached, keeps connections open but:
                                                #  - Set Connection: closed [S] and
                                                #  - Respond to any new request with 503
HTTPSERVER.on
 ('dropRequest', FUNC(REQ, TCPSOCKET))          #When hitting HTTPSERVER.maxRequestsPerSocket

HTTPSERVER.setMaxIdleHTTPParsers                #NUM (def: 1000). Max number of idle HTTP parsers.

RES|CLIENTREQ.setTimeout(UINT[, FUNC()])        #Call underlying TCPSOCKET.*
RES|CLIENTREQ.on("timeout", FUNC())             #Unless 'timeout' event handler overriden, calls RES|CLIENTREQ.socket.destroy()
HTTPSERVER.setTimeout(UINT[, FUNC()])           #Calls RES.setTimeout(...) on each new RES
HTTPSERVER.timeout                              #Same
--http-server-default-timeout NUM               #Default value of HTTPSERVER.setTimeout|timeout
                                                #Def: 0, i.e. disabled
HTTPSERVER.on("timeout", FUNC(RES))             #Called when any RES 'timeout' event is fired
HTTPSERVER.headersTimeout                       #Like HTTPSERVER.timeout but for the time taken to receive HTTP headers.
                                                #Def: 6e4, i.e. one minute
                                        18.14.0*#or HTTPSERVER.requestTimeout, if smaller
HTTPSERVER.requestTimeout                       #Like HTTPSERVER.timeout but for the time taken to receive HTTP headers + body.
                                                #If over, sends 408
                                                #Def: 3e5 (5m)

HTTPSERVER.keepAliveTimeout                     #Keep TCPSOCKET NUMms (def: 5000) after RES.end() was called, so it can be
                                                #reused if a new request from same host arrives.
                                                #0 to disable.
                                                #It is different from REQ|CLIENTREQ|HTTPSERVER.timeout:
                                                #  - HTTPSERVER.timeout is for idleness while request is ongoing
                                                #  - HTTPSERVER.keepAliveTimeout is for idleness between requests
                                                #As long as TCPSOCKET is opened, TCPSOCKET.unref() won't be called, keeping the
                                                #server open.

CLIENTREQ.NoDelay|SocketKeepAlive(...)          #Call underlying TCPSOCKET.*

REQ                                             #ISTREAM, reading the body
REQ.httpVersion[Major|Minor]                    #
REQ.method                                      #"GET|DELETE|..." (not for CLIENTREQ's REQ)
REQ.url                                         #STR (not for CLIENTREQ's REQ). Does not include origin
REQ.host                                        #STR
REQ.protocol                                    #STR
REQ.headers                                     #As { VAR: 'VAL'[_ARR] ... }. Normalized:
                                                #  - 'VAR' lowercase
                                                #  - duplicates:
                                                #     - common ones are merged as 'VAL'
                                                #     - Set-Cookie: 'VAL'_ARR
                                                #     - others are joined with ','
REQ.headersDistinct                             #As { VAR: 'VAL'_ARR, ... }, normalized.
REQ.rawHeaders                                  #As [ 'VAR', 'VAL', ... ]. Not normalized
REQ.[raw]trailers                               #Same for trailer headers
REQ.trailersDistinct                            #Same for trailer headers
REQ.statusCode|Message                          #Only for CLIENTREQ's REQ
REQ.socket                                      #TCPSOCKET
REQ.flushHeaders()                              #Send the headers right away, instead of trying to send in same TCP packet as body.
                                                #Useful if headers are given quickly but body retrieval takes time.
REQ.destroyed                                   #BOOL
REQ.reusedSocket                                #BOOL. Whether underlying TCP has been used by another REQ before.
                                                #This can happen when using an AGENT with a high keepAliveMsecs.

RES                                             #OSTREAM, writing the body:
                                                #  - headers must be set first
                                                #  - write() sends to client
                                                #  - end() finishes
                                                #Automatically create following headers:
                                                #  - Date [S] (if RES.sendDate true (def))
                                                #  - Connection: keep-alive [S]
                                                #  - Transfer-Encoding: chunked [S]
RES.req                                         #REQ
RES.on("close", FUNC())                         #Fired if closed before end() was called
RES.headersSent                                 #True if headers are sent
RES.writableEnded                               #Same
RES.writableFinished                            #True if all sent + flushed
RES.statusCode|Message                          #If statusMessage not set, use STATUS_CODES[statusCode]
RES.setHeader('VAR', 'VAL'[_ARR])               #'VAL'_ARR: same as doing setHeader() several times.
                                                #'VAL' can only contain visible ASCII, \t or space
                                                #  - else should use encodeURIComponent()
                                                #  - this prevents header response splitting (see XSS doc)
RES.setHeaders(HEADERS|MAP)             18.15.0*#
RES.appendHeader('VAR', 'VAL'[_ARR])            #
RES.getHeader('VAR')->'VAL'[_ARR]               #
RES.getHeaderNames()->'VAR'_ARR                 #
RES.getRawHeaderNames()->'VAR'_ARR              #Same but without lowercasing
RES.getHeaders()->OBJ                           #
RES.hasHeader('VAR')->BOOL                      #
RES.removeHeader('VAR')                         #
RES.writeHead                                   #Sets RES.statusCode|Message|headers (must be done only once)
 (STATUS_NUM[, 'STATUS_NAME'][, HEADERS])->RES  #HEADERS is an OBJ|ARR
RES.addTrailers(OBJ)                            #Add trailing header fields, i.e. between write() and end() of the body.
                                                #Do not forget Trailer [C] at beginning of response
RES.writeProcessing()                           #Send 102 response
RES.writeEarlyHints(OBJ[, FUNC()])      18.11.0*#Send 103 response. OBJ are headers to send as hints.

ON-HEADERS(RES, FUNC())                        ##Fires FUNC() (with RES as this) just before RES starts sending headers
                                               ##Node module 'on-headers' (1.0.1)

CLIENTREQ                                       #Outgoing HTTP request (as opposed to incoming)
                                                #OSTREAM (like RES)
                                                #Headers:
                                                #  - Content-length [C]: only compatible with utf8 encoding for write()
                                                #  - Expect: 100-continue [C]:
                                                #     - call end() right away
                                                #     - should set a timeout
                                                #     - and listen to 'continue' event
                                                #  - default:
                                                #     - all:
                                                #         Host: HOST:PORT [C]
                                                #         Connection: keep-alive [C]
                                                #     - not GET|HEAD:
                                                #         Transfer-Encoding: chunked [C]
request(['URI'|URI][, OBJ][, FUNC(REQ)])        #Sends a HTTP request.
 ->CLIENTREQ                                    #Can use URI
                                                #Can use both first arguments, instead of OBJ.url
                                                #OBJ:
                                                #  - url 'URL'
                                                #  - protocol STR (def: 'http:')
                                                #  - host[name] STR (def: "localhost")
                                                #     - prefer hostname
                                                #     - will fire exception if non existing
                                                #  - family 4|6 (def: both)
                                                #  - port PORT_NUM (def: 80)
                                                #  - socketPath STR: incompatible with host[name] and port
                                                #  - localAddress STR
                                                #  - method STR (def: "GET")
                                                #  - path STR (def: "/"): including hash and query string
                                                #  - headers OBJ
                                                #  - auth STR: e.g. "auth:password"
                                                #  - agent AGENT|false (def: globalAgent)
                                                #  - keepAlive[Msecs]: see AGENT
                                                #  - createConnection(...): see AGENT
                                                #  - timeout NUM
                                                #  - lookup(...) (def: DNS.lookup(...))
                                                #  - maxHeaderSize NUM: see --max-http-header-size
                                                #  - highWaterMark NUM
                                                #  - signal ABORT_SIGNAL: call destroy() on cancel
                                                #  - uniqueHeaders 'VAR'_ARR: like createServer()
                                        20.16.0*#  - rejectNonStandardBodyWrites BOOL: like createServer()
                                        18.14.0*#  - joinDuplicateHeaders BOOL (def: false): like createServer()
                                        22.13.0*#  - setHost BOOL (def: true): set default Host [C]
                                        22.13.0*#  - setDefaultHeaders BOOL (def: true): set default
                                        22.13.0*#    Host|Connection|Content-Length|Transfer-Encoding [C]
                                                #FUNC is 'response' event handler.
get(['URI'|URI][, OBJ][, FUNC(REQ)])            #Same but use method "GET" and automatically calls OSTREAM.end()
CLIENTREQ.on("socket", FUNC(TCPSOCKET))         #Fired when socket is created to send the request.
CLIENTREQ.on("response", FUNC(REQ))             #Response of the server.
                                                #REQ must be read, no matter what.
CLIENTREQ.on("continue", FUNC())                #Fired when server responds with Expect: 100-continue [S]
CLIENTREQ.on("checkExpectation",FUNC(REQ, RES)) #Fired when server responds with Expect [S], except Expect: 100-continue [S]
CLIENTREQ.on("information", FUNC(OBJ))          #Fired when server responds with 1** (excluding 101)
                                                #OBJ:
                                                #  - statusCode STR
                                                #  - headers OBJ, rawHeaders ARR, httVersion STR, httpVersionMinor|Major NUM
CLIENTREQ.on
("connect", FUNC(REQ, TCPSOCKET, BUFFER))       #Fired when server responds to a CONNECT request
CLIENTREQ.on
("upgrade", FUNC(REQ, TCPSOCKET, BUFFER))       #Fired when server responds with Upgrade [S]
CLIENTREQ.destroy()                             #
CLIENTREQ.flushHeaders()                        #Send request headers right away, even if request body not ready for send yet

AGENT                                           #Socket pools manager for CLIENTREQ (not REQ|RES)
new Agent(OBJ)                                  #OBJ is:
                                                #  - maxSockets NUM (def: Infinity):
                                                #     - max busy + free sockets per host.
                                                #     - increasing just affect pooling, i.e. more memory used but faster
                                                #     - but does not affect max. number of sockets per host (unlim.)
                                                #  - maxFreeSockets NUM (def: 256):
                                                #     - max free sockets.
                                                #     - only relevant if keepAlive true
                                                #  - keepAlive BOOL (def: true): keep free sockets opened for use
                                                #  - keepAliveMsecs NUM (def: 1000)
                                                #  - timeout NUM
                                                #  - scheduling 'fifo' or 'lifo' (def):
                                                #     - FIFO keep number of open sockets as high as possible, i.e. good for speed
                                                #     - LIFO keep it as low as possible, i.e. good for memory
                                                #     - LIFO lowers risk of re-using sockets closed by server due to inactivity
AGENT.max[Free]Sockets                          #
AGENT.[free]sockets                             #Current TCPSOCKET_ARR
AGENT.maxTotalSockets                           #Like AGENT.maxSockets but for all origins
AGENT.requests                                  #Current REQ_ARR, not assigned to sockets yet.
AGENT.destroy()                                 #To do to destroy free sockets if keepAliveMsecs high, to avoid hanging.
AGENT.keepSocketAlive = FUNC(TCPSOCKET)         #Override function fired on new free socket.
                                                #Def: TCPSOCKET.setKeepAlive(true, keepAliveMsecs); TCPSOCKET.unref(); return true;
AGENT.reuseSocket = FUNC(TCPSOCKET, CLIENTREQ)  #Override function fired when free socket is being picked.
                                                #Def: TCPSOCKET.ref();
AGENT.getName(OBJ)                              #Returns OBJ (host, port, localAddress) as unique ID STR
                                                #OBJ is optional
AGENT.createConnection(...)->IOSTREAM           #Same as TCP createConnection(), but can be customized and use any IOSTREAM

validateHeaderName('NAME'[, STR])               #Throw if invalid HTTP header name|value.
validateHeaderValue('NAME', 'VAL')              #Automatically done by RES.setHeader()
                                         19.5.0*#STR is error message prefix (def: 'Header name')

DIAGNOSTICS_CHANNEL.subscribe
 ('http.client.request.created',
 FUNC(OBJ))                             22.12.0*#OBJ: request REQ
DIAGNOSTICS_CHANNEL.subscribe
 ('http.client.request.start',
 FUNC(OBJ))                                     #OBJ: request REQ
DIAGNOSTICS_CHANNEL.subscribe
 ('http.client.request.error',
 FUNC(OBJ))                             20.17.0*#OBJ: request REQ, error ERROR
DIAGNOSTICS_CHANNEL.subscribe
 ('http.client.response.finish',
 FUNC(OBJ))                                     #OBJ: request REQ, response RES
DIAGNOSTICS_CHANNEL.subscribe
 ('http.server.request.start',
 FUNC(OBJ))                                     #OBJ: request REQ, response RES, socket SOCKET, server SERVER
DIAGNOSTICS_CHANNEL.subscribe
 ('http.server.response.created',
 FUNC(OBJ))                             22.12.0*#OBJ: request REQ, response RES
DIAGNOSTICS_CHANNEL.subscribe
 ('http.server.response.finish',
 FUNC(OBJ))                                     #OBJ: request REQ, response RES, socket SOCKET, server SERVER

                                  ┌───────────┐
                                  │   HTTPS   │
                                  └───────────┘

HTTPS ==>                                       #Has exactly same members as HTTP except:
                                                #  - createServer(OBJ[, FUNC]): OBJ is same as TLS|HTTP.createServer()
                                                #  - all members:
                                                #      - inherit from HTTP, e.g. HTTPSSERVER inherits HTTPSERVER
                                                #      - use TLS* objects instead of TCP*, e.g. TLSSERVER <- TCPSERVER, TLSSOCKET <- TCPSOCKET, etc.
                                                #      - as such, can be used as HTTP server too
                                                #  - new AGENT(OBJ) and request(OBJ) can use:
                                                #     - all options from TLS.createSecureContext(OBJ)
                                                #     - 'rejectUnauthorized|servername' options from TLS.connect(OBJ)

                                  ┌───────────┐
                                  │   FETCH   │
                                  └───────────┘

fetch|Request|Response|Headers                  #
FormData                                        #Like in browsers

--experimental-fetch                            #Under the hood, uses undici.fetch()
                                                #Difference with DOM:
                                                #  - REQ.body can be [ASYNC_]ITERABLE
                                                #  - REQ.duplex must be 'half' if REQ.body is RSTREAM|ASYNC_ITERABLE
                                                #  - RES.body is not garbage collected, i.e. should be consumed
                                                #  - no support for Expect [C] + 100
                                                #  - no RES.type 'opaqueredirect'
                                       <18.13.0*#Experimental warning
                                        <23.0.0*#No longer needed

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

NODE_URI                                        #Prefer URI
                                                #OBJ:
                                                #  - protocol STR|null
                                                #  - slashes BOOL: if AUTHORITY starts with //
                                                #  - auth STR|null
                                                #  - host STR|null
                                                #  - port STR|null
                                                #  - hostname STR|null
                                                #  - pathname 'PATH'|null
                                                #  - path 'PATH?QUERY'|null
                                                #  - search '?QUERY'|QUERY_OBJ|null
                                                #  - query 'QUERY'|null
                                                #  - hash '#HASH'|null
                                                #  - href 'URI'
resolve('BASE_URI', 'RELATIVE_URI')->'URI'      #

URI                                             #As opposed to NODE_URI, is isomorphic, i.e. same as in browser (see DOM doc)
                                                #Including the fact that URL is a global object
new URL("URI"[, URI2|'URI2'])->URI              #See DOM doc
format(URI[, OPTS])->'URI'                      #OPTS:
                                                #  - auth BOOL: if false (def: true), ignores username|password
                                                #  - fragment BOOL: if false (def: true), ignores hash
                                                #  - search BOOL: if false (def: true), ignores search
                                                #  - unicode BOOL: if false (def), uses Punycode. Otherwise, URI encoding

new URLSearchParams(...)                        #See DOM doc
                                        18.16.0*#Including SEARCHPARAMS.size
                                        18.18.0*#Including SEARCHPARAMS.has|delete() with a second VAL argument

new URLPattern(...)                      23.8.0*#See DOM doc

ORIGIN                                          #OBJ: scheme STR|null, host STR|null, port STR|undefined, domain STR|null
originFor(...)->ORIGIN                          #Like URL constructor, but returning ORIGIN instead

domainToASCII(STR)->STR2
domainToUnicode(STR)->STR2                      #IDN from|to Punycode

fileURLToPath(URI|'URI'[, OPTS])->'PATH'        #Conversion between file://* and 'PATH' considering:
pathToFileURL('PATH'[, OPTS])->URI              #  - 'PATH' is OS-specific, e.g. Windows drive
                                                #  - URI requires percent encoding, but not 'PATH'
                                        20.13.0*#OPTS:
                                        20.13.0*#  - windows BOOL (def: use process.platform)

urlToHttpOptions(URI)->OBJ                      #Returns OBJ to use with HTTP[S].request()

URL.createObjectURL(BLOB)->'URL'                #Like DOM except:
URL.resolveObjectURL('URL')                     #  - 'blob:nodata:UUID'
                                                #  - lifetime is thread
                                                #  - cannot be accessed by other processes|threads
buffer.resolveObjectURL('URL')
 ->BLOB|undefined                               #
URL.canParse(...)->BOOL                 18.17.0*#Like DOM
URL.parse(...)->URL|null                20.18.0*#Like DOM

                                  ┌─────────────────┐
                                  │   QUERYSTRING   │
                                  └─────────────────┘

stringify(QUERY_OBJ[, STR[, STR2[, OPTS]]])     #'QUERY' is escaped
  ->'QUERY'                                     #STR is separator (def: '&'), STR2 delimiter (def: '=')
                                                #ARR is serialized as several VARs
                                                #OPTS:
                                                #  - encodeURIComponent(...) (def: escape(...)): customize escaping
parse('QUERY'[, STR[, STR2]][, OPTS])->QUERY_OBJ#Inverse.
                                                #OPTS:
                                                #  - maxKeys NUM (def: 1000, 0 for unlim)
                                                #  - decodeURIComponent(...) (def: unescape(...)):
                                                #     - customize escaping
                                                #     - transforms + to spaces (instead of escaping)
                                                #Note: QUERY_OBJ does not inherit from OBJ
[un]escape(STR)                                 #Same as en|decodeURIComponent(), but can be overriden to change stringify|parse() behavior

QS ==>                                         ##See QS module for more features

                                  ┌───────────────┐
                                  │   WEBSOCKET   │
                                  └───────────────┘

WebSocket                               20.10.0*#Like DOM
                                        20.10.0*#No WebSocketStream
                                         22.5.0*#Can also be imported from `node:http`, to distinguish from any global WebSocket
--experimental-websocket                <22.0.0*#Required

                                  ┌─────────┐
                                  │   SEE   │
                                  └─────────┘

EventSource                             20.18.0*#Like DOM
--experimental-eventsource              20.18.0*#Required

                                  ┌─────────┐
                                  │   DNS   │
                                  └─────────┘

DIFFERENCE ==>                                  #DNS.resolve*|reverse() and DNS.lookup*() are similar but:
                                                #  - resolve*|reverse(): use C-Ares, a fast library for DNS resolution, which does DNS query directly.
                                                #  - lookup*():
                                                #     - uses getaddrinfo(), which is slower.
                                                #     - it uses underlying OS, i.e. how DNS resolution would behave on that system (e.g. /etc/hosts)
                                                #     - it is used by http.*, tcp.* and udp.* modules.
                                                #Resolving manually the host can give better performance.

lookup('HOST'[, OBJ], FUNC(ERROR, 'HOST', STR4))#DNS forward lookup.
                                                #STR4 is OBJ.family
                                                #OBJ:
                                                #  - family 4, 6 or null (both)
                                         18.4.0*#    or 'IPv4|IPv6'
                                                #  - hints NUM: or'd flags among:
                                                #     - DNS.ADDRCONFIG
                                                #     - DNS.V4MAPPED: if look for IPv6 but none found, return IPv4 mapped as IPv6
                                                #     - DNS.ALL: with V4MAPPED, also return IPv6 too
                                                #  - all BOOL: if true (def: false), return all address as STR4_ARR, not only first one
                                        20.13.0*#  - order 'ipv4first', 'ipv6first' or 'verbatim' (def)
                                       <20.13.0*#     - before there was a similar verbatim BOOL option
                                                #The ERROR.name can correspond to several DNS.*, like DNS.NOTFOUND, DNS.NODATA, DNS.NOMEM, etc. (see online doc)
lookupService
(IP, PORT, FUNC(ERROR, 'HOST', 'SCHEME'))       #
getDefaultResultOrder()->STR            18.17.0*#
setDefaultResultOrder(STR)                      #
--dns-result-order=STR                          #Default value for OPTS.order: 'ipv4first' (def) or 'verbatim'
                                        20.13.0*#or 'ipv6first'

new Resolver([OPTS])                            #RESOLVER
                                                #OPTS:
                                                #  - timeout NUM (-1 for def) (in ms)
                                                #  - tries NUM (def: 4)
                                                #In following methods, if RESOLVER is missing, use builtin RESOLVER
[RESOLVER.]resolve
 ('HOST'[, STR2], FUNC(ERROR, VAL_ARR))         #Same as lookup() but STR2 can any PTR record type:
                                                #'A' (def), 'AAAA', 'CAA', 'MX', 'TXT', 'SRV', 'PTR', 'NS', 'CNAME', 'SOA', 'NAPTR' or 'ANY' (guesses)
                                         23.9.0*#or 'TLSA'
[RESOLVER.]resolveSTR2                          #Same. STR2 is camelcase, and "A"|"AAAA"->4|6
 ('HOST', [OBJ, ]FUNC(ERROR, VAL_ARR))          #OBJ (only with records "A"|"AAAA"):
                                                #  - ttl BOOL: if true (def: false), VAL is { address STR, ttl NUM }
[RESOLVER.]reverse('IP', FUNC(ERROR,'HOST'_ARR))#DNS reverse lookup.

[RESOLVER.]setServers('IP[:PORT]'_ARR)          #Sets list of servers IP to use for DNS resolution
[RESOLVER.]getServers()->'IP[:PORT]'_ARR        #List of servers

RESOLVER.cancel()                               #Cancel all current resolve*|reverse() calls, with ERROR with code 'ECANCELLED'
RESOLVER.setLocalAddress(['IPv4'][, 'IPv6'])    #Changes which address is the local one (def: '0.0.0.0' and '::0')

promises.*(...)                                 #Like DNS.*(...) except returns PROMISE
require('dns/promises')                         #Same as DNS.promises

                                  ┌────────┐
                                  │   OS   │
                                  └────────┘

navigator                                21.0.0*#Like DOM, but only specific fields, documented in this doc
--no-experimental-global-navigator       21.2.0*#Disable globalThis.navigator

platform()->STR                                 #"linux", "darwin", "win32", "android" or "sunos", "aix", "freebsd", "openbsd"
type()->STR                                     #Similar to platform() but slightly more precise.
                                                #E.g. "Linux", "Darwin", "Windows_NT", "CYGWIN_NT*", "SunOS", "AIX", "FreeBSD", "OpenBSD" or "MinGW"
release()->STR                                  #OS version number, e.g. "5.3.0-40-generic" (Linux), "18.0.0" (Mac), "10.0.17763" (Windows)
version()->STR                                  #OS version number more precise, e.g.:
                                                #  - "#32-Ubuntu SMP Fri Jan 31 20:24:34 UTC 2020" (Linux)
                                                #  - "Darwin Kernel Version 18.0.0: Wed Aug 22 20:13:40 PDT 2018; root:xnu-4903.201.2~1/RELEASE_X86_64" (Mac)
                                                #  - "Windows 10 Home" (Windows)
arch()->STR                                     #"arm[64]", "ia32|x32|x64", "mips[el]", "ppc[64]", "s390[x]"
machine()->STR                                  #"arm|aarch64", "i386|i686|x68_64", "mips[64]", "ppc[64[le]]", "s390[x]"
endianness()->STR                               #"BE" or "LE"
navigator.platform                       21.2.0*#Like DOM. 'OS [CPU]'
                                         21.2.0*#Values: 'Linux x86_64|i686|ARCH', 'MacIntel', 'Win32', 'SunOS i86pc|ARCH', 'AIX', 'FreeBSD|OpenBSD amd64|i386 [ARCH]'

NODE_SKIP_PLATFORM_CHECK=1                      #Unless set, Node.js fails to boot on old deprecated OS such as Windows 7

uptime()->DOUBLE                                #In seconds
loadavg()->DOUBLE_ARR                           #For last 1, 5 and 15 minutes.
                                                #Returns [0,0,0] on Windows
totalmem|freemem()->NUM                         #RAM

cpus()->OBJ_ARR                                 #OBJ:
                                                #  - model STR
                                                #  - speed UINT (MHz): varies with the load
                                                #  - times OBJ, ms spent by CPU on each member since uptime: user, sys, idle, nice, irq
                                                #     - nice is always 0 on Windows
availableParallelism()->NUM             18.14.0*#Like OS.cpus().length, but taking into account CPU affinity (i.e. process pinned to specific CPUs)
navigator.hardwareConcurrency            21.0.0*#Same. Like DOM

networkInterfaces()->OBJ_ARR                    #OBJ:
                                                #  - key is interface name ("lo", "wlan0", etc.)
                                                #  - value is OBJ2_ARR, with OBJ2:
                                                #     - address 'IP'
                                                #     - netmask 'MASK'
                                                #     - cidr 'IP/MASK'
                                                #     - family 'IPv4|IPv6'
                                  18.0.0-18.3.0*#        - 4|6 instead
                                                #     - mac STR
                                                #     - internal BOOL (true if boucle local)
                                                #     - scopeid NUM

hostname()->STR                                 #E.g. "ether-laptop"
tmpdir()->STR                                   #E.g.:
                                                #  - Linux: `/tmp`
                                                #  - Mac: `/var/folders/RANDOM/T`
                                                #  - Windows: `C:\Users\USER\AppData\Local\Temp`
                                                #Uses ENVVAR TMPDIR|'/tmp' (Unix), '{SystemRoot|windir}\\temp' (Windows), TMP|TEMP (any OS)
homedir()->STR                                  #E.g.:
                                                #  - Linux: `/home/USER`
                                                #  - Mac: `/Users/USER`
                                                #  - Windows: `C:\Users\USER`
                                                #Based on ENVVAR HOME (Linux) or USERPROFILE (Windows), or defaults to userInfo().homedir
userInfo([OBJ])->OBJ2                           #OBJ2:
                                                #  - uid|gid NUM (-1 on Windows)
                                                #  - username 'USER' (/etc/passwd using `geteuid` on Unix, GetUserNameW() on Windows)
                                                #  - homedir 'PATH' (based on OS syscalls)
                                                #  - shell 'PATH' (null on Windows)
                                                #Throws in Docker when `--user` points to user with no home nor username.
                                                #OBJ: encoding 'utf8' (def) or 'buffer'
devNull()->STR                                  #Returns '/dev/null' on Linux|Mac and '\\.\nul' on Windows

EOL                                             #OS-specific newline "\n" or "\r\n"

setPriority([PID, ]NUM)                         #Sets OS process scheduling priority ("niceness").
                                                #If 0 (def), current process
                                                #NUM is between -20 (high priority) and 19 (low priority) or using os.constants:
                                                #  - PRIORITY_LOW: 19
                                                #  - PRIORITY_BELOW_NORMAL: 10
                                                #  - PRIORITY_NORMAL: 0
                                                #  - PRIORITY_ABOVE_NORMAL: -7
                                                #  - PRIORITY_HIGH: -14
                                                #  - PRIORITY_HIGHEST: -20
getPriority([PID])->NUM                         #

                                  ┌──────────┐
                                  │   PATH   │
                                  └──────────┘

PATH ==>                                        #All these functions look at PATH without caring if file exists.

CROSS-OS ==>                                    #Summary:
                                                #  - should usually use Unix path
                                                #  - except when dealing with input|output outside Node (in shell): use PATH.* then
                                                #  - Node methods input:
                                                #     - Unix path allowed on all OS
                                                #        - but Windows path also allowed in Windows (including mixed)
                                                #     - e.g. require(), PATH.*, FS.*, process.chdir()
                                                #  - Node methods output:
                                                #     - OS-specific
                                                #        - but it's ok since input in Node in Windows allows mixing Unix/Windows
                                                #     - e.g. PATH.*, __dirname, process.argv|execPath|cwd(), OS.userInfo().homedir
                                                #     - exceptions:
                                                #        - PATH.posix|win32.*
                                                #        - output based on input, e.g. createReadStream().path, fs.mkdtemp()
                                                #  - input|output outside Node (in shell): OS-specific

normalize('PATH')->'PATH'                       #Remove leading "./", useless ".." and duplicate "/"
join('PATH',...)->'PATH2'                       #Join with PATH.sep, then do normalize()
resolve('PATH',...)->'PATH2'                    #Like doing several cd 'PATH' from current directory:
                                                #  - 'PATH' can be relative or absolute
                                                #  - 'PATH2' is final DIR, normalized()
relative('PATH', 'PATH2')->'PATH3'              #Print relative PATH3 to go from dir PATH to dir PATH2.
                                                #Return '' if same dir
                                                #On Windows, PATH3 might be absolute if either different root folder or drive.
                                                #On Windows, PATH3 might start with Windows drive if different.

isAbsolute('PATH')->BOOL                        #

dirname('PATH')->'DIR'                          #
basename('PATH'[, '.EXT'])->'FILE'              #
extname('PATH')->'.EXT'                         #

parse('PATH')->PATH_OBJ                         #PATH_OBJ: root STR, dir STR, base STR, ext STR, name STR
format(PATH_OBJ)->'PATH'                        #Inverse

sep                                             #OS-specific path delimiter "/" or "\"
delimiter                                       #OS-specific ENVVAR PATH delimiter ":" or ";"

posix|win32.*
require('path/posix|win32')                     #Like PATH, but always behave like if on those platforms

toNamespacedPath('PATH')->'PATH'                #Returns namespaced path '\\?\LETTER:\'.
                                                #Noop unless on Windows.

                                  ┌────────┐
                                  │   FS   │
                                  └────────┘

--trace-sync-io                                 #console.trace() when sync I/O is used

CROSS-OS PERMISSIONS ==>                        #Windows permissions are not supported
                                                #  - except for `readonly` file attribute on regular files, which maps to `a+w`
                                                #  - all other permissions are always on
                                                #This affects `umask()`, `chmod()`, `access()`, `stat().mode` and `opts.mode`
                                                #for `mkdir()` and `open()`.

PATH|FILENAME|DIR                               #Either:
                                                #  - STR
                                                #  - FILE_URL (not 'FILE_URL')
                                                #  - BUFFER (less interoperable)
f*                                              #Variant using file descriptior FD_INT
l*                                              #Doesn't deference symlinks

PWD ==>                                         #All relative to process.cwd()
...Sync(...)                                    #All functions have a synchronous variant, without FUNC, except
                                                #[un]watch[File]() and createRead|WriteStream()
                                                #Will throw exceptions instead of using ERROR.

copyFile(PATH, PATH2[, NUM][, FUNC(ERROR)])     #Copy files
                                                #NUM is an or'd flag:
                                                #  - COPYFILE_EXCL: fail if PATH2 already exists
                                                #  - COPYFILE_FICLONE[_FORCE]:
                                                #     - copy-on-write:
                                                #        - defer the copy until either PATH[2] is written onto
                                                #        - until then, make them references of each other
                                                #     - not supported on Windows:
                                                #        - fallback to normal copy
                                                #        - if FORCE, fails instead
cp(PATH, PATH2[, OPTS], FUNC(ERROR))            #Copy files|directories
                                         19.7.0*#Creates PATH2 parent directories (if does not exist)
                                         19.7.0*#Keep file mode
                                                #OPTS:
                                                #  - recursive BOOL (def: false)
                                                #  - filter('PATH')->BOOL:
                                                #     - do not copy if false
                                                #     - 'PATH' is:
                                                #        - top-level: PATH as is, stringified
                                                #        - children (if recursive): normalized file path, relative to cwd
                                                #  - errorOnExist BOOL (def: false): throw if PATH2 exists
                                                #  - force BOOL (def: true): overwrite PATH2 file|directory if exists
                                                #  - dereference BOOL (def: false): for symlinks
                                                #  - verbatimSymlinks BOOL (def: false): does not resolve symlink paths
                                                #  - preserveTimestamps BOOL (def: false): keep mtime|atime (but not ctime|birthtime)
                                        18.17.0*#  - mode NUM: like copyFile() NUM flag
rename(PATH, PATH2, FUNC(ERROR))                #Cannot be done between partitions on Linux (see move-file doc)

[f|l]chown(PATH|FD_INT, UID, GID, FUNC(ERROR))  #Noop on Windows
[f|l]chmod(PATH|FD_INT, UINT, FUNC(ERROR))      #See above for Windows behavior
                                                #lchmod() is only on Mac

[f]utimes(PATH|FD_INT, ATIME, MTIME, FUNC(ERR)) #Change atime|mtime
lutimes(...)                                    #
access(PATH[, NUM], FUNC(ERROR))                #Checks if has permission, according to NUM or'd flags:
                                                #  - FS.constants.F_OK (def, always implied):
                                                #     - files exists and its directory list it
                                                #     - also fails if directory and is not executable
                                                #  - FS.constants.R|W|X_OK:
                                                #     - can be read|written|executed
                                                #     - on Windows, only W_OK works and only means "no readonly attribute"
[f|l]stat(PATH|FD_INT,[OPTS,]FUNC(ERROR,FSSTAT))#FSSTAT:
                                                #  - isFile|Directory|Block|CharacterDevice|FIFO|Socket(), (only with lstat()) isSymbolicLink()
                                                #     - on Windows: can only be file, directory or symlink
                                                #  - dev UINT
                                                #  - ino UINT
                                                #  - mode UINT (see above for file type and permissions behavior)
                                                #  - nlink UINT
                                                #  - uid|gid UINT (0 on Windows)
                                                #  - rdev UINT
                                                #  - size UINT
                                                #  - blksize UINT, blocks UINT (both undefined on Windows)
                                                #  - a|m|ctime DATE
                                                #  - birthtime DATE: creation time (Windows only)
                                                #  - a|m|ctime|birthtimeMs NUM
                                                #  - a|m|ctime|birthtimeNs NUM (only if OPTS.bigint true)
                                                #OPTS:
                                                #  - bigint BOOL (def: false): make FSSTAT.* BIGINT instead of UINT
                                                #  - throwIfNoEntry BOOL:
                                                #     - when ENOENT, if true (def) throws, if false return undefined
                                                #     - only with [l]statSync()

statfs(PATH[, OPTS],                    18.15.0*#OPTS:
 FUNC(ERROR, FSSTATFS))                 18.15.0*#  - bigint BOOL (def: false): make FSSTATFS.* BIGINT instead of UINT
FSSTATFS                                18.15.0*#Filesystem information
FSSTATFF.type                           18.15.0*#Type (e.g. ext3, etc.) using a NUM id (see `statfs` man page)
FSSTATFF.bsize                          18.15.0*#Preferred NUM bytes block size (e.g. 4096)
FSSTATFF.blocks                         18.15.0*#NUM of blocks, free or not
FSSTATFF.bfree                          18.15.0*#NUM of blocks, free
FSSTATFF.bavail                         18.15.0*#NUM of blocks, free for non-root users
FSSTATFF.files                          18.15.0*#NUM of inodes|files, free or not
FSSTATFF.ffree                          18.15.0*#NUM of inodes|files, free

symlink(PATH, PATH2[, STR], FUNC(ERROR))        #STR is 'dir', 'file' or 'junction' (Windows only)
                                                #Def: 'file|dir' depending on PATH
link(PATH, PATH2, FUNC(ERROR))                  #Hardlink
readlink(PATH[, OBJ], FUNC(ERROR, PATH2))       #Follow symlink (only once)
                                                #PATH must be a symlink
                                                #OBJ: encoding 'ENCODING'
realpath[.native]                               #Like normalize(), but also follow symlinks (several times if needed), and PATH must exist.
 (PATH[, OBJ], FUNC(ERROR, PATH2))              #OBJ: encoding 'ENCODING'
                                                #If "native" does not cache and do less normalization

[f]truncate(PATH|FD_INT, UINT, FUNC(ERROR))     #
unlink(PATH, FUNC(ERROR))                       #Delete file.
rmdir(PATH, FUNC(ERROR)[, OPTS])                #Delete empty directory.
rm(PATH, FUNC(ERROR)[, OPTS])                   #Delete file|dir.
                                                #OPTS:
                                                #  - force BOOL: if false (def): throw if file does not exist
                                                #  - recursive BOOL (def: false):
                                                #     - whether to allow deleting directory
                                                #  - maxRetries NUM (def: 0)
                                                #     - retry NUM times with linear backoff (starting at OPTS.retryDelay NUMms (def: 100)) on
                                                #       EBUSY, ENOTEMPTY, EPERM, EMFILE or ENFILE
                                                #     - requires OPTS.recursive true

mkdir(PATH[, MODE_INT|OPTS],                    #OPTS:
 FUNC(ERROR[, 'PATH2']))                        #  - mode MODE_INT (def: 0777) (see above for Windows behavior)
                                                #  - recursive BOOL (def: false):
                                                #     - create intermediary directories
                                                #     - no error if directory exists
                                                #     - see make-dir (see its doc) for a ponyfill
                                                #'PATH2' is the topmost subdirectory that did not exist before mkdir() (undefined if none)

readdir(DIR, [OPTS, ]                           #ls: 'FILE' excludes . and ..
 FUNC(ERROR, 'FILE'|DIRENT_ARR))                #OPTS:
                                                #  - encoding 'ENCODING'
                                                #  - withFileTypes BOOL (def: false): whether to return DIRENT_ARR or 'FILE'_ARR
                                        18.17.0*#  - recursive BOOL (def: false): include children recursively
DIRENT.isFile|Directory|Block|CharacterDevice|
 FIFO|Socket|SymbolicLink()->BOOL               #
DIRENT.name                                     #STR
DIRENT.parentPath                        20.1.0*#'DIR' passed as input, relative|absolute
                                       <20.12.0*#Previously called DIRENT.path

opendir(DIR[, OPTS], FUNC(ERROR, FSDIR))        #Like readdir() but:
                                                #  - iteratively, in batch of OPTS.bufferSize NUM (def: 32) files internally
                                                #     - i.e. slower but lower memory
                                                #        - on my machine: 1s per 1e6 files, in big directories
                                                #        - on my machine: 4x|5x for <1e5 files files, 2x for 1e5 files, 1x for 1e6 files, slightly faster above
                                                #     - higher OPTS.bufferSize makes it faster up until a point where it makes it slower
                                                #        - on my machine: fastest seem to be 256
                                                #  - only useful for very big directories (>1e6 files)
                                                #  - unordered
                                                #OPTS:
                                                #  - encoding 'ENCODING'
                                        18.17.0*#  - recursive BOOL (def: false): like readdir()
FSDIR.path                                      #'DIR' (as specified in input)
FSDIR.read()->PROMISE_DIRENT|null               #Get next directory entry or null if no more
FSDIR.close()->PROMISE                          #Cleanup file descriptor after iteration done
FSDIR                                           #Is ASYNC_ITERATOR iterating over PROMISE_DIRENT, doing read() and close()

matchesGlob('PATH', 'GLOB')->BOOL       20.17.0*#Globbing match, without looking at filesystem
                                        20.17.0*#Part of import 'path'
glob('GLOB'[_ARR][, OPTS],               22.0.0*#'PATH' are relative|absolute depending on 'GLOB'
 FUNC(ERROR, 'PATH'_ARR))                22.0.0*#OPTS:
                                         22.0.0*#  - cwd 'DIR' (def: '.')
                                         22.0.0*#  - exclude('PATH')->BOOL
                                        22.14.0*#    or exclude('GLOB')->BOOL
                                         22.2.0*#  - withFileTypes BOOL (def: false): like readdir()
                                         22.0.0*#With promises, it returns a 'PATH'_ASYNC_ITERABLE

open(PATH, STR|NUM[, MODE], FUNC(ERROR, FD_INT))#Open a file and return a file descriptor.
                                                #STR are flags: "r|w|a[s|x][+]":
                                                #  - r: O_RDONLY
                                                #  - w: O_WRONLY + O_CREAT + O_TRUNC
                                                #  - a: O_WRONLY + O_CREAT + O_APPEND
                                                #  - +: O_RDONLY|WRONLY -> O_RDWR
                                                #  - x: O_EXCL. Only with 'w|a', not 'r'
                                                #  - s: O_SYNC. Only with 'r|a', not 'w'
                                                #NUM are or'd flags:
                                                #  - O_RDONLY|O_WRONLY|O_RDWR: read|write-only or not
                                                #  - O_TRUNC: truncate
                                                #  - O_APPEND: append
                                                #  - O_CREAT: create if not exist
                                                #  - O_CREAT + O_EXCL: fail if exist
                                                #  - O_DIRECTORY: fail if not a directory
                                                #  - O_NOFOLLOW: fail if is a symlink
                                                #  - O_SYMLINK: do not follow symlinks
                                                #  - O_NOATIME: do not update atime (Linux only)
                                                #  - O_DIRECT: try to avoid caching|buffering
                                                #  - O_SYNC: synchronous (wait for data)
                                                #  - O_DSYNC: synchronous (wait for data+metadata)
                                                #  - O_NOCTTY: if file is a terminal device, treat it as a normal file
                                                #  - O_NONBLOCK: use async when opening special files like serial ports
                                                #  - UV_FS_O_FILEMAP: use memory file mapping, i.e. bytewise copy of file in RAM. Only on Windows.
                                                #On Windows, those flags are mapped to file attributes, file permissions and share permissions
                                                #MODE INT is 0666 by def.
openAsBlob(PATH[, OPTS])->PROMISE_BLOB   19.8.0*#OPTS:
                                         19.8.0*#  - type 'MIME'
close(FD_INT[, FUNC(ERROR)])                    #
write(FD_INT, TDBUFFER, INT, [INT2, [ INT3,]]   #Write INT2 bytes (def: until end) from TDBUFFER at its position INT to file FD_INT at its position INT3 (def: current).
 FUNC(ERROR, INT4, TDBUFFER))                   #INT4 is the number of bytes written.
                                                #INT|INT2 are optional
write(FD_INT, STR[, INT3,
['ENCODING', ]] FUNC(ERROR, INT4, STR))         #Same but with STR
write(FD_INT, TDBUFFER[, OPTS],                 #Same but with OPTS:
 FUNC(ERROR, INT4, TDBUFFER))                   #  - offset INT (def: 0)
                                                #  - length INT2 (same def)
                                                #  - position INT3 (same def)
writev(FD_INT, TDBUFFER_ARR[, INT3],
 FUNC(ERROR, INT4, TDBUFFER_ARR))               #Same but with TDBUFFER_ARR
read(FD_INT, TDBUFFER, INT, INT2,
INT3, FUNC(ERROR, INT4, BUFFER))                #
read(FD_INT[, TDBUFFER][, OPTS],                #Read INT2 bytes from file FD_INT and return as BUFFER
 FUNC(ERROR, INT2, BUFFER))                     #OPTS:
                                                #  - buffer TDBUFFER2 (def: Buffer.alloc(16384))
                                                #  - offset INT (def: 0) (in BUFFER, to write)
                                                #  - length INT2 (def: OPTS.buffer.length)
                                                #  - position INT3|BIGINT (def: null) (in file, to read)
readv(FD_INT, TDBUFFER[, INT3]
 FUNC(ERROR, INT4, TDBUFFER_ARR))               #Same but with TDBUFFER_ARR
f[data]sync(FD_INT, FUNC(ERROR))                #Flushes to disk
                                                #If 'data', only data, not inode modification (timestamps, permissions, etc.)

readFile                                        #Easier way than using open() and read()
(PATH|FD_INT, [OPTS, ]FUNC(ERROR, BUFFER|STR))  #OPTS:
                                                #  - encoding 'ENCODING' (def: null, i.e. returns BUFFER, otherwise returns STR)
                                                #  - flag STR (def: "r")
                                                #  - signal ABORT_SIGNAL: stop buffering (but not OS call) on cancel
                                                #Prefer createReadStream(...).pipe(OSTREAM)
write|appendFile(FILENAME|UINT                  #OPTS:
 [, STDBUFFER|STREAM|[ASYNC_]ITERABLE][, OPTS]  #  - encoding 'ENCODING' (def: 'utf8')
 FUNC(ERROR))                                   #  - flag STR (def: 'w'|'a')
                                                #  - signal ABORT_SIGNAL
                                                #  - mode MODE_INT (def: 0666)
                                        20.10.0*#  - flush BOOL (def: false): call fsync()
createReadStream(PATH[, OPTS])->ISTREAM         #Iterates using FS.read(FD_INT)
                                                #On start|destroy, does FS.open|close()
                                                #OPTS:
                                                #  - flags STR (def: "r")
                                                #  - mode NUM (def: 0666) (see above for Windows behavior)
                                                #  - fd FD_INT|FILE_HANDLE (def: null)
                                                #     - PATH is then ''
                                                #     - does not use OPTS.flags|mode
                                                #     - ISTREAM.pending always true
                                                #     - 'open' not emitted
                                                #  - start|end UINT: only use from bytes UINT to UINT2
                                                #  - encoding 'ENCODING' (def: null)
                                                #  - highWaterMark NUM (def: 64KB)
                                                #  - autoClose BOOL (def: true): like IOPTS.autoDestroy
                                                #  - emitClose|signal: like IOPTS.*
                                                #  - fs FS or null (def): override FS.*
                                                #ISTREAM has extra:
                                                #  - same members as OPTS
                                                #  - path 'PATH'
                                                #  - pos UINT
                                                #  - bytesRead UINT
                                                #  - on('open', FUNC(FD_INT)): after FS.open()
                                                #  - on('ready', FUNC()): same
                                                #  - pending BOOL: whether 'ready' not emitted yet
createWriteStream(PATH[, OPTS])->OSTREAM        #Iterates using FS.write(FD_INT)
                                                #On start|destroy, does FS.open|close()
                                                #Same OPTS and extra members as createReadStream() except:
                                                #  - no OPTS.end
                                                #  - def OPTS.flags 'w'
                                                #  - def OPTS.encoding 'utf8'
                                                #  - OPTS.flush BOOL (def: false): does FS.sync() on destroy
                                                #  - ISTREAM.byteRead -> OSTREAM.bytesWritten

mkdtemp(PATH, FUNC(ERROR, 'PATH2'))             #Create temp DIR at 'PATHrandom', with random being 6 chars [:alnum:] (36 bits of entropy)
                                        <20.6.0*#Can only use 'PATH'

watch('FILE|DIR'[, OPTS][, FUNC])->FSWATCHER    #FSWATCHER fires events when file changes name or content.
                                                #OPTS:
                                                #  - persistent BOOL: if true (def), calls ref(), yielding the macrotask
                                                #  - recursive BOOL (def: false)
                                        <19.1.0*#     - not on Linux
                                                #  - encoding 'ENCODING' (def: 'utf8')
                                                #  - signal ABORT_SIGNAL: close() on cancel
                                                #FUNC is the FSWATCHER 'change' event handler.
                                                #Unstable. Prefer Chokidar.
FSWATCHER.on
('change', FUNC('change|rename', SBUFFER))      #SBUFFER is the FILENAME and is not always provided (e.g. never on MacOSX, and not always on other OS)
FSWATCHER.close()                               #
FSWATCHER.on('close', FUNC())                   #
FSWATCHER.on('error', FUNC(ERROR))              #
FSWATCHER.[un]ref()                             #

[un]watchFile                                   #Uses polling
 (FILE[, OPTS], FUNC(PREV_STAT, NEW_STAT))      #OPTS:
 ->STATWATCHER                                  #  - persistent BOOL
                                                #  - interval (def: 5000)
STATWATCHER                                     #
STATWATCHER.[un]ref()                           #

constants                                       #Low-level file-system constants, for the current OS

FS.promises                                     #Like FS but:
require('fs/promises')                          #  - return PROMISE instead
                                                #     - no FS.unwatch|watchFile()
                                                #  - FS.create*Stream*():
                                                #     - only on FILE_HANDLE.*
                                                #     - OPTS lack: flags|fd|signal|fs
                                                #  - FS.watch() returns ASYNC_ITERATOR of OBJ: eventType 'EVENT', filename SBUFFER
                                                #  - FD_INT are FILE_HANDLE instead
                                                #     - no FS.close() but FILE_HANDLE.close() is available
                                                #  - FS.constants|Stats|*OK remain on FS.*
FILE_HANDLE                                     #Abstraction of a file descriptor, with automatic closing on FS PROMISE rejection
FILE_HANDLE.fd                                  #FD_INT
FILE_HANDLE.FUNC(...)                           #Same as FSP.[f]FUNC(FILE_HANDLE, ...)
FILE_HANDLE.on('close', FUNC())                 #
FILE_HANDLE[Symbol.asyncDispose]()      18.18.0*#Calls FILE_HANDLE.close()
FILE_HANDLE.readableWebStream                   #Like createReadStream() but with RSTREAM
 ([OPTS])->RSTREAM                              #Must explicitly call FILE_HANDLE.close() after completing reading
                                         23.8.0*#Uses ROPTS.type 'bytes'

                                  ┌─────────────┐
                                  │   STORAGE   │
                                  └─────────────┘

--experimental-webstorage                22.4.0*#

localStorage                             22.4.0*#Like DOM. Persisted on file on writes.
                                                #Max total size: ~5MB
                                                #Max value: same as total size
--localstorage-file=PATH                        #PATH to SQLite database file

sessionStorage                           22.4.0*#Like DOM. Persisted in memory, i.e. only in current process.
                                                #Limits: like localStorage

                                  ┌────────────┐
                                  │   SQLITE   │
                                  └────────────┘

--experimental-sqlite                  <22.13.0*#Required

new DatabaseSync(PATH[, OPTS])           22.5.0*#SDB
                                         22.5.0*#PATH is either 'PATH' or ':memory:'
                                        23.10.0*#or URL or BUFFER
OPTS.open                                22.5.0*#BOOL (def: false). Calls SDB.open()
SDB.open()                               22.5.0*#
SDB.close()                              22.5.0*#

OPTS.readOnly                           22.12.0*#BOOL (def: false). No write operations
OPTS.enableForeignKeyConstraints        22.12.0*#BOOL (def: false). Disable foreign keys constraints
OPTS.enableDoubleQuotedStringLiterals   22.12.0*#BOOL (def: false). Disable "-quoted STRs

SDB.loadExtension('PATH')               22.13.0*#Loads an extension
SDB.enableLoadExtension(BOOL)           22.13.0*#If true (def: false), throw on SDB.loadExtension()

SDB.exec('SQL')                          22.5.0*#Run SQL

SDB.prepare('SQL')->SSTATEMENT           22.5.0*#Can use parameters using:
                                         22.5.0*#  - named: :VAR $VAR or @VAR
                                         22.5.0*#  - anonymous: ? or ?NUM
                                         22.5.0*#Can bind parameters using SQLite-specific syntax
SSTATEMENT.sourceSQL()->'SQL'            22.5.0*#
SSTATEMENT.expandedSQL()->'SQL'          22.5.0*#Same but replace bound parameters by values
SSTATEMENT.all([OBJ][, VAL...])->OBJ_ARR 22.5.0*#Run SQL. OBJ is named parameters, VAL... anonymous ones
                                         22.5.0*#Returns ARR of rows OBJs
SSTATEMENT.iterate(...)->OBJ_ITERATOR   22.13.0*#Same but returned as ITERATOR
SSTATEMENT.get(...)[->OBJ]               22.5.0*#Same but only return 0|1 row
SSTATEMENT.run(...)->OBJ                 22.5.0*#Same but returns OBJ:
                                         22.5.0*#  - changes NUM|BIGINT: of insert|update|delete
                                         22.5.0*#  - lastInsertRowid NUM|BIGINT
SSTATEMENT.setReadBigInts(BOOL)          22.5.0*#Uses BIGINT instead of NUMs (def: false)
SSTATEMENT
 .setAllowBareNamedParameters(BOOL)      22.5.0*#When true (def: false), VAR prefix character : $ @ ? is optional

SDB.createSession([OPTS])->SESSION      22.12.0*#
OPTS.table                              22.12.0*#'TABLE' (def: any)
OPTS.db                                 22.12.0*#'DB' (def: 'main')
SESSION.close()                         22.12.0*#

SESSION.changeset()->CHANGESET_UINT8ARR 22.12.0*#All changes since last call to changeset()
SESSION.patchset()->CHANGESET_UINT8ARR  22.12.0*#Same but more compact format
SESSION.applyChangeset
 (CHANGESET_UINT8ARR[, OPTS])->BOOL     22.12.0*#Apply changes. BOOL is success
OPTS.filter                             22.12.0*#FUNC('TABLE')->BOOL. Skip if false
OPTS.onConflict                         22.12.0*#FUNC(CONFLICT)->VAL. What to do on conflict
                                        22.12.0*#CONFLICT is constants.*:
                                        22.12.0*#  - SQLITE_CHANGESET_DATA: update|delete mismatched 'before' values
                                        22.12.0*#  - SQLITE_CHANGESET_NOTFOUND: update|delete missing row
                                        22.12.0*#  - SQLITE_CHANGESET_CONFLICT: insert with duplicate key
                                        22.12.0*#  - SQLITE_CHANGESET_FOREIGN_KEY: foreign key violation
                                        22.12.0*#  - SQLITE_CHANGESET_CONSTRAINT: unique|check|not null violation
                                        22.12.0*#Must return constants.*:
                                        22.12.0*#  - SQLITE_CHANGESET_OMIT: ignore change
                                        22.12.0*#  - SQLITE_CHANGESET_REPLACE: apply change
                                        22.12.0*#  - SQLITE_CHANGESET_ABORT: abort all changes

SDB.function('FUNCTION'[, OPTS], FUNC)  22.13.0*#Allow calling FUNC() from SQL
OPTS.deterministic                      22.13.0*#BOOL (def: false)
OPTS.directOnly                         22.13.0*#BOOL (def: false)
OPTS.varargs                            22.13.0*#BOOL (def: false). Whether allow arbitrady NUM of arguments, or use FUNC.length
OPTS.useBigIntArguments                 22.13.0*#BOOL (def: false). Whether integers are INT or BIGINT

backup(SDB, 'PATH'|URL|BUFFER[, OPTS])   23.8.0*#Performs backup
 ->>                                     23.8.0*#SDB must be open
                                         23.8.0*#If PATH already exists, overwrite it
                                        23.10.0*#PATH can be URL|BUFFER
OPTS.source                              23.8.0*#'DB' (def: 'main')
OPTS.target                              23.8.0*#'DB' (def: 'main')
OPTS.rate                                23.8.0*#NUM (def: 100) of pages per batch
OPTS.progress                            23.8.0*#FUNC(NUM, NUM2) called repeatedly with NUM of pages done and NUM2 total

TYPES ==>                                22.5.0*#null NUM BIGINT STR UINT8ARR
                                        22.14.0*#DATAVIEW TYPED_ARR

                                  ┌──────────┐
                                  │   ZLIB   │
                                  └──────────┘

crc32(STDBUFFER[, UINT])->UINT2         20.15.0*#CRC32
                                        20.15.0*#UINT is seed
                                        20.15.0*#UINT[2] is 32 bits
                                        20.15.0*#If STR, internally transformed to UINT8ARR using TEXTENCODER.encode()

createGzip|Deflate[Raw]([OBJ])->COMPRESS        #COMPRESS is a IOSTREAM, so should do:
                                                #  ISTREAM.pipe(IOSTREAM).pipe(OSTREAM)
                                                #See HTTP for different formats.
                                                #Raw: same but does not append a zlib header.
                                                #OBJ can be:
                                                #  - [finish]flush, among:
                                                #     - constants.Z_NO_FLUSH (def)
                                                #     - constants.Z_PARTIAL_FLUSH
                                                #     - constants.Z_SYNC_FLUSH
                                                #     - constants.Z_FULL_FLUSH
                                                #     - constants.Z_FINISH
                                                #     - constants.Z_BLOCK
                                                #     - constants.Z_TREES
                                                #  - chunkSize (def: 16*1024): higher means faster but more memory
                                                #  - windowBits (def: 15): from 9 to 15, higher means better compression but
                                                #    more memory.
                                                #  - dictionary TDABUFFER (deflate|inflate only) (def: "")
                                                #OBJ (compression only):
                                                #  - level: higher means better compression but slower, among:
                                                #     - constants.Z_DEFAULT_COMPRESSION (def)
                                                #     - constants.Z_BEST_SPEED
                                                #     - constants.Z_BEST_COMPRESSION
                                                #     - constants.Z_NO_COMPRESSION
                                                #  - memLevel (def: 8): from 1 to 9, higher means better compression but more
                                                #    memory.
                                                #  - strategy, make compression better, according to type of data, among:
                                                #     - constants.Z_DEFAULT_STRATEGY: almost random data, and small values
                                                #     - constants.Z_FILTERED: in-between
                                                #     - constants.Z_HUFFMAN_ONLY: less random, and large repeating chunk
                                                #     - constants.Z_RLE: same, but specially for PNG data
                                                #     - constants.Z_FIXED: only specific application
                                                #  - maxOutputLength NUM (def: Buffer.kMaxLength): not used in streaming mode
                                                #Memory required (in bytes) is:
                                                #  - for compression:
                                                #     - 2^(windowBits+2) + 2^(memLevel+9) + chunkSize, i.e. 272K by def
                                                #  - for decompression:
                                                #     - 2^windowBits + chunkSize, i.e. 48K by def
createBrotliCompress([OBJ])->COMPRESS           #Same with Brotli. OBJ:
                                                #  - flush ENUM, finishFlush ENUM, among:
                                                #     - constants.BROTLI_OPERATION_PROCESS (def)
                                                #     - constants.BROTLI_OPERATION_FINISH (def for last chunk)
                                                #     - constants.BROTLI_OPERATION_FLUSH (def for flush())
                                                #     - constants.BROTLI_OPERATION_EMIT_METADATA
                                                #  - chunkSize NUM (def: 16KB)
                                                #  - params OBJ:
                                                #     - [constants.BROTLI_PARAM_MODE] ENUM, among:
                                                #        - constants.BROTLI_MODE_GENERIC (def)
                                                #        - constants.BROTLI_MODE_TEXT: best for UTF-8 text
                                                #        - constants.BROTLI_MODE_FONT: best for WOFF 2.0 fonts
                                                #     - [constants.BROTLI_PARAM_QUALITY] NUM:
                                                #        - between constants.BROTLI_MIN|MAX_QUALITY (0|11)
                                                #        - def constants.BROTLI_DEFAULT_QUALITY (11)
                                                #        - higher gives better compression but consumes more CPU-time
                                                #     - [constants.BROTLI_PARAM_LGWIN] NUM:
                                                #        - between constants.BROTLI_MIN|MAX_WINDOW_BITS (10|24)
                                                #           - max BROTLI_LARGE_MAX_WINDOW_BITS (30) if BROTLI_PARAM_LARGE_WINDOW true
                                                #        - def constants.BROTLI_DEFAULT_WINDOW (22)
                                                #        - higher gives better compression, but consumes more memory, i.e. 2**NUM (i.e. def is 4MB)
                                                #     - [constants.BROTLI_PARAM_LGBLOCK] NUM:
                                                #        - between constants.BROTLI_MIN|MAX_INPUT_BLOCK_BITS (16|24)
                                                #        - higher gives better compression, but consumes more memory, i.e. 3 ** NUM
                                                #     - [constants.BROTLI_PARAM_SIZE_HINT] NUM:
                                                #        - input size hint
                                                #        - def 0, i.e. unknown
                                                #     - [constants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING] BOOL:
                                                #        - if true (def: false), poorer compression but faster decompression
                                                #     - [constants.BROTLI_PARAM_LARGE_WINDOW] BOOL:
                                                #        - if true (def: false), allow large windows, good for huge files
                                                #     - [constants.BROTLI_PARAM_NPOSTFIX|NDIRECT] NUM:
                                                #        - def 0
                                                #        - hint for number of direct distance codes and postfix bits.
                                                #        - those are two internal parameters of the algorithms, to use only when knowing it.
                                                #  - maxOutputLength: like createGzip|Deflate()
createZstdCompress([OBJ])->COMPRESS      23.8.0*#Same with Zstd. OBJ:
                                         23.8.0*#  - flush ENUM, finishFlush ENUM, among:
                                         23.8.0*#     - constants.ZSTD_e_continue (def)
                                         23.8.0*#     - constants.ZSTD_e_end (def for last chunk)
                                         23.8.0*#     - constants.ZSTD_e_flush (def for flush())
                                         23.8.0*#  - chunkSize NUM (def: 16KB)
                                         23.8.0*#  - params OBJ:
                                         23.8.0*#     - [constants.ZSTD_c_*]: options (not all documented here)
                                         23.8.0*#     - [constants.ZSTD_c_compression_level] NUM (def: constants.ZSTD_CLEVEL_DEFAULT, i.e. 3)
                                         23.8.0*#  - maxOutputLength: like createGzip|Deflate()
createGunzip|Inflate[Raw]|Unzip([OBJ])->UNCOMPRS#UNCOMPRESS is a IOSTREAM.
                                                #Unzip: autodetect whether Gunzip or Deflate (but not DeflateRaw).
createBrotliDecompress([OBJ])->UNCOMPRESS       #Same with Brotli. OBJ:
                                                #  - [constants.BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION] BOOL:
                                                #     - affects internal memory allocation
                                                #  - [constants.BROTLI_DECODER_PARAM_LARGE_WINDOW] BOOL: same as for compression
createZstdDecompress([OBJ])->UNCOMPRESS  23.8.0*#Same with Zstd. OBJ:
                                         23.8.0*#  - [constants.ZSTD_d_windowLogMax] NUM (power of 2): max memory
[UN]COMPRESS.flush([NUM, ]FUNC(ERROR))          #Compression uses an internal cache. Flush it.
                                                #Don't call unless necessary, because it impacts performance.
                                                #NUM def is constants.Z_FULL_FLUSH|BROTLI_OPERATION_FLUSH. See above for other values.
[UN]COMPRESS.reset()                            #Stop compressing any data going through.
                                                #Only for Deflate|Inflate
[UN]COMPRESS.params(LEVEL, STRATEGY,FUNC(ERROR))#
[UN]COMPRESS.bytesWritten                       #NUM

gzip|deflate[Raw]|brotli|ZstdCompress
(STDABUFFER[, OBJ], FUNC(ERROR, BUFFER))        #
gunzip|inflate[Raw]|unzip|brotli|ZstdDecompress
(STDABUFFER[, OBJ], FUNC(ERROR, BUFFER2))       #Convenience methods
*Sync(...)                                      #Same but sync

CompressionStream                        18.0.0*#See DOM doc
DecompressionStream                      18.0.0*#Global objects
                                        20.12.0*#Can use 'deflate-raw'

                                  ┌──────────────┐
                                  │   WARNINGS   │
                                  └──────────────┘

WARNINGS ==>                                    #Are similar to console.warn() except:
                                                #  - can be handled similarly to an exception, but does not stop execution
                                                #  - not part of normal JavaScript code flow
                                                #  - used by Node.js internal warnings, e.g. deprecations
                                                #  - should try to emit only once
                                                #By def, printed to console with console.warn()

--no-warnings
NODE_NO_WARNINGS=1 ENVVAR                       #Does not print to console. Still emits process.on('warning')
--disable-warning=TYPE|CODE             20.11.0*#Same for specific warning
--trace-warnings                                #Use console.trace() instead of console.warn()
--redirect-warnings=FILE
NODE_REDIRECT_WARNINGS=FILE ENVVAR              #I.e. will not be printed to console

PROCESS.emitWarning(ERROR)                      #Emits a warning
PROCESS.emitWarning('MESSAGE'[, 'TYPE']
[, 'CODE'][, FUNC])
PROCESS.emitWarning('MESSAGE',                  #Same but using new Error('MESSAGE') with name 'TYPE', code 'CODE', detail STR
[{ type, code, ctor, detail }])                 #If FUNC, calls Error.captureStackTrace(ERROR, FUNC)

process.on('warning', FUNC(ERROR))              #Fired on warnings.
                                                #ERROR: message 'MESSAGE', name 'TYPE'[, code 'CODE'][, detail STR]
                                                #By default:
                                                #  - prints `(node:${process.pid}) [${ERROR.code}] ${ERROR.toString()}\n${ERROR.stack}\n${ERROR.detail}`
                                                #    on stderr
                                                #  - ERROR.stack only printed if --trace-warnings

DEPRECATION ==>                                 #Type of warning with TYPE "DeprecationWarning"

UTIL.deprecate(FUNC, 'MESSAGE'[, 'CODE'])->FUNC #Make FUNC fire PROCESS.emitWarning('MESSAGE', 'DeprecationWarning', 'CODE')

--no-deprecation
--trace-deprecation                             #Like --no|trace-warnings but for deprecations
--throw-deprecation                             #throw error on deprecation
--pending-deprecation
NODE_PENDING_DEPRECATION=1 ENVVAR               #Includes upcoming deprecations

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

EXIT EVENTS ==>                                 #  - normal exit: beforeExit, exit
                                                #  - uncaught exception: uncaughtException, exit
                                                #  - process.exit(): exit
                                                #  - process.abort(): none
                                                #  - signals: only signals events
                                                #The only handler that will prevent exit from happening (graceful exit)
                                                #are SIGINT|SIGTERM
on("beforeExit", FUNC(INT))                     #FUNC() can be async. If async, it will be fired again. To avoid infinite loop,
                                                #last iteration must not add any microtask|macrotask.
                                                #INT is the exit code
on("exit", FUNC(INT))                           #FUNC() must be sync
process.exitCode                                #INT set in 'exit' handler providing either process.exit() or uncaught exception.
                                                #Can be set too
--trace-exit                                    #Print a stack when calling process.exit()
                                                #Not for other exit types (normal exits, signals, uncaught exceptions, etc.)

finalization.register[BeforeExit]        22.5.0*#Calls FUNC(OBJ) on process '[before]exit', except if OBJ has been GC'd
 (OBJ, FUNC(OBJ, '[before]exit'))        22.5.0*#Meant for doing cleanup of OBJ
                                         22.5.0*#Should avoid using arrow FUNC since it would keep reference to upper scope, i.e. OBJ would not be GC'd
finalization.unregister(OBJ)             22.5.0*#

[un]ref(OBJ)                            22.14.0*#Calls OBJ[Symbol.for('nodejs.[un]ref')](), meant to keep process alive

on("uncaughtException", FUNC(VAL, STR))         #Any exception VAL thrown and not caught in try/catch
                                                #Can be exception top-level or within a microtask/macrotask (callbacks)
                                                #Unless an event handler exists, calls process.exit(1)
                                                #  - should always call process.exit(1) within event handler to keep this behavior
                                                #STR is either:
                                                #  - 'unhandledRejection': came from --unhandled-rejections=strict
                                                #  - 'uncaughtException': otherwise
on('uncaughtExceptionMonitor', FUNC(VAL, STR))  #Same as on('uncaughtException') except:
                                                #  - does not prevent process.exit(1)
                                                #  - called first
setUnaughtExceptionCaptureCallback              #Same as on("uncaughtException") except:
 (FUNC(VAL)|null)                               #  - unsets "uncaughtException" handler
                                                #  - unsets --abort-on-uncaught-exception
hasUnaughtExceptionCaptureCallback()->BOOL      #
--abort-on-uncaught-exception                   #Create a dump file when process exited because of uncaught exception
--trace-uncaught                                #Make default uncaughtException handler also print stack trace of the line that threw
                                                #If ERROR throw, this will be same stack trace, shown twice.
                                                #But for non-ERROR, this is useful since they don't have stack traces otherwise.
                                                #Can be bad for garbage collection.
--force-node-api-uncaught-exceptions-policy     #Handle uncaught exceptions inside native modules as well

exit([UINT])                                    #Exit with exit code UINT (def: 0)
                                                #Pending microtasks|macrotasks will be aborted. Streams won't be flushed.
abort()                                         #Aborts: exits + produce a core file.

pid                                             #
ppid                                            #Parent's pid

SIGNALS ==>                                     #Node specifics:
                                                #  - signal 0 can be used to test for process existence
                                                #  - "SIGUSR1" will start debugger (not on Windows)
                                                #  - handling SIGINT|SIGTERM will remove default handler
                                                #  - cannot handle SIGKILL|SIGSTOP
                                                #Only on Linux: SIGPOLL, SIGPWR, SIGUNUSED
                                                #Only on Mac: SIGINFO
                                                #On Windows, only following work:
                                                #  - process.kill() only: 0, SIGINT, SIGTERM, SIGKILL
                                                #     - SIGINT can use process.on() but only with CTRL-C
                                                #  - process.on() only:
                                                #     - SIGBREAK: CTRL-BREAK on Windows, similar to CTRL-C
                                                #     - SIGHUP: closing cmd.exe window
                                                #     - SIGWINCH, SIGILL, SIGABRT, SIGFPE, SIGSEGV
--disable-sigusr1                       22.14.0*#Do not start debugger on SIGUSR1

kill(PID_INT[, 'SIGNAME'|SIGNUM])->BOOL         #Sends a signal (def: "SIGTERM").
                                                #If PID_INT doesn't exist, throw exception (can use 0 to just test process existence).
                                                #If PID_INT is negative, targets also descendants (Unix only)
                                                #Return true if succeeded
OS.constants.signals.SIGNAME                    #SIGNUM
                                                #SIGNAME is OS-agnostic, SIGNUM is OS-specific
                                                #All OS miss SIGEMT SIGCLD SIGRTMIN SIGRTMAX
                                                #Linux misses SIGINFO
                                                #Mac misses SIGPOLL SIGPWR SIGUNUSED
                                                #Linux|Mac miss SIGBREAK
                                                #Windows signals are emulated by Node.js and only for:
                                                #  - process.kill(): SIGINT SIGTERM SIGKILL SIGQUIT
                                                #  - process.on(): SIGINT SIGABRT SIGHUP SIGBREAK SIGWINCH SIGILL SIGFPE SIGSEGV
on('SIGNAL', FUNC('SIGNAL'))                    #Fires when signal emitted on current process.
--trace-sigint                                  #Print a stack trace on SIGINT. Still keep SIGINT default handler

on('unhandledRejection', FUNC(VAL, PROMISE))    #When PROMISE:
                                                #  - is rejected
                                                #  - and has no handler (PROMISE.catch())
--unhandled-rejections=STR                      #What to do on 'unhandledRejection':
                                                #  - 'strict': 'unhandledRejection' event + uncaughtException
                                                #  - throw (def): 'unhandledRejection' event + (unless that event was handled) uncaughtException
                                                #  - warn-with-error-code: 'unhandledRejection' event + (unless that event was handled) warning + process.exitCode 1
                                                #  - 'warn': 'unhandledRejection' event + (unless that event was handled) warning + (once) deprecation warning
                                                #  - 'none': nothing
on('rejectionHandled', FUNC(PROMISE))           #When adding PROMISE.catch() on a PROMISE that:
                                                #  - was already rejected
                                                #  - and had no handler when it was rejected (i.e. 'unhandledRejection')
                                                #  - and was rejected in a previous macrotask

argv                                            #Command line args as STR_ARR. Doesn't include node options.
                                                #First is "node", second the absolute path of FILE, then the other arguments.
execArgv                                        #Same but only for node options (exclude all STR of argv)
execPath                                        #Absolute path of node executable used.

env                                             #Environment variables, as OBJ. Values are strings.
                                                #Case-insensitive on Windows.
--trace-env                             22.13.0*#Print ENVVAR being get|set
                                                #Includes ones done internally by Node.js
--trace-env-js-stack                    22.13.0*#Same but also print stack in JavaScript
--trace-env-native-stack                22.13.0*#Same but also print stack in C / libuv

title                                           #Process title displayed in ps. Read/write. Usually short max length.
                                                #Cannot set to smaller length than the initial value
--title STR                                     #Set PROCESS.title

process.loadEnvFile(['PATH'|BUFFER|URL])20.12.0*#Load ENVVARs from a FILE (def: './.env')
                                         20.6.0*#Each line is ENVVAR=VAL
                                         20.6.0*#Can use #COMMENT
                                         20.6.0*#Can "-quote, '-quote, \-escape VAL
                                        20.12.0*#Quoted values can be multiline
                                         20.6.0*#Ignores ENVVAR NODE_OPTIONs
--env-file=FILE                          20.6.0*#Same
--env-file-if-exists=FILE                22.9.0*#Same but does not fail if does not exist
process.parseEnv(STR)->OBJ              20.12.0*#Parses env file contents

cwd()->'DIR'                                    #Current directory
                                                #Is the one of the main file. Required files do not change it.
chdir('DIR')                                    #

CROSS-OS ==>                                    #All the following throw on Windows
get[e]gid|[e]uid()                              #
set[e]gid|[e]uid(UINT|STR)                      #
getgroups()
setgroups(STR_ARR)                              #Supplementary GIDs.
initgroups(STR, STR2[_ARR])                     #

umask(UINT)                                     #See below for Windows behavior

version                                         #Node.js version 'vSERMVER'
navigator.userAgent                      21.1.0*#'Node.js/NUM'
release.name                                    #'node|io.js'
release.sourceUrl|headersUrl                    #'URL'
release.lts                                     #'NAME' when LTS
versions                                        #OBJ with members node v8 uv uvwasi zlib acorn ada ares base64 brotli cjs_module_lexer
                                                #modules nghttp2|3 ngtcp2 napi llhttp http_parser openssl icu unicode cldr tz simdjson simdutf
config                                          #Config flags and variables used during compilation, as OBJ

arch                                            #Same as OS.arch()
platform                                        #Same as OS.platform()

memoryUsage()->OBJ                              #OBJ
                                                #  - rss NUM: space occupied by process (including code)
                                                #  - heapUsed|heapTotal NUM: subset of rss for heap
                                                #  - external NUM: subset of heap for JavaScript objects stored in C++
                                                #  - arrayBuffers NUM: subset of external for [SHARED_]ARR_BUFFER
memoryUsage.rss()->NUM                          #Like memoryUsage().rss, but faster
availableMemory()->NUM                  20.13.0*#Memory still available to process
constrainedMemory()->NUM                18.15.0*#Process max memory constraint. Only for cgroup on Linux. undefined otherwise.
cpuUsage([OBJ])->OBJ                            #OBJ: user|system NUM (time usage, in microseconds)
                                                #If OBJ passed, is difference.
threadCpuUsage([OBJ])->OBJ               23.9.0*#Same but only for current thread
uptime()                                        #

resourceUsage()->OBJ                            #OBJ:
                                                #  - user|systemCPUTime NUM: same as cpuUsage().user|system
                                                #  - maxRSS NUM (in KB): max RSS memory
                                                #  - minor|majorPageFault NUM: number of page faults
                                                #  - fsRead|fsWrite NUM: number of I/O operations
                                                #  - [in]voluntaryContextSwitches NUM: CPU time slices switches (not on Windows)
                                                #  - sharedMemorySize|unsharedDataSize|unsharedStackSize|swappedOut|ipcSent|ipcReceived|signalsCount NUM: does not work on any OS

hrtime([VAL])->VAL                              #Current time as [UINT, UINT2], where UINT is seconds and UINT2 nanoseconds.
                                                #Not real time, but arbitrary one just to compare with another time check.
                                                #If VAL passed, is difference.
                                                #Better that using new Date(), notably because ns not ms
                                                #Resolution:
                                                #  - 1ms to 1ns, depending on hardware
                                                #  - often 1ns on Linux/Mac machines
hrtime.bigint()->BIGINT                         #Same but using BIGINT nanosecs instead of [UINT, UINT2]

                                  ┌───────────────────┐
                                  │   CHILD_PROCESS   │
                                  └───────────────────┘

spawn(STR[, STR2_ARR][, OPTS])->CHILDPROCESS    #Creates and runs a CHILDPROCESS from command line "STR ...STR2_ARR"
                                                #  - cwd STR|FILE_URL (def: null, i.e. current)
                                                #  - env OBJ (def: process.env)
                                                #  - uid|gid UINT
                                                #     - def: current ones using `setuid|setgid` syscalls
                                                #     - fails on Windows
                                                #  - stdio STR_ARR:
                                                #     - how parent can access child's file descriptors
                                                #     - at least first three ones, stdin|out|err, but can continue with fd 3, etc.
                                                #     - among:
                                                #        - "pipe":
                                                #           - anonymous pipe
                                                #           - write-only (parent to child) if stdin, read-only (child to parent) otherwise
                                                #           - enable CHILDPROCESS.stdio[FD_INT]|stdin|out|err
                                                #        - "overlapped"
                                                #           - same as "pipe" except, on Windows, use sync I/O instead of async
                                                #        - "ipc":
                                                #           - bidirectional anonymous pipe
                                                #           - enable CHILDPROCESS.send()
                                                #           - can only do it for one file descriptor
                                                #        - "ignore": with nothing
                                                #        - STREAM: pipe file descriptor to it (like NUM> FILE)
                                                #        - FD_INT: same with parent file descriptor (like NUM>&FD_INT) (not on Windows)
                                                #        - null|undefined (def): "pipe" for stdin|out|err, "ignore" for others.
                                                #     - can use the following shortcuts STR instead:
                                                #        - "ignore": [ "ignore", "ignore", "ignore" ]
                                                #        - "pipe": [ "pipe", "pipe", "pipe" ]
                                                #        - "inherit": [ 0, 1, 2 ]
                                                #  - serialization STR:
                                                #     - how to serialize VAL of CHILD_PROCESS.send()
                                                #     - either:
                                                #        - 'json' (def)
                                                #        - 'advanced' (V8.[de]serialize())
                                                #           - BIGINT|undefined allowed but not top-level
                                                #  - shell STR3|BOOL (def: false)
                                                #     - false (def): runs 'STR ...STR2_ARR'
                                                #        - on Windows, only works with `*.exe|com|cmd|bat`
                                                #        - no shell escaping done on either Linux/Windows
                                                #     - STR3: runs 'STR3 -c "STR ...STR2_ARR"'
                                                #        - 'STR3 /d /s /c "STR ...STR2_ARR"' instead if cmd.exe
                                                #     - true: same but using '/bin/sh' (Unix) or ENVVAR ComSpec or 'cmd.exe' (Windows)
                                                #  - windowsVerbatimArguments BOOL:
                                                #     - no shell escaping (Windows only)
                                                #     - def: true if OPTS.shell with 'cmd.exe', false otherwise
                                                #  - argv0 STR (def: STR): process.argv[0]
                                                #     - does not work with node.js binary itself
                                                #     - does not modify `process.title` on Windows
                                                #  - detached BOOL (def: false):
                                                #     - child process will outlive parent
                                                #        - regardless on how parent was terminated: normally, runtime error,
                                                #          programmatic signal, CTRL-C, CTRL-\
                                                #        - on Unix, child process always does, even if `detached: false`, except for `CTRL-C` (in terminal)
                                                #     - create a new process group
                                                #  - windowsHide BOOL (def: false) (Windows only):
                                                #     - if detached true and in terminal:
                                                #        - do not create new terminal window
                                                #        - but cannot use CTRL-C
                                                #  - signal ABORT_SIGNAL: kill() on cancel
                                                #  - timeout NUM (def: 0) (in ms)
                                                #Use CHILDPROCESS.ref(), so needs to use unref() if program can exit while CHILDPROCESS is running.
fork(STR[, STR2_ARR][, OPTS])->CHILD_PROCESS    #Same as spawn() but using 'node STR ...STR2_ARR'
                                                #OPTS:
                                                #  - shell: always false
                                                #  - stdio:
                                                #     - def 'inherit'
                                                #     - always add 'ipc' to fourth ARR value
                                                #Extra OPTS:
                                                #  - execPath 'PATH': instead of 'node'
                                                #  - execArgv STR_ARR: arguments passed to execPath (e.g. node CLI flags)
                                                #  - silent BOOL (def: false): same as OPTS.stdio 'pipe'
fork(URI, ...)->CHILD_PROCESS                   #
execFile(STR[, STR2_ARR][, OPTS],               #Same as spawn() but using FUNC() instead of returning CHILDPROCESS.
 FUNC(ERROR, SVAL, SVAL2))->CHILD_PROCESS       #  - SVAL|SVAL2 is stdout|stderr
                                                #Cannot use OPTS: stdio, argv0, detached
                                                #Extra OPTS:
                                                #  - encoding 'ENCODING' or null|'buffer' (def: 'utf8')
                                                #  - maxBuffer NUM (def: 200KB): stdout|stderr max size
                                                #  - killSignal 'SIGNAL'|SIGNUM (def: 'SIGTERM'): sent (with CHILD_PROCESS.kill()) on timeout|maxBuffer|signal
                                                #    (not on explicit CHILD_PROCESS.kill())
exec(STR[, OPTS], FUNC(ERROR, SVAL, SVAL2))
 ->CHILD_PROCESS                                #Same as execFile() but with OPTS.shell def true

spawnSync(...)                                  #Like spawn() except for the following.
                                                #Extra OPTS:
                                                #  - input STDBUFFER: overrides OPTS.stdio[0] (which must be not set, or default value 'pipe')
                                                #  - encoding (def: 'buffer')
                                                #  - timeout, killSignal, maxBuffer
                                                #  - OPTS.stdio: no 'overlapped' nor 'ipc'
                                                #Returns:
                                                #  - pid UINT
                                                #  - stdout|stderr SVAL
                                                #  - output [stdout, stderr]
                                                #  - status NUM: null if killed by signal
                                                #  - signal 'SIGNAL'
                                                #  - error ERROR
exec[File]Sync(...)                             #Like exec[File]() except for the following.
                                                #Extra OPTS: input, stdio, detached, argv0
                                                #Returns SVAL (stdout). Throws on non-0 exit code.

CHILDPROCESS.pid                                #

CHILDPROCESS.stdio[FD_INT]                      #I|OSTREAM for file descriptor FD_INT. null if not 'pipe|overlapped'
CHILDPROCESS.stdin|out|err                      #Same for 0|1|2

CHILDPROCESS.on("spawn", FUNC())                #Fired when CHILDPROCESS initialized but command not started yet
CHILDPROCESS.on("error", FUNC(ERROR))           #When CHILDPROCESS could not spawn() or send|kill|disconnect()
                                                #The exit event might be fired or not after error event.
CHILDPROCESS.on("exit|close",FUNC(UINT,SIGNAME))#UINT is the exit code, SIGNAME the terminating signal.
                                                #Only one of them is always defined, the other is null.
                                                #exit is when process exits
                                                #close is when process exits, all file descriptors closed and IPC disconnected
                                                #file descriptors don't close if shared by other processes.
process.signalCode                              #Like process.exitCode but for SIGNAME

CHILDPROCESS.kill(['SIGNAL'|SIGNUM])            #Def: "SIGTERM"
CHILDPROCESS.killed                             #BOOL. Whether CHILD_PROCESS.kill() was called (including with non-termination SIGNAL)
                                                #Does not check whether CHILD_PROCESS was terminated by signal: use `exit` SIGNAME instead
CHILDPROCESS[Symbol.dispose]()          18.18.0*#Calls CHILDPROCESS.kill()

[CHILD]PROCESS.send                             #Communication:
(VAL[, TCP|UDPSOCKET|SERVER][, OPTS]            #  - parent use CHILDPROCESS.on("message") and CHILDPROCESS.send(...)
[, FUNC([ERROR])])->BOOL                        #  - child use PROCESS.on("message") and PROCESS.send(...)
                                                #Child process must have been created using "ipc" (see above)
                                                #See OPTS.serialization above for which VAL type is allowed
                                                #FUNC is fired after sending (when flushed), before target received
                                                #FUNC(ERROR):
                                                #  - possible ERRORs:
                                                #     - [CHILD]PROCESS.connected false: ERROR.code 'ERR_IPC_CHANNEL_CLOSED'
                                                #     - I/O error: ERROR.sycall 'write'
                                                #  - if not specified, emits 'error' event on PROCESS|CHILDPROCESS
                                                #Can also throw ERROR (as opposed to calling FUNC(ERROR)) if invalid VAL:
                                                #  - undefined: ERROR.code 'ERR_MISSING_ARGS'
                                                #  - BIGNUM|SYM|FUNC: ERROR.code 'ERR_INVALID_ARG_TYPE'
                                                #  - other serialization errors
                                                #Returns false if either:
                                                #  - ERROR
                                                #  - should stop sending, due to backpressure either:
                                                #     - max 350325 bytes
                                                #     - max 1 message when specifying TCP|UDPSOCKET|SERVER
                                                #     - like STREAMs highWaterMark: it is advisory only
                                                #     - that buffer is cleared each time FUNC() is called
                                                #        - i.e. instead of checking BOOL, can just wait for FUNC() to be called
                                                #Parent can send messages before the child has setup `message` event listener. In the child:
                                                #  - they are buffered (no limit)
                                                #  - buffer is cleared when first event listener setup on `process` (detected using 'newListener' event)
                                                #  - then no more buffering
                                                #When sending a TCP|UDPSOCKET|SERVER, it will be shared between parent and child:
                                                #  - packets will arrive randomly at both
                                                #  - only one needs to listen
                                                #  - for TCP|UDPSERVER, both can listen to 'connection' event
                                                #OPTS:
                                                #  - keepOpen BOOL (def: false): see TCPSOCKET
[CHILD]PROCESS.on("message",
FUNC(VAL[, TCPSOCKET|TCPSERVER]))               #Guaranteed to be received in same order as sent
[CHILD]PROCESS.disconnect()                     #Becomes impossible to do send() on either side
                                                #Throws if [CHILD]PROCESS.connected false
                                                #Flushes pending messages (both TCP|UDP and others)
[CHILD]PROCESS.connected                        #BOOL. When false:
                                                #  - if [CHILD]PROCESS.channel not null: flushing messages (TCP|UDP only), but no new one
                                                #  - else: no more TCP|UDP messages to flush (but might still be some non-TCP|UDP)
[CHILD]PROCESS.on("disconnect", FUNC())         #Once flushing of messages done (both TCP|UDP and others)
[CHILD]PROCESS.channel                          #Underlying EVENTEMITTER for send()
                                                #Under the hood:
                                                #  - uses a file descriptor
                                                #     - communicated to child using ENVVAR NODE_CHANNEL_FD, but deleted by Node on subprocess start
                                                #     - same for OPTS.serialization, communicated with ENVVAR NODE_CHANNEL_SERIALIZATION_MODE
                                                #  - uses a named pipe, but uses recvmsg syscall (Unix) instead of read (Unix)
                                                #     - i.e. similar to objectMode: reads|sends per-message, not per-byte
[CHILD]PROCESS.channel.ref()                    #Keeps [CHILD]PROCESS alive
                                                #Automatically called on:
                                                #  - PROCESS.on('message|disconnect')
                                                #  - PROCESS.once('message|disconnect'), but removed once received
                                                #  - [CHILD]PROCESS.send() while ongoing (i.e. until its FUNC() callback fired)
[CHILD]PROCESS.channel.unref()                  #Automatically called on [CHILD]PROCESS:
                                                #  - exit
                                                #  - disconnect()
                                                #  - removeListener('message|disconnect')
                                                #If .ref|unref() called manually, does not do automatical call anymore
                                                #  - e.g. if unref(), will not automatically wait for send() or once('message') to complete
[CHILD]PROCESS.channel.fd                       #NUM
                                                #In subprocess, same as the one specified on OPTS.stdio
                                                #In parent, different one

DIAGNOSTICS_CHANNEL.subscribe
 ('child_process', FUNC(OBJ))                   #OBJ: process CHILD_PROCESS

                                  ┌─────────────┐
                                  │   CLUSTER   │
                                  └─────────────┘

GOAL ==>                                        #A single process will only use only one CPU core.
                                                #Using CHILDPROCESS.fork() on the same code to create one child for each CPU
                                                #core.
                                                #Can manage the workers: kill some, manage a pool, etc.
                                                #Work should be done by child processes, master should only manage them.
                                                #Child processes cannot fork() to grandchild processes.
                                                #One common task is to make CHILDPROCESS TCPSERVER.listen(), in which case:
                                                #  - connections will arrive randomly at the child processes listening to
                                                #    the same port.
                                                #    The randomness uses CLUSTER.schedulingPolicy:
                                                #      - CLUSTER.SCHED_RR (def on Unix): improved round-robin
                                                #      - CLUSTER.SCHED_NONE (def on Windows): previous version
                                                #    or use ENVVAR NODE_CLUSTER_SCHED_POLICY "rr|none"
                                                #  - be careful:
                                                #     - listen(TCPSERVER|TCPSOCKET): TCPSERVER|TCPSOCKET must have been sent by master
                                                #       to child, or will create problems
                                                #     - listen({ fd: INT }): looks at parent file descriptor
                                                #  - if UDPSOCKET.bind() or TCPSERVER.listen() OBJ.exclusive true (def: false), socket is not shared
fork([OBJ])                                     #Like CHILD_PROCESS.fork(), but returns a WORKER, which gives extra functions.
                                                #Can fork a separate file for children, but if forking the same file, should
                                                #use if ( CLUSTER.isPrimary|Worker ) in beginning of code.
                                                #OBJ is env (def: process.env).
                                                #Options are controlled by CLUSTER.settings, that is available for read once
                                                #CLUSTER.setupPrimary(OBJ) has been called to change it (only once):
                                                #  - exec STR: the file the child is forked with (def: process.argv[1])
                                                #  - args STR (def: process.argv.slice(2)): to worker
                                                #  - execArgv STR_ARR (def: process.execArgv): to node
                                                #  - silent BOOL: like CHILDPROCESS.fork() (def: false)
                                                #  - cwd, windowHide: like CHILD_PROCESS.spawn()
                                                #  - serialization: like CHILD_PROCESS.spawn()
                                                #  - uid|gid UINT, stdio
                                                #setupPrimary() fire 'setup'(OBJ) event
on("fork|online", FUNC(WORKER))                 #Fired when a child process is created|ready to respond.
WORKER.on("online", FUNC())                     #
on("listening", FUNC(WORKER, OBJ))              #Fired when a child process use TCPSERVER.listen().
                                                #OBJ has members { address, port, addressType: "[udp]4|6|-1(Unix socket)" }
WORKER.on("listening", FUNC(OBJ))               #

workers                                         #All WORKER in an OBJ, where the key is the WORKER.id
                                                #Only available in parent process.
worker                                          #Current WORKER. Only available in child processes.
WORKER.id                                       #
WORKER.process                                  #The underlying CHILDPROCESS.
                                                #In a WORKER, can use process.* directly

WORKER.send(VAL[,TCPSOCKET|TCPSERVER][, FUNC()])#
WORKER.on
("message", FUNC(OBJ[, TCPSOCKET|TCPSERVER]))   #
on('message', FUNC(WORKER TCPSOCKET|TCPSERVER,
OBJ))                                           #
WORKER.kill(['SIGNAL'])                         #Calls WORKER.disconnect(), then in:
                                                #  - the parent, sends signal (def: "SIGTERM")
                                                #  - the child processes, exit with error code 0

WORKER.disconnect()->WORKER                     #If listen() was called, don't accept new connections and emit TCPSERVER.close()
                                                #when no more connections (only server connections, not CLIENTREQ, that
                                                #are closed directly).
                                                #Might be useful to use a timeout to kill the WORKER if connections keep on
                                                #living.
disconnect(FUNC())                              #Call disconnect() on all child processes (must be done from parent).
on("disconnect", FUNC(WORKER))                  #Fired when a child process use disconnect()
WORKER.on("disconnect", FUNC())                 #
WORKER.isConnected()                            #
WORKER.isDead()                                 #True if exited of thrown exception
WORKER.exitedAfterDisconnect                    #When WORKER exits, will be false if exited because of an exception, and true
                                                #if because of kill() or disconnect()
on("exit", FUNC(WORKER, UINT, 'SIGNAL'|null))   #Fired when a child process exits.
                                                #UINT is the exit code
WORKER.on("exit", FUNC(UINT, 'SIGNAL'|null))    #
WORKER.on("error", FUNC(ERROR))                 #

                                  ┌────────────────────┐
                                  │   WORKER_THREADS   │
                                  └────────────────────┘

ISOMORPHISM ==>                                 #Inspired by DOM workers but with notable differences

MULTI-THREADING ==>                             #Uses threads not processes, i.e.:
                                                #  - uses OS time slicing i.e.:
                                                #     - long microtasks are processed in several steps
                                                #     - load between threads is balanced by OS
                                                #  - for each time slice, uses any available CPU, i.e. scale to all CPUs
                                                #I.e. good for CPU-intensive tasks (not I/O intensive)

new Worker(SCRIPT[, OPTS])                      #SCRIPT is 'PATH', FILE_URL or data: URL
                                                #OPTS:
                                                #  - eval BOOL (def: false): use inline 'JAVASCRIPT' instead
                                                #  - workerData VAL:
                                                #     - assigned to WORKER_THREADS.workerData VAL
                                                #     - same possible types as postMessage()
                                                #  - transferList VAL:
                                                #     - with OPTS.workerData, the VAL2_ARR connected to it
                                                #       (like postMessage(OPTS.workerData, OPTS.transferList))
                                                #  - argv STR_ARR: process.argv
                                                #     - same possible types as postMessage()
                                                #  - execArgv STR_ARR (def: process.execArgv)
                                                #  - env OBJ (def: process.env)
                                                #     - copied
                                                #     - can be require('worker_threads').SHARE_ENV, to pass process.env by reference instead
                                                #  - resourceLimits OBJ:
                                                #     - terminates process if reaches those limits
                                                #     - does not include ARRBUFFER
                                                #     - OBJ:
                                                #        - maxOldGenerationSizeMb NUM: main heap max size
                                                #        - maxYoungGenerationSizeMb NUM: recently created objects heap max size
                                                #        - codeRangeSizeMb NUM: code max size
                                                #        - stackSizeMb NUM (def: 4): stack max size
                                                #  - trackUnmanagedFds BOOL (def: true): on exit, automatically call any FD_INT if FS.close() was not called
                                        18.16.0*#  - name STR: for debugging

globalThis.*                                    #In worker, like in parent except process.*:
                                                #  - exit() affects current thread not current process
                                                #  - no abort|chdir|initgroups|set*|umask(VAL)|on('SIGNAL')
                                                #  - env|title are read-only
                                                #  - cannot use TRACE_EVENTS
                                                #Worker and parent's global|process.* are distinct.
                                                #Unlike DOM, no concept of WORKERGLOBAL nor "self".

process.stdin|stdout|stderr                     #Worker has different standard streams than parent, but they are piped:
                                                #  - from parent if OPTS.stdin true (def: false)
                                                #  - to parent unless OPTS.stdout|stderr true (def: false)
WORKER.stdin|stdout|stderr                      #Worker's standard streams, available to parent

WORKER_THREADS.isMainThread                     #BOOL. True if is top-level parent.

WORKER_THREADS|WORKER.threadId                  #THREAD_ID, which is a NUM
                                                #Top-level parent is 0. Then increments for each worker

WORKER.resourceLimits                           #Like OPTS.resourceLimits

WORKER.on('online', FUNC())                     #When worker is loaded, just before it starts executing

WORKER.terminate()->PROMISE_EXIT_CODE           #Worker current microtask will be interrupted
                                                #EXIT_CODE will be 1
                                                #Async and return a PROMISE

process.on('worker', FUNC(WORKER))              #When worker starts
WORKER.on('exit', FUNC(EXIT_CODE))              #When worker ends (including because of uncaught exceptions)

WORKER.on('error', FUNC(ERROR))                 #Uncaught exception within worker.

MESSAGEPORT|WORKER.[un]ref()                    #

setEnvironmentData(KEY, VAL)                    #Similar to process.env except:
getEnvironmentData(KEY)->VAL                    #  - can use any KEY|VAL type
                                                #  - thread-specific (not process-specific)

WORKER|MESSAGEPORT.postMessage                  #Like DOM except:
 (VAL[, VAL2_ARR])                              #  - child can only use MESSAGEPORT, not global "postMessage()"
                                                #  - VAL2:
                                                #     - can be SHARED_ARRBUFFER
                                                #     - can be BLOB
                                                #     - can be RSTREAM|WSTREAM|TSTREAM
                                                #     - can be FILE_HANDLE or crypto KEY
                                                #     - when MESSAGEPORT, VAL must be MESSAGEPORT
WORKER|MESSAGEPORT.on('message', FUNC(VAL))     #Like DOM except:
                                                #  - receive VAL directly, not MESSAGEEVENT
                                                #  - MESSAGEPORT will keep process open until MESSAGEPORT.close|unref()
WORKER|MESSAGEPORT.on
 ('messageerror', FUNC(ERROR))                  #Like DOM
WORKER.receiveMessageOnPort                     #If there is a message VAL in the queue, return it and remove it from queue.
 (MESSAGEPORT|BROADCAST_CHANNEL)->VAL           #Otherwise return undefined
WORKER.moveMessagePortToContext                 #Transfer MESSAGEPORT to another global object COBJ (created by VM.createContext())
 (MESSAGEPORT, COBJ)->MESSAGEPORT2              #MESSAGEPORT will become unusable
                                                #'message' event listeners are kept
WORKER.markAsUntransferable(VAL2)               #If VAL2 is passed to postMessage(), ignore it from the VAL2_ARR
WORKER.isMarkedAsUntransferable
 (VAL2)->BOOL                            21.0.0*#
WORKER.markAsUncloneable(VAL)           22.10.0*#If VAL is passed to postMessage(VAL), throw an error

postMessageToThread                             #Same as WORKER.postMessage() except using THREAD_ID
 (THREAD_ID, VAL[, VAL2_ARR[, NUM]])->>         #Goal: when WORKER is not direct child
                                                #PROMISE resolves when WORKER received the message, or times out after NUMms (def: none)
                                                #Cannot send to itself
                                                #WORKER must have 'workerMessage' set
WORKER.on('workerMessage', FUNC(VAL, THREAD_ID))#Like WORKER.on('message') but with postMessageToThread()

new MessageChannel()
MESSAGECHANNEL.port1|2
new MessagePort()
MESSAGEPORT.postMessage(VAL[, VAL2_ARR])
MESSAGEPORT.on('message', FUNC(MESSAGEEVENT))
MESSAGEPORT.on('messageerror', FUNC(ERROR))
MESSAGEPORT.start|close()                       #Like DOM, except MessagePort is an EventEmitter instead of EventTarget
MESSAGEPORT.on('close', FUNC())                 #Exposed globally
MESSAGEPORT.[un]ref()                           #Node.js specific
MESSAGEPORT.hasRef()->BOOL                      #

WORKER_THREADS.parentPort                       #Default MESSAGEPORT available in every worker.
                                                #null in parent

isInternalThread                        22.14.0*#BOOL. Whether currently in an internal thread (e.g. the one used internally during load)

new BroadcastChannel('CHANNEL_NAME')            #Like DOM
                                                #Global object
BROADCAST_CHANNEL.name
BROADCAST_CHANNEL.postMessage(VAL)
BROADCAST_CHANNEL.on('message[error]', FUNC)
BROADCAST_CHANNEL.close()                       #
BROADCAST_CHANNEL.[un]ref()                     #Node.js specific

DIAGNOSTICS_CHANNEL.subscribe
 ('worker_threads', FUNC(OBJ))                  #OBJ: worker WORKER

                                  ┌────────┐
                                  │   VM   │
                                  └────────┘

ALTERNATIVES ==>                                #When running 'Math.random()'
                                                #Execution time:
                                                #  - as is:  0.000006ms
                                                #  - eval(): 0.0001ms
                                                #  - runIn*Context(): 0.001ms
                                                #     - with SCRIPT: same performance, but can divide between loading (new Script)
                                                #       and executing (SCRIPT.runIn*Context())
                                                #  - spawn(): 1.3ms
                                                #  - Worker(): 6ms
                                                #Security:
                                                #  - as is, eval(): access to current process + context
                                                #  - runIn*Context(): access to current process
                                                #  - Worker(): access to none (providing OPTS.stdin|stdout|stderr true)
                                                #  - spawn(): access to none
                                                #Limits:
                                                #  - as is, eval(): defaults (max call stack, max STR|ARR length)
                                                #  - runIn*Context(): defaults, timeout
                                                #  - Worker(): defaults, seems to crash over 1000 threads
                                                #  - spawn(): defaults, timeout, maxBuffer
                                                #Threads/processes:
                                                #  - as is, eval(), runIn*Context(): same thread|process
                                                #  - Worker(): different thread
                                                #  - spawn(): different process
                                                #Similar to REALMs, but with more features

createContext([CONT_OBJ][, CONT_OPTS])->COBJ    #COBJ is an OBJ with some hidden properties.
                                                #CONT_OBJ is merged in
                                                #  - def: {}
                                        20.18.0*#  - can be constants.DONT_CONTEXTIFY, which is like {} but:
                                        20.18.0*#     - globalThis === COBJ (reference, not proxy)
                                        20.18.0*#     - globalThis can be frozen
                                                #CONT_OPTS:
                                                #  - name STR (def: 'VM Context NUM'): for debugging
                                                #  - origin PROTO://HOST[:PORT] (def: ''): for debugging
                                                #  - codeGeneration:
                                                #     - strings BOOL (def: true): if false, throws on eval() or derivatives (new Function(...), etc.)
                                                #     - wasm BOOL (def: true): if false, throws when trying to compile WASM
                                                #  - microtaskMode STR (def: nothing): if 'afterEvaluate':
                                                #     - wait for current macrotask to complete, i.e. all microtasks done
                                                #     - RUN_OPTS.timeout|breakOnSigint will work microtask-wise, not macrotask-wise
                                        18.20.0*#  - importModuleDynamically('SPECIFIER', PARENT_VMMODULE, OBJ)->[>]VMMODULE:
                                        18.20.0*#     - called on import('SPECIFIER'[, OBJ])
                                        18.20.0*#     - def: throw error
                                        20.12.0*#     - can be vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER, to use the default import() behavior
isContext(COBJ)->BOOL                           #Returns true if COBJ

runInContext(STR, COBJ[, RUN_OPTS])             #Like eval() but use context COBJ as unique global environment:
                                                #  - passed by reference.
                                                #  - does not have any other access to caller otherwise,
                                                #    including current caller local scope
                                                #Also:
                                                #  - use current process:
                                                #     - same file descriptors
                                                #     - throw exception in current process
                                                #     - should create a new process first if VM used for security reason.
                                                #  - returns synchronous return value from code STR
                                                #     - but can still inspect COBJ passed by reference for async return value,
                                                #       or pass COBJ.FUNC()
                                                #RUN_OPTS:
                                                #  - filename STR, line|columnOffset NUM: for stack trace error message
                                                #  - displayErrors BOOL (def: true): prints to current stderr any stderr
                                                #    from code
                                                #  - timeout NUM: throw error if timeout
                                                #  - breakOnSigint BOOL (def: false): terminate on SIGINT
                                                #  - cachedData BUFFER:
                                                #     - can also be TYPED_ARR|DATAVIEW
                                                #     - copy of script, to improve load performance
                                                #     - created by SCRIPT|SOURCE_TEXT_MODULE.createCachedData()->BUFFER
                                                #     - V8.cachedDataVersionTag()->NUM:
                                                #        - returns a hash of v8 version, CLI flags and CPU features
                                                #        - to use as cache key
                                                #     - SCRIPT.cachedDataRejected true if invalid type
                                                #  - importModuleDynamically: like createContext()
runInNewContext(STR[, CONT_OBJ][, RUN_OPTS])    #Same but automatically use createContext(CONT_OBJ, CONT_OPTS)
                                                #Additional RUN_OPTS:
                                                #  - context*: like CONT_OPTS.*
runInThisContext(STR[, RUN_OPTS])               #Same as runInNewContext(STR, global)

compileFunction('CODE'[, 'PARAM_NAME'_ARR]      #Like new Function() but use OPTS.parsingContext COBJ (def: global)
 [, RUN_OPTS|SCRIPT_OPTS])->FUNC                #RUN_OPTS|SCRIPT_OPTS:
                                                #  - filename, line|columnOffset, cachedData, importModuleDynamically(),
                                        18.15.0*#    cachedDataRejected,
                                                #  - contextExtensions OBJ_ARR (def: []): objects wrapping COBJ

new Script(STR[, RUN_OPTS])                     #Returns a SCRIPT, i.e. a compiled version of STR:
                                                #  - separates compiling from running STR
                                                #  - every run can be bound to different COBJ
                                                #RUN_OPTS:
                                                #  - displayErrors|timeout|breakOnSigint are specified during run*(...)
                                                #  - others are specified during new Script()
SCRIPT.runIn[New|This]Context(...)              #Same as run*(STR, ...)

--experimental-vm-modules                       #Must be used for VMMODULE
VMMODULE                                        #Same as SCRIPT but for ES module
                                                #Creates by new SourceTextModule() and new SyntheticModule()
VMMODULE.link                                   #Specifies the function to resolve SPECIFIERs,
 (FUNC('SPECIFIER', PARENT_VMMODULE, OBJ))      #I.e. when using import { SPECIFIER } from VMMODULE
 ->[PROMISE_]VMMODULE                           #Must be called only once.
                                                #VMMODULE and PARENT_VMMODULE must have same COBJ
                                                #OBJ is { attributes } containing `import ... with { ... }`
VMMODULE.linkingStatus                          #Can be:
                                                #  - 'unlinked': before VMMODULE.link()
                                                #  - 'linking': during VMMODULE.link()
                                                #  - 'linked': after VMMODULE.link() success
                                                #  - 'evaluating': before VMMODULE.evaluate()
                                                #  - 'evaluated': after VMMODULE.evaluate() success
                                                #  - 'errored': after VMMODULE.link() error
VMMODULE.error                                  #If linkingStatus 'errored', contains link() rejected promise value.
                                                #Otherwise, accessing it throws an exception.
VMMODULE.instantiate()                          #Must be called after VMMODULE.link()
                                                #Might throw if problem importing|exporting
                                                #The function is memoized.
VMMODULE.evaluate([RUN_OPTS])->PROMISE(VAL)     #Runs the code.
                                                #Must be called after VMMODULE.instantiate()
                                                #RUN_OPTS: timeout, breakOnSigint
VMMODULE.url                                    #
VMMODULE.namespace                              #
VMMODULE.dependencySpecifiers                   #All 'MODULE'_ARR imported by that module

new SourceTextModule(STR[, OPTS])               #SOURCE_TEXT_MODULE, child of VMMODULE.
                                                #For regular JavaScript text files.
                                                #OPTS:
                                                #  - context COBJ: reused by every MODULE.run*(...), i.e. cannot be changed
                                                #  - identifier STR (def: 'vm:module(NUM)'): for debugging
                                                #  - line|columnOffset NUM: for stack trace error message
                                                #  - importModuleDynamically(...): like above, but cannot use USE_MAIN_CONTEXT_DEFAULT_LOADER
                                                #  - initalizeImportMeta(import.meta, VMMODULE):
                                                #     - called during VMMODULE.evaluate()
                                                #     - used to initialize import.meta by modifying it
                                                #  - cachedData BUFFER: like VM.runInContext()
new SyntheticModule('VAR'_ARR, FUNC()[,OPTS])   #SYNTHETIC_MODULE, child of VMMODULE.
                                                #Define modules programmatically instead of through source text files.
                                                #Used for non-JavaScript modules.
                                                #'VAR'_ARR are exported variables.
                                                #FUNC() is called on evaluate()
                                                #  - with SYNTHETIC_MODULE as `this`
                                                #OPTS:
                                                #  - context, identifier: like SOURCE_TEXT_MODULE
SYNTHETIC_MODULE.setExport('VAR', VAL)          #Define exported variable. Should be done inside constructor FUNC()

measureMemory([OPTS])->PROMISE_OBJ              #Returns memory taken by a COBJ
                                                #Prints experimental warning
                                                #OPTS:
                                                #  - context COBJ (def: current one)
                                                #  - mode 'summary' (def) or 'detailed'
                                                #Returns OBJ:
                                                #  - total:
                                                #     - jsMemoryEstimate NUM (in bytes)
                                                #     - jsMemoryRange [MIN_NUM, MAX_NUM]

                                  ┌────────────┐
                                  │   CRYPTO   │
                                  └────────────┘

--openssl-config=FILE
OPENSSL_CONF=FILE ENVVAR                        #
--openssl-shared-config                         #
--openssl-legacy-provider                       #OpenSSL 3.0 legacy

createHash(STR[, OPTS])                         #Returns a HASH, i.e. a IOSTREAM generator: write|read to it to get hashes.
                                                #STR is the algo.
                                                #CRYPTO.getHashes() gives list of supported hashes algos, as STR_ARR:
                                                #includes [EC]DSA, DSS1, MD4|5, RIPEMD, RMD, SHA1|224|256|384|512, Whirlpool
                                                #OPTS:
                                                #  - same as Stream.Transform(OPTS)
                                                #  - outputLength NUM (in bytes)
HASH.copy([OPTS])->HASH2                        #Clone. Keep state. Doe snot work if HASH already closed.
hash('ALGO', STDABUFFER[, 'ENCODING'])  20.12.0*#Non-streaming alternative to createHash(). Faster for small values, but does not stream, i.e. more memory
 ->SBUFFER                              20.12.0*#Def ENCODING: 'hex'

createHmac(STR, STDABUFFER|KEY)                 #Same as createHash() but for a HMAC. STR is hash algo. Second argument is the key.
createCipheriv(STR, STDABUFFER|KEY,             #Same but for a CIPHER (sym. cipher).
 STDABUFFER|null[, OPTS])                       #Key must be KEY|TDBUFFER or STR with encoding "binary".
                                                #Third argument is IV. Can be null.
                                                #CRYPTO.getCiphers() gives list of supported sym. ciphers (including mode of
                                                #operation), as STR_ARR: includes AES, Blowfish, Camellia, CAST, DES, DES3,
                                                #DES-X, IDEA, RC2, RC4, SEED, ChaCha
                                                #OPTS:
                                                #  - any of Stream.Transform()
                                                #  - authTagLength NUM (def: 16): 4-16 (must be even number)
                                                #STDBUFFER can be STDABUFFER
CIPHER.setAutoPadding(BOOL)                     #If false (def: true), disables padding (PKCS padding).
                                                #Use it for personalized padding, i.e. filling with nulls.
CIPHER.getAuthTag()->BUFFER                     #Returns MAC, for sym. ciphers that produce one ("authenticated
                                                #encryption"), i.e. "GCM" only.
CIPHER.setAAD(STDABUFFER)->STDABUFFER2          #Same but for "additional authenticated data" ("GCM" only)
createDecipheriv(...)
DECIPHER.setAutoPadding(BOOL)                   #Same for decryption.
DECIPHER.setAuthTag(STDABUFFER[, 'ENCODING'])   #
DECIPHER.setAAD(BUFFER)                         #

createDiffieHellman(ARGS)                       #Creates a DIFFIEHELLMAN (used for asym. encryption with HL algo).
                                                #ARGS can be:
                                                #  - NUM[, NUM2]: prime length NUM and generator NUM2 (def: 2).
                                                #  - STDBUFFER[, ENCODING][, NUM|STDBUFFER2[, ENCODING2]]: prime STDBUFFER
                                                #    (def ENCODING: "buffer", can also be "binary|base64") and generator
                                                #    NUM|STDBUFFER2 (def: 2)
DIFFIEHELLMAN.getPrime([ENCODING])->SBUFFER     #
DIFFIEHELLMAN.getGenerator([ENCODING])->SBUFFER #
DIFFIEHELLMAN.generateKeys([ENCODING])->SBUFFER #Creates private and public key, and returns public key.
DIFFIEHELLMAN.getPublic|PrivateKey([ENCODING])
 ->SBUFFER                                      #
DIFFIEHELLMAN.setPublic|PrivateKey
 (STDBUFFER, [ENCODING])                        #
DIFFIEHELLMAN.computeSecret(STDBUFFER           #Creates shared secret by using current private key and other part public key
[, ENCODING][, ENCODING2])->SBUFFER             #STDBUFFER (must have used the same prime and generator)
                                                #ENCODING is other part public key encoding, ENCODING2 shared secret returned.
DIFFIEHELLMAN.verifyError                       #Or'd flags showing warning after initialization among:
                                                #  - CRYPTO.DH_CHECK_P_NOT_SAFE_PRIME
                                                #  - CRYPTO.DH_CHECK_NOT_PRIME
                                                #  - CRYPTO.DH_UNABLE_TO_CHECK_GENERATOR
                                                #  - CRYPTO.DH_NOT_SUITABLE_GENERATOR
getDiffieHellman(STR)                           #Returns a DIFFIEHELLMAN but:
                                                #  - without setPublic|PrivateKey()
                                                #  - according to STR "modp14|15|16|17|18", i.e. prime is constant, but it is faster

createECDH(STR)                                 #Returns ECDH, elliptic curve version of Diffie-Hellman.
                                                #Same as DIFFIEHELLMAN but:
                                                #  - last arg FORMAT "[un]compressed|hybrid" (def: "uncompressed") to generateKeys() and getPublicKeys()
                                                #  - no getPrime(), getGenerator(), verifyError, setPublicKey()
                                                #STR is algo, from CRYPTO.getCurves() as STR_ARR: includes Oakley, brainpool,
                                                #c2tnb, prime, secp, sect, wap-wsg-idm-ecid-wtls
ECDH.convertKey(STDBUFFER, 'ALGO'[, ENCODING]
 [, ENCODING2], FORMAT)->SBUFFER                #Converts public key STDBUFFER to FORMAT

public|privateEncrypt|Decrypt                   #Encrypts/decrypts asym. (RSA) TDBUFFER, with private|public key STR|KEY|OBJ:
 (STDABUFFER|KEY|OBJ, TDBUFFER)                 #  - key, format, type, passphrase: like createPrivate|PublicKey()
                                                #  - padding: CRYPTO.constants.RSA_NO|PKCS1[_OAEP]_PADDING
                                                #  - oaepHash STR (def: 'sha1'): algo for OAEP padding
                                                #  - oaepLabel STDABUFFER: label for OAEP padding

generateKeyPair[Sync]('TYPE', OPTS              #Create asym key pair, where SBUFFER is publicKey and SBUFFER privateKey
 [, FUNC(ERROR, SBUFFER, SBUFFER2)])            #'TYPE' is 'rsa', 'dsa', 'ec', 'ed25519', 'ed448', 'x25519', 'x448' or 'dh'
 [->{ publicKey|privateKey }]                   #OPTS:
                                                #  - publicKeyEncoding OBJ (def: produces a KEY):
                                                #     - type 'pkcs1' (RSA only) or 'spki' (prefered)
                                                #     - format 'pem' or 'der'
                                                #  - privateKeyEncoding OBJ (def: produces a KEY):
                                                #     - type 'pkcs1' (RSA only), 'sec1' (EC only) or 'pkcs8' (prefered)
                                                #     - format 'pem' or 'der'
                                                #     - cipher 'ALGO', passphrase STR: encrypt using PKCS#5 2.0
                                                #  (RSA, DSA)
                                                #  - modulusLength NUM: key size (in bits)
                                                #  (RSA)
                                                #  - publicExponent NUM (def: 0x10001): public exponent
                                                #  (DSA)
                                                #  - divisorLength NUM: q size (in bits)
                                                #  (EC)
                                                #  - namedCurve STR: curve name
                                                #  (RS-PSS)
                                                #  - [mgf1]hashAlgoritm STR (RSA-PSS)
                                                #  - saltLength STR (RSA-PSS)

createPrivate|PublicKey(OPTS|STDABUFFER)->KEY   #Create asym key pair. OPTS:
                                                #  - key STDABUFFER or (for 'Public') KEY
                                                #  - format 'pem' (def), 'der' or 'jwk': of key
                                                #  - type 'pkcs1', 'spki' or (privateKey only) 'sec1': ignored if format 'pem'
                                                #  - passphrase STDABUFFER (privateKey only)
createSecretKey(STDABUFFER)->KEY                #Create sym key.

diffieHellman(OPTS)->BUFFER                     #Compute Diffie-Hellman secret using OPTS:
                                                #  - privateKey KEY
                                                #  - publicKey KEY
                                                #KEY must be of same type 'dh|ec|x448|x25519'

KEY.type                                        #'public|private' (if async) or 'secret' (if sync)
KEY.asymmetricKeyType                           #'rsa', 'dsa', 'ec', (if sym key) undefined,
                                                #'ed25519', 'ed448', 'x25519', 'x448', 'rsa-pss'
                                                #'dh'
KEY.asymmetricKeyDetails()->OBJ                 #OBJ:
                                                # - modulusLength|publicExponent|divisorLength|namedCurve|*hashAlgorithm|saltLength:
                                                #   like generateKeyPair()
KEY.symmetricSize                               #Byte length NUM. undefined if async
KEY.export([OPTS])->SBUFFER                     #OPTS (if async):
                                                #  - type, format, passphrase: like createPrivate|PublicKey()
                                                #  - cipher STR
KEY.equals(KEY2)->BOOL                          #

createSign(STR)                                 #Same as createDecipheriv() but for signing algo STR.
                                                #List can be found with openssl list-public-key-algorithms.
                                                #Includes RSA, DH, DSA, HMAC and CMAC.
                                                #Unless createCipheriv(), is only a OSTREAM. To read from it, use
                                                #SIGN.sign(STDABUFFER|KEY|OPTS[, ENCODING]), where STDABUFFER|OPTS|KEY is the private key.
                                                #OPTS:
                                                #  - key, format, type, passphrase: like createPrivateKey()
                                                #  - padding CRYPTO.constants.RSA_PKCS1_[PSS_]PADDING
                                                #  - saltLength NUM, can be:
                                                #     - CRYPTO.constants.RSA_PSS_SALTEN_DIGEST: digest size
                                                #     - CRYPTO.constants.RSA_PSS_SALTEN_MAX_SIGN
                                                #  - dsaEncoding 'der' (def) or 'ieee-p1363'
createVerify(STR)                               #Same for verifying algo STR.
                                                #Like createSign(), is only a OSTREAM.
VERIFY.verify                                   #Read from createVerify()
 (STDABUFFER|KEY|OBJ, STDABUFFER2[, ENCODING])  #STDABUFFFER is a certificate or a RSA|DSA public key in PEM format or a private key
                                                #OBJ:
                                                #  - padding
                                                #  - saltLength
                                                #  - dsaEncoding
                                                #STDABUFFER2 is the signature.
sign(['ALGO, ']STDBUFFER2, SBUFFER|KEY|OPTS
 [, FUNC(ERROR, BUFFER)])->BUFFER
verify(['ALGO, ']STDBUFFER2, SBUFFER|KEY|OPTS,
 STDBUFFER[, FUNC(ERROR, BOOL)])->BUFFER        #Shortcut for createSign|Verify()

Certificate()                                   #Returns CERTIFICATE, used for SPKAC, used to send certificates client-side to
                                                #the server with the HTML5 <keygen>.
CERTIFICATE.verifySpkac(STDBUFFER)->BOOL
CERTIFICATE.exportChallenge|PublicKey
(STDABUFFER[, ENCODING])->BUFFER                #

pbkdf2[Sync](STDABUFFER, STDABUFFER2, NUM, NUM2,#Generate a random BUFFER using PBKDF2 with HMAC-SHA1, with first arg being
DIGEST[, FUNC(ERROR, BUFFER)])[->BUFFER]        #the input, second the salt (should be min. 64 bits), NUM the number of
                                                #iterations (should be min. 1000) and NUM2 the final string length.

scrypt[Sync](STDABUFFER, STDABUFFER2, NUM       #Generate a derived key BUFFER using Scrypt.
 [, OPTS][, FUNC(ERROR, BUFFER)])[->BUFFER]     #First arg is the password, second is the salt (should be 16 bytes long), NUM is BUFFER length.
                                                #OPTS:
                                                #  - cost|N NUM (def: 16384): CPU/memory cost. Must be power of 2
                                                #  - blockSize|r NUM (def: 8): block size
                                                #  - parallelization|p NUM (def: 1): parallelization
                                                #  - maxmem NUM (def: 32MB): memory bound.
                                                #    Must be > 128*N*r

randomBytes(NUM[, FUNC(ERROR, BUFFER)])         #Generates random BUFFER of length NUM
                                                #Is cryptographically secure (e.g. from /dev/random)
                                                #If no FUNC, synchronous (returns BUFFER)
randomFill[Sync](TDBUFFER[, NUM[, NUM2]]        #Like randomBytes() but by filling in a TDBUFFER instead, from offset NUM
[, FUNC(ERROR, TDBUFFER)])[->BUFFER]            #(def: 0) with length NUM2 (def: TDBUFFER.lBUFFER.length).
getRandomValues(TDABUFFER)->TDABUFFER           #Same. Maximum 65536 bytes.
randomInt([UINT, ]UINT2[, FUNC(ERROR, UINT3)])  #Generates random UINT3 from UINT (included, def: 0) to UINT2 (excluded)
 ->UINT3                                        #Is cryptographically secure (e.g. from /dev/random)
randomUUID([OPTS])->STR                         #Returns UUIDv4. Cryptographically secure (e.g. from /dev/random)
                                                #OPTS:
                                                #  - disableEntropyCache BOOL: if false (def), cache 128 UUIDs in advance

generatePrime[Sync](NUM[, OPTS],                #Creates a random prime number
 FUNC(ERROR, ARRBUFFER|BIGINT))                 #OPTS:
                                                #  - bigint BOOL (def: false): return as BIGINT
                                                #  - safe BOOL (def: false): return a safe prime, i.e. (prime - 1) / 2 is also prime
                                                #  - add|rem TDABUFFER|BIGINT: enforce prime % OPTS.add = OPTS.rem (for Diffie-Hellman)
checkPrime[Sync](TDABUFFER|BIGINT               #Gives an estimation of whether number is prime.
 [, OPTS], FUNC(ERROR, BOOL))                   #OPTS:
                                                #  - checks NUM:
                                                #     - higher takes more time (O(n))
                                                #     - probability of false positive is 1/(4**NUM)
                                                #     - def: automatically guessed to give false positive probability of 1/(2e64)

--secure-heap=NUM                               #Randomize the heap used by several CRYPTO.* methods
                                                #Must be power of 2
                                                #Noop on Windows
--secure-heap-min=NUM                           #Minimum allocation when using --secure-heap
                                                #Must be power of 2
                                                #Def: 64
secureHeapUsed()->OBJ                           #OBJ:
                                                #  - total NUM: passed to --secure-heap
                                                #  - min NUM: passed to --secure-heap-min
                                                #  - used NUM: how many bytes used
                                                #  - utilization NUM: used/total

getFips()->BOOL                                 #True if Node has been:
                                                #   - built to be FIPS-compliant (by def, is not)
                                                #   - run with node --enable-fips or (same but cannot modify CRYPTO.fips) --force-fips
setFips(BOOL)                                   #

timingSafeEqual(STDABUFFER, STDABUFFER2)->BOOL  #Like STDABUFFER.equals(STDABUFFER2), but protected against timing attacks

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

CONSOLE.*                                       #Like DOM except:
                                                #  - uses UTIL.inspect|format()
                                                #     - with OPTS.colors true, unless inside a WORKER
                                                #  - console.dir(VAL, ...) -> console.log(inspect(VAL, ...))
                                                #  - console.assert() can use format strings

new Console(OPTS)                               #Returns CONSOLE, same as console but with different stdout|stderr
new Console(OSTREAM[, OSTREAM2][, BOOL])        #OPTS:
                                                #  - stdout OSTREAM, stdout OSTREAM2
                                                #  - ignoreErrors BOOL (def: true): ignore errors on OSTREAM[2]
                                                #  - colorMode BOOL or 'auto' (def: OSTREAM.isTTY && OSTREAM.hasColors())
                                                #  - inspectOptions OPTS: passed to UTIL.inspect()
                                                #  - groupIndentation NUM (def: 2): when using console.group*()

STDERR ==>                                      #Used by:
                                                #  - CONSOLE.warn|error() (not other CONSOLE.*)
                                                #  - unhandled exception or promise rejection
                                                #  - process.emitWarning()

DIAGNOSTICS_CHANNEL.subscribe
 ('console.LEVEL', FUNC(ARGS_ARR))      22.14.0*#

                                  ┌────────────────┐
                                  │   PERF_HOOKS   │
                                  └────────────────┘

performance                                     #Like DOM (see doc), except:
PERFORMANCE                                     #  - entryTypes:
PERFENTRY.*                                     #     - 'mark|measure|resource': like DOM
PERFOBSERVER                                    #     - 'node': instead of DOM 'navigation'
                                                #     - 'http[2]', 'dns', 'net': network requests
                                                #     - 'gc'
                                                #     - 'function'
                                                #  - PERF_RESOURCE_TIMING misses:
                                                #     - nextHopProtocol
                                                #  - no PerformanceServerTiming
                                                #  - PERFOBSERVER is an ASYNCRESOURCE
                                                #Like DOM has:
                                                #  - PERFORMANCE.toJSON()
                                                #  - PERFORMANCE.clearMarks|clearMeasures|clearResourceTimings|getEntries*()
                                                #  - PERFOBSERVER.takeRecords()
                                                #  - PerfObserver.supportedEntryTypes
                                         18.8.0*#  - PERFORMANCE.setResourceTimingBufferSize() (def: 250) and 'resourcetimingbufferfull' event
WORKER.performance                              #Same but inside a WORKER
                                                #Only has eventLoopUtilization()

performance                                     #Exposed as global
PerformanceEntry|Mark|Measure
 Observer[EntryList]|ResourceTiming      19.0.0*#Exposed as globals

DOMTIMESTAMP                                    #Still milliseconds unit, but precision (on an average machine) is:
                                                #  - if DOMGLOBALTIME: 1µs
                                                #  - otherwise: 100ns on Windows, 1ns on Unix
PERFORMANCE.timeOrigin                          #When Node starting running, right after processs was initialized.

PERFORMANCE.markResourceTiming                  #Creates a PERF_RESOURCE_TIMING with:
 (PERF_RESOURCE_TIMING, 'URL', STR, GLOBAL,     #  - name 'URL'
 STR2[, OBJ[, STATUS_NUM[, 'MIME']]])           #  - initiatorType STR
                                         22.2.0*#  - encodedBodySize NUM: from OBJ.encodedBodySize
                                         22.2.0*#  - decodedBodySize NUM: from OBJ.decodedBodySize
                                         22.2.0*#  - contentType 'MIME': from OBJ.contentType
                                         22.2.0*#  - responseStatus NUM
                                         22.2.0*#  - deliveryType 'MIME'
                                                #STR2 is cache mode '' or 'local'

PERFORMANCE.nodeTiming                          #PERFNODETIMING, PERFENTRY for Node.js process load
PERFNODETIMING.entryType                        #'node'
PERFNODETIMING.name                             #'node'

TIMES ==>                                       #Following are DOMLOCALTIME, in order
PERFNODETIMING.nodeStart                        #Node process started
PERFNODETIMING.v8Start                          #v8 process initialized
PERFNODETIMING.environment                      #Environment initialized. Always 0. Previous events are negative.
PERFNODETIMING.bootstrapComplete                #End of all require()
PERFNODETIMING.loopStart                        #Start of event loop
PERFNODETIMING.loopExit                         #End of event loop. 0 unless inside 'exit' event handler
PERFNODETIMING.idleTime                         #How long event loop was idle

PERFNODETIMING.uvMetricsInfo            20.18.0*#UV_METRICS_INFO
                                        20.18.0*#Should be retrieved after waiting for setImmediate(), to let queued events be processed first
UV_METRICS_INFO.loopCount               20.18.0*#NUM of event loops
UV_METRICS_INFO.events                  20.18.0*#NUM of event loops with an event
UV_METRICS_INFO.eventsWaiting           20.18.0*#NUM of event loops with an event that had to be queued (not processed right away)

PERFHTTPTIMING                                  #PERFENTRY for HTTP/1.1 requests
PERFHTTPTIMING.entryType                        #'http'
PERFHTTPTIMING.name                             #'HttpClient' or 'HttpRequest'
PERFHTTPTIMING.detail.req                       #REQ: method|url|headers
PERFHTTPTIMING.detail.res                       #RES: statusCode|statusMessage|headers

PERFHTTP2TIMING                                 #PERFENTRY for HTTP/2 requests
                                                #Not fully documented yet
PERFHTTP2TIMING.entryType                       #'http2'
PERFHTTPTIMING.name                             #'Http2Stream' or 'Http2Session'

PERFNETTIMING                                   #PERFENTRY for TCP requests
PERFNETTIMING.entryType                         #'net'
PERFNETTIMING.name                              #'connect'
PERFNETTIMING.detail.host                       #
PERFNETTIMING.detail.port                       #

PERFDNSTIMING                                   #PERFENTRY for DNS requests
PERFDNSTIMING.entryType                         #'dns'
PERFDNSTIMING.name                              #'lookup', 'lookupService' or 'queryxxx'
PERFDNSTIMING.detail                            #OBJ:
                                                #  (lookup)
                                                #  - hostname
                                                #  - family
                                                #  - hints
                                                #  - verbatim
                                                #  - addresses
                                                #  (lookupService)
                                                #  - hostname
                                                #  - host
                                                #  - port
                                                #  - service
                                                #  (queryxxx)
                                                #  - host
                                                #  - ttl
                                                #  - service

PERFGCTIMING                                    #PERFENTRY for garbage collector
PERFGCTIMING.entryType                          #'gc'
PERFGCTIMING.name                               #'gc'
PERFGCTIMING.detail.kind                        #constants.NODE_PERFORMANCE_GC_MINOR|MAJOR|INCREMENTAL|WEAKCB (1|2|4|8)
PERFGCTIMING.detail.flags                       #constants.NODE_PERFORMANCE_GC_FLAGS_NO|CONSTRUCT_RETAINED|FORCED|
                                                #SYNCHRONOUS_PHANTOM_PROCESSING|ALL_AVAILABLE_GARBAGE|ALL_EXTERNAL_MEMORY|
                                                #SCHEDULE_IDLE (0|2|4|8|16|32|64)

PERFORMANCE.timerify(FUNC[, OPTS])->FUNC2       #Make FUNC(ARG...) create a PERFFUNC
                                                #Prepend 'timerified ' to FUNC2.name
                                                #Await return value if it is a PROMISE
                                                #OPTS:
                                                #  - histogram RECORDABLE_HISTOGRAM: add values to it
PERFFUNC                                        #PERFENTRY to measure FUNCs
PERFFUNC.entryType                              #'function'
PERFFUNC.name                                   #FUNC.name (without 'timerified ')
PERFFUNC.duration                               #How long FUNC() took
PERFFUNC.detail                                 #'ARG'_ARR

PERFORMANCE.eventLoopUtilization                #Measure event loops:
 ([OBJ2][, OBJ3])->OBJ                          #  - from OBJ2 (def: process start)
                                                #  - until OBJ3 (def: now)
                                                #  - where OBJ2|OBJ3 are previous eventLoopUtilization() return values
                                                #OBJ:
                                                #  - active DOMDURATION: event loop active
                                                #  - idle DOMDURATION: inverse
                                                #  - utilization: active / (active + idle)

monitorEventLoopDelay([OPTS])->HISTOGRAM        #Event loop benchmarking, i.e. how long each microtask takes (in ns).
                                                #OPTS:
                                                #  - resolution NUM (in ms) (def: 10) (min: 1)
HISTOGRAM.enable|disable()->BOOL                #Start|stop. Returns false is already started|stopped
HISTOGRAM.reset()                               #
HISTOGRAM.count                                 #Number of samples
HISTOGRAM.min|max
HISTOGRAM.mean|stddev                           #Duration NUM (in ns)
HISTOGRAM.percentiles                           #Same as a MAP where key is percentile NUM (0-100) and value is duration NUM (in ns)
HISTOGRAM.percentile(NUM)->NUM                  #
HISTOGRAM.exceeds                               #How many microtasks took more than 1 hour
HISTOGRAM.count|min|max|percentiles|
 percentile|exceedsBigInt                       #

createHistogram([OPTS])                         #OPTS:
 ->RECORDABLE_HISTOGRAM                         #  - lowest|highest NUM|BIGINT (def: 1|MAX_SAFE_INTEGER): min|max value
                                                #  - figures NUM (def: 3, from 1 to 5): number of significant digits
RECORDABLE_HISTOGRAM                            #Like HISTOGRAM, with additional methods to manually add values
RECORDABLE_HISTOGRAM.record(NUM|BIGINT)         #Add value
RECORDABLE_HISTOGRAM.recordDelta()              #Like record() but using the amount of ns spent since last record()
RECORDABLE_HISTOGRAM.add(RECORDABLE_HISTOGRAM2) #

                                  ┌──────────┐
                                  │   I18N   │
                                  └──────────┘

ICU DATA                                        #I18n dataset used by:
                                                #  - JavaScript-aware functions: STR.normalize|toLowerCase|toUpperCase(),
                                                #    STR|NUM|DATE.toLocale*(), STR.localeCompare(), Intl, URL,
                                                #    TEXTENCODER|TEXTDECODER, \p{} in REGEXP
                                                #How many languages are included depends on:
                                                #  - compile-time flag --with-intl=STR:
                                                #     - 'full' (def)
                                                #     - 'small-icu':
                                                #        - supports: STR.normalize|toLowerCase|toUpperCase(), STR.toLocale*(),
                                                #          STR.localeCompare(), URL, BUFFER.transcode()
                                                #        - not supported: Intl, NUM|DATE.toLocale*(), TEXTENCODER|TEXTDECODER, \p{} in REGEXP
                                                #     - 'system-icu':
                                                #        - same as 'small-icu', except link to ICU dataset dynamically instead
                                                #          of statically
                                                #        - i.e. depends whether OS includes ICU databaset, which most Linux do
                                                #     - 'none': no i18n, navigator.language[s], and STR.normalize(), Intl and BUFFER.transcode() fail
                                                #  - ENVVAR NODE_ICU_DATA=FILE
                                                #  - node --icu-data-dir=FILE
                                                #Can use package full-icu to download ICU dataset manually.

process.versions.icu                            #'VERSION'|undefined

navigator.language[s]                    21.2.0*#See DOM
                                         21.2.0*#Based on OS settings
                                         21.2.0*#'en-US' if fallback or no ICU

ENVVAR TZ                                       #Timezone

ENCODING                                        #One of:
                                                #  - utf[-]8 (def)
                                                #     - U+FFFD on invalid sequences
                                                #  - utf[-]16le|ucs[-]2
                                                #  - latin1|binary: byte 0x00-0x1f, 0x7f-0x9f -> '\xXX', others -> Latin1 byte
                                                #  - ascii: byte 0x00-0x1f, 0x7f -> '\xXX', 0x80-0xff -> 0x00-0x7f, others -> ASCII
                                                #  - hex
                                                #  - base64
                                                #  - base64url
                                                #Can be any case
                                                #For TEXTDECODER|TEXTENCODER, it is different (see DOM doc), and depends on ICU:
                                                #  - always: 'utf-8' (def), 'utf-16le'
                                                #  - if 'small|system-icu': 'utf-16be'
                                                #  - if 'full' ICU: many more (see online doc)

TextDecoder|TextEncoder                         #See DOM doc. UINT8ARR can be BUFFER too
TextEncoderStream                               #See DOM doc
TextDecoderStream                               #Global objects
TENCODING                                       #ENCODING from TextDecoder()

                                  ┌───────────────┐
                                  │   UTIL MAIN   │
                                  └───────────────┘

promisify(FUNC(..., FUNC2(ERROR, VAL)))->FUNC   #Transform FUNC so FUNC(...)->>ERROR|VAL
                                                #If calling FUNC(..., FUNC2), FUNC2 still gets called, and PROMISE do not get resolved|rejected
                                                #If FUNC throws, PROMISE gets rejected.
                                                #For this to work:
                                                #  - FUNC2 does not have to be last argument in FUNC declaration
                                                #  - but caller must specify all arguments up to FUNC2
                                                #If FUNC[util.promisify.custom] FUNC3 is defined, returns FUNC3 instead.
                                                #  - this is defined for setTimeout|setImmediate(), i.e. can be used even
                                                #    though callback is first parameter
                                                #  - util.promisify.custom is also Symbol.for('nodejs.util.promisify.custom')
callbackify(FUNC()->PROMISE)
 ->FUNC(..., FUNC2(ERROR, VAL))                 #Inverse. FUNC will not return PROMISE anymore

isDeepStrictEqual(VAL, VAL2)                    #Does a deep equality
                                                #Does not compare inherited nor non-enumerable properties
                                                #Handles -0, NaN, DATE, REGEXP, MAP|SET, ERROR
                                                #Including REGEXP.lastIndex

inherits(TYPE_FUNC, TYPEPARENT_FUNC)            #Makes TYPE inherits from TYPEPARENT, i.e. executes:
                                                #  TYPE.prototype = Object.create(TYPEPARENT.prototype)
                                                #  TYPE.prototype.constructor = TYPE
                                                #Also creates a TYPE.super_ that points to TYPEPARENT
                                                #Since it does not use OBJ in Object.create(), needs to create own static
                                                #members with TYPE.prototype.VAR = VAL

new MIMEType('MIME')                    18.13.0*#E.g. 'text/javascript[+...];key=value'.
                                        18.13.0*#Throw if invalid 'MIME'
MIMETYPE.toString|toJSON()->STR         18.13.0*#E.g. 'text/javascript[+...];key=value'
MIMETYPE.essence                        18.13.0*#E.g. 'text/javascript[+...]'
MIMETYPE.type                           18.13.0*#E.g. 'text'
MIMETYPE.subtype                        18.13.0*#E.g. 'javascript[+...]'
MIMETYPE.params                         18.13.0*#MIMEPARAMS, child of MAP
new MIMEParams()                        18.13.0*#

getCallSites(NUM[, OPTS])->FRAME_ARR     22.9.0*#Stack trace
                                         22.9.0*#NUM (min 1, max 200) is number of FRAMEs
                                       <22.12.0*#Previously named getCallSite()
OPTS.sourceMap                          22.13.0*#BOOL (def: depends on --enable-source-maps)
FRAME.scriptName                         22.9.0*#'PATH', 'node:MODULE', '' (e.g. for eval()) or special STR (e.g. 'REPL*')
FRAME.scriptId                           23.7.0*#STR. Unique file identifier
FRAME.functionName                       22.9.0*#'FUNC_NAME' or '' (e.g. REPL)
FRAME.lineNumber                         22.9.0*#NUM (1-based)
FRAME.columnNumber                       22.9.0*#NUM (1-based)
                                        <22.9.0*#Previously named column

                                  ┌─────────────────┐
                                  │   UTIL FORMAT   │
                                  └─────────────────┘

styleText('CSTYLE'[_ARR], STR[, OPTS])  20.12.0*#Apply CSTYLE
 ->STR                                 <20.13.0*#Cannot be ARR
OPTS.validateStream                      22.9.0*#BOOL. If true (def), noop if !STREAM.isTTY || !STREAM.hasColors()
OPTS.stream                              22.9.0*#OSTREAM (def: process.stdout) used by OPTS.validateStream

stripVTControlCharacters(STR)->STR              #Remove ANSI sequences (like `strip-ansi`), mostly for colors and cursors

inspect(VAL[, OPTS])                            #Serialize VAL as STR. Used by REPL.
                                                #OPTS:
                                                #  - showHidden BOOL: if false (def), doesn't show non-enumerable properties,
                                                #    except SYMs and user-defined prototype properties
                                                #  - depth NUM (def: 2): max recursion (null|Infinity for infinite)
                                                #  - maxArrayLength NUM (def: 100) (null for infinite)
                                                #  - maxStringLength NUM (def: 1e4) (Infinity|null for infinite): truncate any STR with ellipsis
                                                #  - breakLength NUM (def: 60) (can be Infinity): maxlength to print OBJ in multiline
                                                #  - compact BOOL|NUM:
                                                #     - if false:
                                                #        - always print OBJ multiline
                                                #        - break strings that are more than breakLength long
                                                #     - if NUM (def: 3): allows fitting NUM properties in one line (if within breakLength)
                                                #  - colors BOOL (def: false)
                                                #  - customInspect BOOL (def: true):
                                                #     - call VAL[SYM](UINT[, OBJ][, FUNC])->STR if it exists
                                                #     - SYM is util.inspect.custom or Symbol.for('nodejs.util.inspect.custom')
                                                #     - FUNC is original inspect()
                                                #  - showProxy BOOL: if true (def: false), dereference PROXY (to their target)
                                                #  - sorted BOOL (def: false) or FUNC('KEY', 'KEY2')->-1|0|1
                                                #  - getters BOOL (def: false) or 'get|set' (only getters with|without a set()): show getters values
                                                #  - numericSeparator BOOL (def: false): separate thousands on NUM|BIGINTs with "_"
                                                #Circular references are printed correctly.
                                                #  - a pointer to the reference is shown
                                                #Can change inspect.defaultOptions
                                                #require("buffer").INSPECT_MAX_BYTES: number of bytes printed for BUFFER (def: 50)
                                                #Max output 128MB
inspect.colors.CSTYLE                           #[NUM, NUM2] with ANSI sequences start|end:
                                                #  - reset, bold, underline, inverse, dim, italic, hidden, strikethrough, overlined, blink, doubleunderline, framed
                                                #  - [bg]black|red|green|yellow|blue|magenta|cyan|white|gray[Bright]
inspect.styles.CATEGORY                         #'CSTYLE' to apply with inspect()
                                                #E.g. CATEGORY 'bigint' -> 'yellow'

format(STR[, VAL...])                           #Printf-like FUNC, STR can contain:
                                                #  - "%s": STR
                                                #  - "%d", "%i": INT|BIGINT
                                                #  - "%f": FLOAT
                                                #  - "%j": JSON. Returns '[Circular]' (on the whole return value) if any circular references. Handles toJSON()
                                                #  - "%O": OBJ. Uses UTIL.inspect() with default options
                                                #  - "%o": OBJ. Uses UTIL.inspect() with options: showHidden true, depth 4, showProxy true
                                                #  - "%%": escape
formatWithOptions(OBJ, ...)                     #Like format(...) except if can specify inspect() options OBJ

debug[log](STR)->DEBUG_FUNC                     #
DEBUG_FUNC(...)                                 #Like console.error(...) except:
                                                #  - prepends `${STR} ${process.pid}: `
                                                #  - noop unless DEBUG_FUNC.enabled true
DEBUG_FUNC.enabled                              #BOOL
                                                #Def: if ENVVAR NODE_DEBUG "STR2,..." (can include *) includes STR

                                  ┌───────────────┐
                                  │   UTIL ARGS   │
                                  └───────────────┘

parseArgs([OPTS])->OBJ                          #Parse CLI flags
                                                #OPTS:
                                                #  - args STR_ARR (def: process.argv.slice(2))
                                                #  - options OBJ:
                                                #     - known CLI flags
                                                #     - key is 'FLAG'
                                                #        - long name
                                                #        - must match exactly, i.e. can be either dasherized|camelized and does not convert
                                                #        - --'FLAG.FLAG2' -> 'FLAG.FLAG2' (not OBJ)
                                                #        - --NUM -> 'NUM' (not ARR index)
                                                #     - value OBJ2:
                                                #        - short 'CHAR':
                                                #           - short name
                                                #           - unlike long name, value:
                                                #              - does not need to be separated with space
                                                #              - cannot be separated with =
                                                #           - cannot be grouped (e.g. -a -b -> -ab)
                                                #        - type STR (required):
                                                #           - 'boolean'
                                                #              - throw if it has an argument
                                                #                 - including --FLAG=, --FLAG=true|false, --no-FLAG
                                                #           - 'string'
                                                #              - always interpreted as STR:
                                                #                 - --FLAG= -> ''
                                                #                 - NUM -> 'NUM'
                                                #                 - true|false -> 'true|false'
                                                #        - multiple BOOL: when set multiple times:
                                                #           - false (def): only keep last
                                                #           - true: set as ARR
                                                #        - default STR|BOOL[_ARR]
                                                #  - strict BOOL (def: true): throw if:
                                                #     - unknown CLI flag
                                                #     - wrong type
                                                #  - allowPositionals BOOL (def: !OPTS.strict)
                                                #     - when false, throw if positional argument
                                                #     - handles '--' to signify start of positional flags
                                        20.16.0*#  - allowNegative BOOL (def: false): allow --no-BOOL
                                         18.7.0*#  - tokens BOOL (def: false): returns OBJ.tokens
                                                #Returns OBJ:
                                                #  - values.FLAG BOOL|STR: non-positional flags
                                                #  - positionals STR_ARR
                                         18.7.0*#  - tokens OBJ_ARR: tokenized flags
                                         18.7.0*#     - kind 'option' (non-positional), 'positional' or 'option-terminator' (--)
                                         18.7.0*#     - index NUM
                                         18.7.0*#     (positional)
                                         18.7.0*#     - value STR
                                         18.7.0*#     (non-positional)
                                         18.7.0*#     - name STR: long name
                                         18.7.0*#     - rawName STR: short|long name, as passed by user
                                         18.7.0*#     - value STR: undefined for BOOL options
                                         18.7.0*#     - inlineValue BOOL|undefined: whether value was passed explicitely
                                                #Does not allow:
                                                #  - command-specific flags
                                                #  - --help
                                                #  - --version
                                                #  - optional flag argument
                                                #  - multiple flag arguments
                                                #  - normalization, including default values
                                                #  - complex validation, including enums
                                                #  - completion script

                                  ┌────────────────┐
                                  │   UTIL/TYPES   │
                                  └────────────────┘

types.isRegExp(VAL)->BOOL                       #True if REGEXP
types.isDate(VAL)->BOOL                         #True if DATE
types.isPromise(VAL)->BOOL                      #True if PROMISE (not PROMISABLE)
types.is[Weak]Map|Set(VAL)->BOOL                #True if [WEAK]MAP|SET
types.isNativeError(VAL)->BOOL                  #True if instanceof ERROR
types.isProxy(VAL)->BOOL                        #True if PROXY

types.isArgumentsObject(VAL)->BOOL              #True if arguments

types.isAsyncFunction(VAL)->BOOL                #True if async FUNC

types.isGeneratorFunction(VAL)->BOOL            #True if FUNC *
types.isGeneratorObject(VAL)->BOOL              #True if return value of FUNC * (not just any ITERABLETOR)
types.isMap|SetIterator(VAL)->BOOL              #True if MAP|SET.keys|values|entries|Symbol.iterator()

types.is[Shared|Any]ArrayBuffer[View]|DataView|
 TypedArray|[Big]Int|Uint|Float*Array(VAL)
 ->BOOL                                         #True if [SHARED]ARRBUFFER|DATAVIEW|TYPED_ARR|UINT|INT|FLOAT*ARRAY

types.isBoolean|Number|StringObject(VAL)
 ->BOOL                                         #True if new Boolean|Number|String(VAL) (not Boolean|Number|String(VAL))
types.isSymbolObject(VAL)->BOOL                 #True if Object(Symbol(VAL)) (not Symbol(VAL))
types.isBoxedPrimitive(VAL)->BOOL               #True if new Boolean|Number|String(VAL) or Object(Symbol|BigInt(VAL))

types.isModuleNamespaceObject(VAL)->BOOL        #True if OBJ from import * as OBJ
types.isExternal(VAL)->BOOL                     #True if external C/C++ value

                                  ┌────────────┐
                                  │   REPORT   │
                                  └────────────┘

process.report.getReport([ERROR])->OBJ          #Get debugging information.
                                                #Def ERROR is new Error()
                                                #Returns OBJ:
                                                #  - header:
                                                #     - reportVersion 1
                                                #     - trigger:
                                                #        - 'GetReport': manual call to getReport()
                                                #        - 'OnUncaughtException': --report-uncaught-exception
                                                #        - 'OnFatalError': --report-on-fatalerror
                                                #        - 'OnUserSignal': --report-on-signal
                                                #     - event STR:
                                                #        - 'JavaScript API': manual call to getReport()
                                                #        - 'exception': --report-uncaught-exception
                                                #        - 'ERROR_MESSAGE': --report-on-fatalerror
                                                #        - 'SIGNAL': --report-on-signal
                                                #     - filename 'FILENAME'|null: where file was dumped
                                                #     - dumpEventTime 'DATE'
                                                #     - dumpEventTimeStamp DATE_NUM
                                                #     - commandLine STR_ARR: process.argv
                                                #     - processId NUM
                                                #     - nodejsVersion 'vVERSION'
                                                #     - glibcVersionRuntime|Compiler 'VERSION'
                                                #     - componentVersions: process.versions
                                                #     - arch: process.arch
                                                #     - platform: process.platform
                                                #     - release: process.release
                                                #     - host: os.hostname()
                                                #     - cpus: os.cpus()
                                                #     - networkInterfaces: os.networkInterfaces() (except as an OBJ_ARR)
                                                #     - cwd process.cwd()
                                                #     - osName STR (e.g. 'Linux')
                                                #     - osRelease STR (e.g. '4.18.0-16-generic')
                                                #     - osVersion 'VERSION' (e.g. '#17-Ubuntu SMP Fri Feb 8 00:06:57 UTC 2019')
                                                #     - osMachine STR (e.g. 'x86_64')
                                                #     - machine STR: osVersion (not Windows) + hostname
                                                #     - wordSize 32|64
                                                #  - javascriptStack: message STR, stack STR_ARR
                                                #  - nativeStack STR_ARR: same but lower-level
                                                #  - javascriptHeap:
                                                #     - totalMemory NUM
                                                #     - executableMemory NUM
                                                #     - totalCommittedMemory NUM
                                                #     - availableMemory NUM
                                                #     - totalGlobalHandlesMemory NUM
                                                #     - usedGlobalHandlesMemory NUM
                                                #     - usedMemory NUM
                                                #     - memoryLimit NUM: slightly above availableMemory
                                                #     - mallocedMemory NUM
                                                #     - externalMemory NUM
                                                #     - peakMallocedMemory NUM
                                                #     - nativeContextCount NUM
                                                #     - detachedContextCount NUM
                                                #     - doesZapGarbage NUM
                                                #     - heapSpaces.read_only|new|old|code|map|[new_]large_object_space:
                                                #        - memorySize NUM
                                                #        - committedMemory NUM
                                                #        - used NUM
                                                #        - available NUM
                                                #        - capacity NUM: used + available
                                                #  - libuv OBJ_ARR: pending macrotasks
                                                #     - type STR
                                                #     - is_active '0|1'
                                                #     - is_referenced '0|1'
                                                #     - address 'NUM'
                                                #     - loopIdleTimeSeconds NUM
                                                #     - any type-specific properties
                                                #  - environmentVariables OBJ: process.env
                                                #  - [uvthreads]resourceUsage:
                                                #     - user|kernelCpuSeconds 'NUM'
                                                #     - cpuConsumptionPercent 'NUM'
                                        18.13.0*#     - kernel|userCpuConsumptionPercent 'NUM'
                                                #     - fsActivity.reads|writes 'NUM'
                                                #     (not uvthreads)
                                        18.13.0*#     - rss NUM
                                                #     - maxRss 'INT'
                                        18.13.0*#     - free|total|available|constrained_memory 'NUM'
                                                #     - pageFaults.IO[Not]Required 'INT'
                                                #  - userLimits.TYPE.soft|hard 'NUM|unlimited|'
                                                #     - TYPE can be [core_]file_size_blocks|data_seg_size_bytes|max_locked_memory_bytes|
                                                #       max_memory_size_bytes|open_files|stack_size_bytes|cpu_time_seconds|
                                                #       max_user_processes|virtual_memory_bytes
                                                #  - sharedObjects 'PATH'_ARR: shared libraries
process.report.writeReport                      #Call process.report.getReport() and dump the file
 (['FILENAME'][, ERROR])->'FILENAME'            #Print FILENAME on stderr

--report-exclude-network
process.report.excludeNetwork           20.13.0*#BOOL (def: false). Do not set OBJ.header.networkInterfaces, for performance
--report-exclude-env
process.report.excludeEnv               22.13.0*#BOOL (def: false). Do not set OBJ.envionmentVariables, for security

--diagnostic-report-*                           #Former name of --report-*

process.report.directory
--report-directory DIR                          #Def: '', i.e. process.cwd()
process.report.filename                         #'FILENAME|stdout|stderr'
--report-filename STR                           #Def: '', i.e. 'report.YYYYMMDD.HHMMSS.PID.COUNTER.json'
process.report.compact
--report-compact                                #Use JSON.stringify(VAL) instead of JSON.stringify(VAL, null, 2)

process.report.reportOnUncaughtException
--report-uncaught-exception                     #BOOL (def: false). Call writeReport() on unhandled uncaught exception
process.report.reportOnFatalError
--report-on-fatalerror                          #BOOL (def: false). Call writeReport() on process crashing (e.g. out of memory)
process.report.reportOnSignal
--report-on-signal                              #BOOL (def: false). Call writeReport() on signal.
process.report.signal
--report-signal SIGNAL                          #'SIGNAL' (def: 'SIGUSR2') used with process.report.reportOnSignal

                                  ┌───────────────┐
                                  │   PROFILING   │
                                  └───────────────┘

FRAME                                           #OBJ:
                                                #  - url 'STR': FILE URL
                                                #  - scriptId 'NUM': FILE ID
                                                #  - functionName 'FUNC.name'
                                                #  - lineNumber|columnNumber NUM

--prof                                          #Writes a V8 profiling dump on exit, to isolate-0xID-PID-v8.log
                                                #Similar to --cpu-prof but harder to read
--prof-process                                  #Visualize a V8 profiling dump on stdout

--cpu-prof                                      #Writes a CPU profiling dump on exit.
                                                #Can be loaded in Chrome DevTools `Performance` tab.
                                                #Use a sampling approach:
                                                #  - keep track of all stack frames
                                                #  - run periodic samples, checking which stack frames are executing
                                                #File is JSON:
                                                #  - nodes NODE_ARR (stack frames):
                                                #     - id 'NODE_ID'
                                                #     - children 'NODE_ID'_ARR
                                                #     - callFrame FRAME
                                                #     - hitCount NUM: number of samples where this stack frame was on top
                                                #     - positionTicks OBJ_ARR (optional):
                                                #        - line NUM: line number
                                                #        - ticks NUM: number of samples on that line
                                                #  - startTime|endTime NUM (in ns): since machine startup
                                                #  - samples 'NODE_ID'_ARR: top stack frame for each sample
                                                #  - timeDeltas NUM_ARR (in ns):
                                                #     - time between each sample
                                                #     - should be approximately same as --cpu-prof-interval
--cpu-prof-dir 'DIR'                            #Def: --diagnostic-dir
--cpu-prof-name STR                             #Def: 'CPU.YYYYMMDD.HHMMSS.PID.TID.COUNTER.cpuprofile'
--cpu-prof-interval NUM                         #NUM (in microsecs). Def: 1000

--heap-prof                                     #Writes a heap profiling dump on exit.
                                                #Can be loaded in Chrome DevTools `Memory` tab.
                                                #File is JSON:
                                                #  - head NODE:
                                                #     - id 'NODE_ID'
                                                #     - children NODE_ARR
                                                #     - callFrame FRAME
                                                #     - selfSize NUM (in bytes)
                                                #  - samples OBJ_ARR:
                                                #     - nodeId 'NODE_ID'
                                                #     - ordinal NUM (index)
                                                #     - size NUM (in bytes)
                                                #FRAME: functionName STR, scriptId STR
--heap-prof-dir 'DIR'                           #Def: --diagnostic-dir
--heap-prof-name STR                            #Def: 'Heap.YYYYMMDD.HHMMSS.PID.TID.COUNTER.heapprofile'
--heap-prof-interval NUM                        #NUM (in bytes). Def: 512KB

--diagnostic-dir 'DIR'                          #Default value of --cpu-prof-dir|heap-prof-dir|redirect-warnings
                                         20.8.0*#Also used by writeHeapSnapshot()
                                                #Def: PWD

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

getHeapStatistics()->OBJ                        #OBJ:
                                                #  - total|used_heap_size[_executable] NUM
                                                #  - total|used_global_handles_size NUM
                                                #  - total_physical|available_size NUM
                                                #  - heap_size_limit NUM
                                                #  - external_memory NUM
                                                #  - [peak_]malloced_memory NUM
                                                #  - does_zap_garbage BOOL
                                                #  - number_of_native|detached_contexts NUM
getHeapSpaceStatistics()->OBJ                   #OBJ:
                                                #  - space_name STR
                                                #  - space_[used|available_]size NUM
                                                #  - physical_space_size NUM
getHeapCodeStatistics()->OBJ                    #OBJ:
                                                #  - code_and_metadata_size NUM
                                                #  - bytecode_and_metadata_size NUM
                                                #  - external_script_source_size NUM
getCppHeapStatistics([STR])->OBJ        23.10.0*#OBJ:
                                        23.10.0*#  - committed|resident|used_size_bytes NUM
                                        23.10.0*#  - detail_level STR: the argument
                                        23.10.0*#  - type_names ARR
                                        23.10.0*#  - space_statistics OBJ_ARR:
                                        23.10.0*#     (only set if STR 'detailed' (def) instead of 'brief')
                                        23.10.0*#     - name STR
                                        23.10.0*#     - committed|resident|used_size_bytes NUM
                                        23.10.0*#     - page_stats OBJ_ARR
                                        23.10.0*#     - free_list_stats OBJ

new GCProfiler()->GC_PROFILER           18.15.0*#
GC_PROFILER.start()                     18.15.0*#
GC_PROFILER.stop()->OBJ                 18.15.0*#Returns information about garbage collection.
                                        18.15.0*#OBJ:
                                        18.15.0*#  - version 1
                                        18.15.0*#  - startTime|endTime DATE_NUM
                                        18.15.0*#  - statistics OBJ_ARR:
                                        18.15.0*#     - gcType STR: GC event type
                                        18.15.0*#     - cost NUM
                                        18.15.0*#     - beforeGC|afterGC OBJ:
                                        18.15.0*#        - heapStatistics OBJ: same as getHeapStatistics() but camelCase
                                        18.15.0*#        - heapSpaceStatistics OBJ_ARR: same as getHeapSpaceStatistics() but camelCase

--expose-gc                              22.3.0*#Enables globalThis.gc()
globalThis.gc()                          22.3.0*#Triggers garbage collection

setFlagsFromString('--OPT ...')                 #Additional v8 CLI options

serialize(VAL)->BUFFER
deserialize(BUFFER)->VAL                        #Serialize|deserialize according to structured clone algorithm (see JavaScript doc)

structuredClone(VAL[, OPTS])->VAL2              #See DOM doc. Global function.

queryObjects(CLASS[, OPTS])->NUM        20.13.0*#Returns NUM of instances of CLASS
                                        20.13.0*#OPTS:
                                        20.13.0*#  - format 'count' (def) or 'summary': if 'summary', returns STR_ARR instead
                                        20.13.0*#     - each STR is a description, e.g. 'CLASS { ATTR: VAL, ... }'

NODE_V8_COVERAGE=DIR                            #
takeCoverage()                                  #
stopCoverage()                                  #See v8 coverage doc

--use-largepages=STR                            #Use page size of 2MiB instead of 4KiB.
                                                #Good when lots of random access on large amount of memory
                                                #STR can be:
                                                #  - 'off' (def)
                                                #  - 'silent': silent if fail
                                                #  - 'on': warning if fail

isStringOneByteRepresentation           23.10.0*#Whether CHAR exists in Latin-1 encoding
 ('CHAR')->BOOL                         23.10.0*#Goal: under-the-hood, V8 stores Latin-1-only STRs with 1 byte per char
                                        23.10.0*#instead of using UTF-16 (2 bytes per char)

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

getHeapSnapshot([OPTS])->ISTREAM                #Create a V8 heap snapshot. This serializes the current process|worker state.
                                                #Parent|child workers are not included.
                                                #This can be used to:
                                                #  - restart the process later, or speed up startup time
                                                #  - inspect memory/heap in Chrome devTools
                                         19.1.0*#OPTS:
                                         19.1.0*#  - exposeInternals BOOL (def: false): snapshot includes internal details
                                         19.1.0*#  - exposeNumericValues BOOL (def: false): snapshot includes number details
writeHeapSnapshot(['FILENAME'][, OPTS])         #Write getHeapSnapshot() to a file in --diagnostic-dir
 ->'FILENAME'                                   #'FILENAME' defaults to 'Heap-${yyyymmdd}-${hhmmss}-${pid}-${threadId}.heapsnapshot'
                                         19.1.0*#OPTS: exposeInternals|exposeNumericValues
--heapsnaphot-signal=SIGNAL                     #Do writeHeapSnapshot() on SIGNAL
--heapsnaphot-near-heap-limit=NUM               #Do writeHeapSnapshot() when close to heap limit (memory crash)
                                                #Rotates at most files at once
                                                #Def: 0 (disabled)
setHeapSnapshotNearHeapLimit(NUM)               #

--build-snapshot                         18.8.0*#When process exits, write heap snapshot.
                                         18.8.0*#Limitations:
                                         18.8.0*#  - forces CommonJS
                                         18.8.0*#  - can only require() core modules, and only few of them
--snapshot-blob=PATH                     18.8.0*#With --build-snapshot, where to write heap snapshot (def: snapshot.blob)
                                         18.8.0*#Without --build-snapshot, use heap snapshot
                                         18.8.0*#  - The Node.js binary (version, arch, OS) and V8 flags must be identical
./configure --node-snapshot-main=PATH           #Same as --build-snapshot, but when building Node.js.
                                                #Write heap snapshot to ./out/Release/node

--build-snapshot-config
 =SNAPSHOT_CONFIG_PATH                  20.12.0*#
SNAPSHOT_CONFIG_PATH.builder            20.12.0*#'PATH' of the script to create the heap snapshot
SNAPSHOT_CONFIG_PATH.withoutCodeCache   20.12.0*#BOOL. If false (def), includes V8 code cache in snapshot.
                                        20.12.0*#This makes snapshot creation and startup faster.
                                        20.12.0*#But this makes snapshot bigger, less portable and forbid dynamic import()

startupSnapshot.isBuildingSnapshot()
 ->BOOL                                         #True when writing snaphot
startupSnapshot.addSerializeCallback            #Call FUNC before process writing snapshot exits.
 (FUNC(VAL)[, VAL])                             #Must be done by process writing snaphot.
                                                #VAL binds FUNC.
startupSnapshot.addDeserializeCallback          #Call FUNC when process reading snapshot starts.
 (FUNC(VAL)[, VAL])                             #Must be done by process writing snaphot.
                                                #VAL binds FUNC.
startupSnapshot.                                #Like addDeserializeCallbacks() except:
 setDeserializeMainFunction                     #  - Can be called only once
 (FUNC(VAL)[, VAL])                             #  - Makes specifying an entry file when reading the snapshot optional

                                  ┌─────────┐
                                  │   SEA   │
                                  └─────────┘

node sea-config.json                     20.0.0*#Outputs a FILE.js as a FILE.blob
--experimental-sea-config                20.0.0*#Must be set for the above
SEA_CONFIG.disableExperimentalSEAWarning 20.2.0*#BOOL (def: false)
SEA_CONFIG.main                          20.0.0*#'PATH' to FILE.js
SEA_CONFIG.output                        20.0.0*#'PATH' to FILE.blob
SEA_CONFIG.useSnapshot                   20.6.0*#BOOL (def: false). Runs FILE.js right away, and use startupSnapshot.* to
                                         20.6.0*#register the main FUNC
SEA_CONFIG.useCodeCache                  20.6.0*#BOOL (def: false). Like !SNAPSHOT_CONFIG_PATH.withoutCodeCache

postject NODE_BIN NODE_SEA_BLOB          20.0.0*#Make Node.js binary execute FILE.blob by default, i.e. embed it
 FILE.blob                               20.0.0*#To avoid modifying global Node.js binary, should copy it
                                         20.0.0*#  cp $(command -v node) NODE_BIN
                                         20.0.0*#NODE_SEA_BLOB is a literal string
                                         20.0.0*#FILE.blob must:
                                         20.0.0*#  - use CommonJS
                                         20.0.0*#  - only require('node:*')
                                         20.0.0*#     - however can do require('node:module').createRequire() to get a normal require()
                                         20.0.0*#     - i.e. should use a bundler
                                         20.0.0*#  - __filename|__dirname === process.execPath
                                         20.0.0*#Signature must also be removed from NODE_BIN, then re-added after postject done
                                         20.0.0*#  - Linux: nothing to do
                                         20.0.0*#  - macOS: codesign --remove-signature NODE_BIN, then codesign --sign - NODE_BIN
                                         20.0.0*#  - Windows: signtool remove /s NODE_BIN, then signtool sign /fd SHA256 NODE_BIN
--sentinel-fuse NODE_SEA_FUSE_{ID}       20.0.0*#Must be set
--macho-segment-name NODE_SEA            20.0.0*#Must be set on macOS

isSea()->BOOL                           20.12.0*#Whether is a SEA binary

SEA_CONFIG.assets.ASSET                 20.12.0*#'PATH' to contents bundled with binary
getAsset('ASSET'[, 'TENCODING'])
 ->ABUFFER                              20.12.0*#
getRawAsset('ASSET')->ARRBUFFER         20.12.0*#Same but does not copy, i.e. faster but read-only
getAssetAsBlob('ASSET'[, OPTS])->BLOB   20.12.0*#OPTS: type 'MIME'

                                  ┌────────────┐
                                  │   ASSERT   │
                                  └────────────┘

ASSERT ==>                                      #See Node.js assert doc

new CallTracker()                               #See Node.js mock documentation

snapshot(...)                            18.8.0*#See Node.js snapshots documentation

                                  ┌──────────┐
                                  │   TEST   │
                                  └──────────┘

DOCS ==>                                        #See node_test doc