diff --git a/content/api/v16/assert.en.md b/content/api/v16/assert.en.md
index 6065cf859f..30296972d4 100644
--- a/content/api/v16/assert.en.md
+++ b/content/api/v16/assert.en.md
@@ -13,7 +13,7 @@ Stable
-
-`options.onPropagate` is experimental.
+Experimental
-* `options` [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
- * `onPropagate` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) Optional callback invoked before a store is
- propagated to a new async resource. Returning `true` allows propagation,
- returning `false` avoids it. Default is to propagate always.
+* `fn` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) The function to bind to the current execution context.
+* Returns: [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) A new function that calls `fn` within the captured
+ execution context.
-Creates a new instance of `AsyncLocalStorage`. Store is only provided within a
-`run()` call or after an `enterWith()` call.
+Binds the given function to the current execution context.
+
+#### Static method: `AsyncLocalStorage.snapshot()`
+
+
-The `onPropagate` is called during creation of an async resource. Throwing at
-this time will print the stack trace and exit. See
-[`async_hooks` Error handling][] for details.
+Experimental
+
+
+
+* Returns: [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) A new function with the signature
+ `(fn: (...args) : R, ...args) : R`.
-Creating an async resource within the `onPropagate` callback will result in
-a recursive call to `onPropagate`.
+Captures the current execution context and returns a function that accepts a
+function as an argument. Whenever the returned function is called, it
+calls the function passed to it within the captured context.
+
+```js
+const asyncLocalStorage = new AsyncLocalStorage();
+const runInAsyncScope = asyncLocalStorage.run(123, () => asyncLocalStorage.snapshot());
+const result = asyncLocalStorage.run(321, () => runInAsyncScope(() => asyncLocalStorage.getStore()));
+console.log(result); // returns 123
+```
+
+AsyncLocalStorage.snapshot() can replace the use of AsyncResource for simple
+async context tracking purposes, for example:
+
+```js
+class Foo {
+ #runInAsyncScope = AsyncLocalStorage.snapshot();
+
+ get() { return this.#runInAsyncScope(() => asyncLocalStorage.getStore()); }
+}
+
+const foo = asyncLocalStorage.run(123, () => new Foo());
+console.log(asyncLocalStorage.run(321, () => foo.get())); // returns 123
+```
####
SSL_OP_ALLApplies multiple bug workarounds within OpenSSL. See
- https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html
+ https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html
for detail.
@@ -4780,13 +4789,13 @@ See the [list of SSL OP Flags][] for details.
SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATIONAllows legacy insecure renegotiation between OpenSSL and unpatched
clients or servers. See
- https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html .
+ https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html .
SSL_OP_CIPHER_SERVER_PREFERENCEAttempts to use the server's preferences instead of the client's when
selecting a cipher. Behavior depends on protocol version. See
- https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html .
+ https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html .
SSL_OP_CISCO_ANYCONNECTInstructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability
workaround added in OpenSSL 0.9.6d.
-
- SSL_OP_EPHEMERAL_RSAInstructs OpenSSL to always use the tmp_rsa key when performing RSA
- operations.
-
SSL_OP_LEGACY_SERVER_CONNECTAllows initial connection to servers that do not support RI.
-
- SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
-
- SSL_OP_MICROSOFT_SESS_ID_BUG
-
- SSL_OP_MSIE_SSLV2_RSA_PADDINGInstructs OpenSSL to disable the workaround for a man-in-the-middle
- protocol-version vulnerability in the SSL 2.0 server implementation.
-
-
- SSL_OP_NETSCAPE_CA_DN_BUG
-
- SSL_OP_NETSCAPE_CHALLENGE_BUG
-
- SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG
-
- SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
SSL_OP_NO_COMPRESSIONInstructs OpenSSL to disable support for SSL/TLS compression.
@@ -4893,14 +4868,6 @@ See the [list of SSL OP Flags][] for details.
SSL_OP_NO_TLSv1_3Instructs OpenSSL to turn off TLS v1.3
-
- SSL_OP_PKCS1_CHECK_1
-
- SSL_OP_PKCS1_CHECK_2
SSL_OP_PRIORITIZE_CHACHAInstructs OpenSSL server to prioritize ChaCha20-Poly1305
@@ -4909,32 +4876,6 @@ See the [list of SSL OP Flags][] for details.
SSL_OP_CIPHER_SERVER_PREFERENCE
is not enabled.
-
- SSL_OP_SINGLE_DH_USEInstructs OpenSSL to always create a new key when using
- temporary/ephemeral DH parameters.
-
-
- SSL_OP_SINGLE_ECDH_USEInstructs OpenSSL to always create a new key when using
- temporary/ephemeral ECDH parameters.
-
-
- SSL_OP_SSLEAY_080_CLIENT_DH_BUG
-
- SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
-
- SSL_OP_TLS_BLOCK_PADDING_BUG
-
- SSL_OP_TLS_D5_BUG
SSL_OP_TLS_ROLLBACK_BUGInstructs OpenSSL to disable version rollback attack detection.
@@ -5117,6 +5058,7 @@ See the [list of SSL OP Flags][] for details.
[Web Crypto API documentation]: /api/v18/webcrypto
[`BN_is_prime_ex`]: https://www.openssl.org/docs/man1.1.1/man3/BN_is_prime_ex.html
[`Buffer`]: /api/v18/buffer
+[`DH_generate_key()`]: https://www.openssl.org/docs/man3.0/man3/DH_generate_key.html
[`DiffieHellmanGroup`]: #class-diffiehellmangroup
[`EVP_BytesToKey`]: https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html
[`KeyObject`]: #class-keyobject
@@ -5153,6 +5095,7 @@ See the [list of SSL OP Flags][] for details.
[`crypto.webcrypto.subtle`]: /api/v18/webcrypto#class-subtlecrypto
[`decipher.final()`]: #decipherfinaloutputencoding
[`decipher.update()`]: #decipherupdatedata-inputencoding-outputencoding
+[`diffieHellman.generateKeys()`]: #diffiehellmangeneratekeysencoding
[`diffieHellman.setPublicKey()`]: #diffiehellmansetpublickeypublickey-encoding
[`ecdh.generateKeys()`]: #ecdhgeneratekeysencoding-format
[`ecdh.setPrivateKey()`]: #ecdhsetprivatekeyprivatekey-encoding
diff --git a/content/api/v18/debugger.en.md b/content/api/v18/debugger.en.md
index 13b63ea36d..5c0a921404 100644
--- a/content/api/v18/debugger.en.md
+++ b/content/api/v18/debugger.en.md
@@ -206,11 +206,19 @@ debug>
after)
* `watch(expr)`: Add expression to watch list
* `unwatch(expr)`: Remove expression from watch list
+* `unwatch(index)`: Remove expression at specific index from watch list
* `watchers`: List all watchers and their values (automatically listed on each
breakpoint)
* `repl`: Open debugger's repl for evaluation in debugging script's context
* `exec expr`, `p expr`: Execute an expression in debugging script's context and
print its value
+* `profile`: Start CPU profiling session
+* `profileEnd`: Stop current CPU profiling session
+* `profiles`: List all completed CPU profiling sessions
+* `profiles[n].save(filepath = 'node.cpuprofile')`: Save CPU profiling session
+ to disk as JSON
+* `takeHeapSnapshot(filepath = 'node.heapsnapshot')`: Take a heap snapshot
+ and save to disk as JSON
#### Execution control
diff --git a/content/api/v18/deprecations.en.md b/content/api/v18/deprecations.en.md
index 4f2022ebcb..2b677f8310 100644
--- a/content/api/v18/deprecations.en.md
+++ b/content/api/v18/deprecations.en.md
@@ -1864,7 +1864,7 @@ In a future version of Node.js, [`message.headers`][],
[`dnsPromises.lookup()`]: /api/v18/dns#dnspromiseslookuphostname-options
[`domain`]: /api/v18/domain
[`ecdh.setPublicKey()`]: /api/v18/crypto#ecdhsetpublickeypublickey-encoding
-[`emitter.listenerCount(eventName)`]: /api/v18/events#emitterlistenercounteventname
+[`emitter.listenerCount(eventName)`]: /api/v18/events#emitterlistenercounteventname-listener
[`events.listenerCount(emitter, eventName)`]: /api/v18/events#eventslistenercountemitter-eventname
[`fs.FileHandle`]: /api/v18/fs#class-filehandle
[`fs.access()`]: /api/v18/fs#fsaccesspath-mode-callback
diff --git a/content/api/v18/dgram.en.md b/content/api/v18/dgram.en.md
index edc0c86399..ff64e61bd1 100644
--- a/content/api/v18/dgram.en.md
+++ b/content/api/v18/dgram.en.md
@@ -15,7 +15,7 @@ Stable
Hello World ');
});
-server.listen(80);
+server.listen(8000);
```
Even though HTTP/2 streams and network sockets are not in a 1:1 correspondence,
@@ -2158,7 +2158,7 @@ server.on('stream', (stream, headers) => {
stream.end('Hello World ');
});
-server.listen(80);
+server.listen(8000);
```
#### Hello World ');
});
-server.listen(80);
+server.listen(8443);
```
####
+
+Experimental: This feature is being designed and will change.
+
+
+
+
@@ -2560,7 +2561,8 @@ const server = http.createServer((req, res) => {
-* `streams` Stream\[]|Iterable\[]|AsyncIterable\[]|Function\[]
+* `streams` Stream\[]|Iterable\[]|AsyncIterable\[]|Function\[]|
+ ReadableStream\[]|WritableStream\[]|TransformStream\[]
* Returns: [`stream.Duplex`](/api/v18/stream#streamduplex)
Combines two or more streams into a `Duplex` stream that writes to the
@@ -2765,8 +2767,14 @@ Experimental
* `streamReadable` [`stream.Readable`](/api/v18/stream#streamreadable)
* `options` [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
* `strategy` [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
- * `highWaterMark` [`number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)
- * `size` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+ * `highWaterMark` [`number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The maximum internal queue size (of the created
+ `ReadableStream`) before backpressure is applied in reading from the given
+ `stream.Readable`. If no value is provided, it will be taken from the
+ given `stream.Readable`.
+ * `size` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) A function that size of the given chunk of data.
+ If no value is provided, the size will be `1` for all the chunks.
+ * `chunk` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types)
+ * Returns: [`number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)
* Returns: [`ReadableStream`](/api/v18/webstreams#readablestream)
####
Experimental
-'` if `fn`
- does not have a name.
-* `options` [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Configuration options for the suite.
- supports the same options as `test([name][, options][, fn])`.
-* `fn` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) | [`AsyncFunction`](https://tc39.es/ecma262/#sec-async-function-constructor) The function under test.
- If the test uses callbacks, the callback function is passed as an argument.
- **Default:** A no-op function.
-* Returns: `undefined`.
+
+
+Experimental
+
+
+
+* `signal` [`AbortSignal`](/api/v18/globals#abortsignal)
+* `resource` [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Any non-null entity, reference to which is held weakly.
+* Returns: [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+
+Listens to abort event on the provided `signal` and
+returns a promise that is fulfilled when the `signal` is
+aborted. If the passed `resource` is garbage collected before the `signal` is
+aborted, the returned promise shall remain pending indefinitely.
+
+```cjs|mjs
+const { aborted } = require('node:util');
+
+const dependent = obtainSomethingAbortable();
+
+aborted(dependent.signal, dependent).then(() => {
+ // Do something when dependent is aborted.
+});
+
+dependent.on('event', () => {
+ dependent.abort();
+});
+--------------
+import { aborted } from 'node:util';
+
+const dependent = obtainSomethingAbortable();
+
+aborted(dependent.signal, dependent).then(() => {
+ // Do something when dependent is aborted.
+});
+
+dependent.on('event', () => {
+ dependent.abort();
+});
+```
+
###
+
+namespace demo {
+
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void Method(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ args.GetReturnValue().Set(String::NewFromUtf8(
+ isolate, "world").ToLocalChecked());
+}
+
+void Initialize(Local exports) {
+ NODE_SET_METHOD(exports, "hello", Method);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+
+} // namespace demo
+```
+
+All Node.js addons must export an initialization function following
+the pattern:
+
+```cpp
+void Initialize(Local exports);
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+```
+
+There is no semi-colon after `NODE_MODULE` as it's not a function (see
+`node.h`).
+
+The `module_name` must match the filename of the final binary (excluding
+the `.node` suffix).
+
+In the `hello.cc` example, then, the initialization function is `Initialize`
+and the addon module name is `addon`.
+
+When building addons with `node-gyp`, using the macro `NODE_GYP_MODULE_NAME` as
+the first parameter of `NODE_MODULE()` will ensure that the name of the final
+binary will be passed to `NODE_MODULE()`.
+
+Addons defined with `NODE_MODULE()` can not be loaded in multiple contexts or
+multiple threads at the same time.
+
+#### Context-aware addons
+
+There are environments in which Node.js addons may need to be loaded multiple
+times in multiple contexts. For example, the [Electron][] runtime runs multiple
+instances of Node.js in a single process. Each instance will have its own
+`require()` cache, and thus each instance will need a native addon to behave
+correctly when loaded via `require()`. This means that the addon
+must support multiple initializations.
+
+A context-aware addon can be constructed by using the macro
+`NODE_MODULE_INITIALIZER`, which expands to the name of a function which Node.js
+will expect to find when it loads an addon. An addon can thus be initialized as
+in the following example:
+
+```cpp
+using namespace v8;
+
+extern "C" NODE_MODULE_EXPORT void
+NODE_MODULE_INITIALIZER(Local exports,
+ Local module,
+ Local context) {
+ /* Perform addon initialization steps here. */
+}
+```
+
+Another option is to use the macro `NODE_MODULE_INIT()`, which will also
+construct a context-aware addon. Unlike `NODE_MODULE()`, which is used to
+construct an addon around a given addon initializer function,
+`NODE_MODULE_INIT()` serves as the declaration of such an initializer to be
+followed by a function body.
+
+The following three variables may be used inside the function body following an
+invocation of `NODE_MODULE_INIT()`:
+
+* `Local exports`,
+* `Local module`, and
+* `Local context`
+
+The choice to build a context-aware addon carries with it the responsibility of
+carefully managing global static data. Since the addon may be loaded multiple
+times, potentially even from different threads, any global static data stored
+in the addon must be properly protected, and must not contain any persistent
+references to JavaScript objects. The reason for this is that JavaScript
+objects are only valid in one context, and will likely cause a crash when
+accessed from the wrong context or from a different thread than the one on which
+they were created.
+
+The context-aware addon can be structured to avoid global static data by
+performing the following steps:
+
+* Define a class which will hold per-addon-instance data and which has a static
+ member of the form
+ ```cpp
+ static void DeleteInstance(void* data) {
+ // Cast `data` to an instance of the class and delete it.
+ }
+ ```
+* Heap-allocate an instance of this class in the addon initializer. This can be
+ accomplished using the `new` keyword.
+* Call `node::AddEnvironmentCleanupHook()`, passing it the above-created
+ instance and a pointer to `DeleteInstance()`. This will ensure the instance is
+ deleted when the environment is torn down.
+* Store the instance of the class in a `v8::External`, and
+* Pass the `v8::External` to all methods exposed to JavaScript by passing it
+ to `v8::FunctionTemplate::New()` or `v8::Function::New()` which creates the
+ native-backed JavaScript functions. The third parameter of
+ `v8::FunctionTemplate::New()` or `v8::Function::New()` accepts the
+ `v8::External` and makes it available in the native callback using the
+ `v8::FunctionCallbackInfo::Data()` method.
+
+This will ensure that the per-addon-instance data reaches each binding that can
+be called from JavaScript. The per-addon-instance data must also be passed into
+any asynchronous callbacks the addon may create.
+
+The following example illustrates the implementation of a context-aware addon:
+
+```cpp
+#include
+
+using namespace v8;
+
+class AddonData {
+ public:
+ explicit AddonData(Isolate* isolate):
+ call_count(0) {
+ // Ensure this per-addon-instance data is deleted at environment cleanup.
+ node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);
+ }
+
+ // Per-addon data.
+ int call_count;
+
+ static void DeleteInstance(void* data) {
+ delete static_cast(data);
+ }
+};
+
+static void Method(const v8::FunctionCallbackInfo& info) {
+ // Retrieve the per-addon-instance data.
+ AddonData* data =
+ reinterpret_cast(info.Data().As()->Value());
+ data->call_count++;
+ info.GetReturnValue().Set((double)data->call_count);
+}
+
+// Initialize this addon to be context-aware.
+NODE_MODULE_INIT(/* exports, module, context */) {
+ Isolate* isolate = context->GetIsolate();
+
+ // Create a new instance of `AddonData` for this instance of the addon and
+ // tie its life cycle to that of the Node.js environment.
+ AddonData* data = new AddonData(isolate);
+
+ // Wrap the data in a `v8::External` so we can pass it to the method we
+ // expose.
+ Local external = External::New(isolate, data);
+
+ // Expose the method `Method` to JavaScript, and make sure it receives the
+ // per-addon-instance data we created above by passing `external` as the
+ // third parameter to the `FunctionTemplate` constructor.
+ exports->Set(context,
+ String::NewFromUtf8(isolate, "method").ToLocalChecked(),
+ FunctionTemplate::New(isolate, Method, external)
+ ->GetFunction(context).ToLocalChecked()).FromJust();
+}
+```
+
+##### Worker support
+
+
+#include
+#include
+
+using node::AddEnvironmentCleanupHook;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+
+// Note: In a real-world application, do not rely on static/global data.
+static char cookie[] = "yum yum";
+static int cleanup_cb1_called = 0;
+static int cleanup_cb2_called = 0;
+
+static void cleanup_cb1(void* arg) {
+ Isolate* isolate = static_cast(arg);
+ HandleScope scope(isolate);
+ Local obj = Object::New(isolate);
+ assert(!obj.IsEmpty()); // assert VM is still alive
+ assert(obj->IsObject());
+ cleanup_cb1_called++;
+}
+
+static void cleanup_cb2(void* arg) {
+ assert(arg == static_cast(cookie));
+ cleanup_cb2_called++;
+}
+
+static void sanity_check(void*) {
+ assert(cleanup_cb1_called == 1);
+ assert(cleanup_cb2_called == 1);
+}
+
+// Initialize this addon to be context-aware.
+NODE_MODULE_INIT(/* exports, module, context */) {
+ Isolate* isolate = context->GetIsolate();
+
+ AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);
+ AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);
+ AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);
+}
+```
+
+Test in JavaScript by running:
+
+```js
+// test.js
+require('./build/Release/addon');
+```
+
+#### Building
+
+Once the source code has been written, it must be compiled into the binary
+`addon.node` file. To do so, create a file called `binding.gyp` in the
+top-level of the project describing the build configuration of the module
+using a JSON-like format. This file is used by [node-gyp][], a tool written
+specifically to compile Node.js addons.
+
+```json
+{
+ "targets": [
+ {
+ "target_name": "addon",
+ "sources": [ "hello.cc" ]
+ }
+ ]
+}
+```
+
+A version of the `node-gyp` utility is bundled and distributed with
+Node.js as part of `npm`. This version is not made directly available for
+developers to use and is intended only to support the ability to use the
+`npm install` command to compile and install addons. Developers who wish to
+use `node-gyp` directly can install it using the command
+`npm install -g node-gyp`. See the `node-gyp` [installation instructions][] for
+more information, including platform-specific requirements.
+
+Once the `binding.gyp` file has been created, use `node-gyp configure` to
+generate the appropriate project build files for the current platform. This
+will generate either a `Makefile` (on Unix platforms) or a `vcxproj` file
+(on Windows) in the `build/` directory.
+
+Next, invoke the `node-gyp build` command to generate the compiled `addon.node`
+file. This will be put into the `build/Release/` directory.
+
+When using `npm install` to install a Node.js addon, npm uses its own bundled
+version of `node-gyp` to perform this same set of actions, generating a
+compiled version of the addon for the user's platform on demand.
+
+Once built, the binary addon can be used from within Node.js by pointing
+[`require()`][require] to the built `addon.node` module:
+
+```js
+// hello.js
+const addon = require('./build/Release/addon');
+
+console.log(addon.hello());
+// Prints: 'world'
+```
+
+Because the exact path to the compiled addon binary can vary depending on how
+it is compiled (i.e. sometimes it may be in `./build/Debug/`), addons can use
+the [bindings][] package to load the compiled module.
+
+While the `bindings` package implementation is more sophisticated in how it
+locates addon modules, it is essentially using a `try…catch` pattern similar to:
+
+```js
+try {
+ return require('./build/Release/addon.node');
+} catch (err) {
+ return require('./build/Debug/addon.node');
+}
+```
+
+#### Linking to libraries included with Node.js
+
+Node.js uses statically linked libraries such as V8, libuv, and OpenSSL. All
+addons are required to link to V8 and may link to any of the other dependencies
+as well. Typically, this is as simple as including the appropriate
+`#include <...>` statements (e.g. `#include `) and `node-gyp` will locate
+the appropriate headers automatically. However, there are a few caveats to be
+aware of:
+
+* When `node-gyp` runs, it will detect the specific release version of Node.js
+ and download either the full source tarball or just the headers. If the full
+ source is downloaded, addons will have complete access to the full set of
+ Node.js dependencies. However, if only the Node.js headers are downloaded,
+ then only the symbols exported by Node.js will be available.
+
+* `node-gyp` can be run using the `--nodedir` flag pointing at a local Node.js
+ source image. Using this option, the addon will have access to the full set of
+ dependencies.
+
+#### Loading addons using `require()`
+
+The filename extension of the compiled addon binary is `.node` (as opposed
+to `.dll` or `.so`). The [`require()`][require] function is written to look for
+files with the `.node` file extension and initialize those as dynamically-linked
+libraries.
+
+When calling [`require()`][require], the `.node` extension can usually be
+omitted and Node.js will still find and initialize the addon. One caveat,
+however, is that Node.js will first attempt to locate and load modules or
+JavaScript files that happen to share the same base name. For instance, if
+there is a file `addon.js` in the same directory as the binary `addon.node`,
+then [`require('addon')`][require] will give precedence to the `addon.js` file
+and load it instead.
+
+### Native abstractions for Node.js
+
+Each of the examples illustrated in this document directly use the
+Node.js and V8 APIs for implementing addons. The V8 API can, and has, changed
+dramatically from one V8 release to the next (and one major Node.js release to
+the next). With each change, addons may need to be updated and recompiled in
+order to continue functioning. The Node.js release schedule is designed to
+minimize the frequency and impact of such changes but there is little that
+Node.js can do to ensure stability of the V8 APIs.
+
+The [Native Abstractions for Node.js][] (or `nan`) provide a set of tools that
+addon developers are recommended to use to keep compatibility between past and
+future releases of V8 and Node.js. See the `nan` [examples][] for an
+illustration of how it can be used.
+
+### Node-API
+
+
+
+Stable
+
+
+
+Node-API is an API for building native addons. It is independent from
+the underlying JavaScript runtime (e.g. V8) and is maintained as part of
+Node.js itself. This API will be Application Binary Interface (ABI) stable
+across versions of Node.js. It is intended to insulate addons from
+changes in the underlying JavaScript engine and allow modules
+compiled for one version to run on later versions of Node.js without
+recompilation. Addons are built/packaged with the same approach/tools
+outlined in this document (node-gyp, etc.). The only difference is the
+set of APIs that are used by the native code. Instead of using the V8
+or [Native Abstractions for Node.js][] APIs, the functions available
+in the Node-API are used.
+
+Creating and maintaining an addon that benefits from the ABI stability
+provided by Node-API carries with it certain
+[implementation considerations][].
+
+To use Node-API in the above "Hello world" example, replace the content of
+`hello.cc` with the following. All other instructions remain the same.
+
+```cpp
+// hello.cc using Node-API
+#include
+
+namespace demo {
+
+napi_value Method(napi_env env, napi_callback_info args) {
+ napi_value greeting;
+ napi_status status;
+
+ status = napi_create_string_utf8(env, "world", NAPI_AUTO_LENGTH, &greeting);
+ if (status != napi_ok) return nullptr;
+ return greeting;
+}
+
+napi_value init(napi_env env, napi_value exports) {
+ napi_status status;
+ napi_value fn;
+
+ status = napi_create_function(env, nullptr, 0, Method, nullptr, &fn);
+ if (status != napi_ok) return nullptr;
+
+ status = napi_set_named_property(env, exports, "hello", fn);
+ if (status != napi_ok) return nullptr;
+ return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init)
+
+} // namespace demo
+```
+
+The functions available and how to use them are documented in
+[C/C++ addons with Node-API](n-api.md).
+
+### Addon examples
+
+Following are some example addons intended to help developers get started. The
+examples use the V8 APIs. Refer to the online [V8 reference][v8-docs]
+for help with the various V8 calls, and V8's [Embedder's Guide][] for an
+explanation of several concepts used such as handles, scopes, function
+templates, etc.
+
+Each of these examples using the following `binding.gyp` file:
+
+```json
+{
+ "targets": [
+ {
+ "target_name": "addon",
+ "sources": [ "addon.cc" ]
+ }
+ ]
+}
+```
+
+In cases where there is more than one `.cc` file, simply add the additional
+filename to the `sources` array:
+
+```json
+"sources": ["addon.cc", "myexample.cc"]
+```
+
+Once the `binding.gyp` file is ready, the example addons can be configured and
+built using `node-gyp`:
+
+```bash
+node-gyp configure build
+```
+
+#### Function arguments
+
+Addons will typically expose objects and functions that can be accessed from
+JavaScript running within Node.js. When functions are invoked from JavaScript,
+the input arguments and return value must be mapped to and from the C/C++
+code.
+
+The following example illustrates how to read function arguments passed from
+JavaScript and how to return a result:
+
+```cpp
+// addon.cc
+#include
+
+namespace demo {
+
+using v8::Exception;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+// This is the implementation of the "add" method
+// Input arguments are passed using the
+// const FunctionCallbackInfo& args struct
+void Add(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ // Check the number of arguments passed.
+ if (args.Length() < 2) {
+ // Throw an Error that is passed back to JavaScript
+ isolate->ThrowException(Exception::TypeError(
+ String::NewFromUtf8(isolate,
+ "Wrong number of arguments").ToLocalChecked()));
+ return;
+ }
+
+ // Check the argument types
+ if (!args[0]->IsNumber() || !args[1]->IsNumber()) {
+ isolate->ThrowException(Exception::TypeError(
+ String::NewFromUtf8(isolate,
+ "Wrong arguments").ToLocalChecked()));
+ return;
+ }
+
+ // Perform the operation
+ double value =
+ args[0].As()->Value() + args[1].As()->Value();
+ Local num = Number::New(isolate, value);
+
+ // Set the return value (using the passed in
+ // FunctionCallbackInfo&)
+ args.GetReturnValue().Set(num);
+}
+
+void Init(Local exports) {
+ NODE_SET_METHOD(exports, "add", Add);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+
+} // namespace demo
+```
+
+Once compiled, the example addon can be required and used from within Node.js:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+console.log('This should be eight:', addon.add(3, 5));
+```
+
+#### Callbacks
+
+It is common practice within addons to pass JavaScript functions to a C++
+function and execute them from there. The following example illustrates how
+to invoke such callbacks:
+
+```cpp
+// addon.cc
+#include
+
+namespace demo {
+
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Null;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void RunCallback(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+ Local cb = Local::Cast(args[0]);
+ const unsigned argc = 1;
+ Local argv[argc] = {
+ String::NewFromUtf8(isolate,
+ "hello world").ToLocalChecked() };
+ cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
+}
+
+void Init(Local exports, Local module) {
+ NODE_SET_METHOD(module, "exports", RunCallback);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+
+} // namespace demo
+```
+
+This example uses a two-argument form of `Init()` that receives the full
+`module` object as the second argument. This allows the addon to completely
+overwrite `exports` with a single function instead of adding the function as a
+property of `exports`.
+
+To test it, run the following JavaScript:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+addon((msg) => {
+ console.log(msg);
+// Prints: 'hello world'
+});
+```
+
+In this example, the callback function is invoked synchronously.
+
+#### Object factory
+
+Addons can create and return new objects from within a C++ function as
+illustrated in the following example. An object is created and returned with a
+property `msg` that echoes the string passed to `createObject()`:
+
+```cpp
+// addon.cc
+#include
+
+namespace demo {
+
+using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void CreateObject(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ Local obj = Object::New(isolate);
+ obj->Set(context,
+ String::NewFromUtf8(isolate,
+ "msg").ToLocalChecked(),
+ args[0]->ToString(context).ToLocalChecked())
+ .FromJust();
+
+ args.GetReturnValue().Set(obj);
+}
+
+void Init(Local exports, Local module) {
+ NODE_SET_METHOD(module, "exports", CreateObject);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+
+} // namespace demo
+```
+
+To test it in JavaScript:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+const obj1 = addon('hello');
+const obj2 = addon('world');
+console.log(obj1.msg, obj2.msg);
+// Prints: 'hello world'
+```
+
+#### Function factory
+
+Another common scenario is creating JavaScript functions that wrap C++
+functions and returning those back to JavaScript:
+
+```cpp
+// addon.cc
+#include
+
+namespace demo {
+
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void MyFunction(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ args.GetReturnValue().Set(String::NewFromUtf8(
+ isolate, "hello world").ToLocalChecked());
+}
+
+void CreateFunction(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ Local context = isolate->GetCurrentContext();
+ Local tpl = FunctionTemplate::New(isolate, MyFunction);
+ Local fn = tpl->GetFunction(context).ToLocalChecked();
+
+ // omit this to make it anonymous
+ fn->SetName(String::NewFromUtf8(
+ isolate, "theFunction").ToLocalChecked());
+
+ args.GetReturnValue().Set(fn);
+}
+
+void Init(Local exports, Local module) {
+ NODE_SET_METHOD(module, "exports", CreateFunction);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+
+} // namespace demo
+```
+
+To test:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+const fn = addon();
+console.log(fn());
+// Prints: 'hello world'
+```
+
+#### Wrapping C++ objects
+
+It is also possible to wrap C++ objects/classes in a way that allows new
+instances to be created using the JavaScript `new` operator:
+
+```cpp
+// addon.cc
+#include
+#include "myobject.h"
+
+namespace demo {
+
+using v8::Local;
+using v8::Object;
+
+void InitAll(Local exports) {
+ MyObject::Init(exports);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+
+} // namespace demo
+```
+
+Then, in `myobject.h`, the wrapper class inherits from `node::ObjectWrap`:
+
+```cpp
+// myobject.h
+#ifndef MYOBJECT_H
+#define MYOBJECT_H
+
+#include
+#include
+
+namespace demo {
+
+class MyObject : public node::ObjectWrap {
+ public:
+ static void Init(v8::Local exports);
+
+ private:
+ explicit MyObject(double value = 0);
+ ~MyObject();
+
+ static void New(const v8::FunctionCallbackInfo& args);
+ static void PlusOne(const v8::FunctionCallbackInfo& args);
+
+ double value_;
+};
+
+} // namespace demo
+
+#endif
+```
+
+In `myobject.cc`, implement the various methods that are to be exposed.
+Below, the method `plusOne()` is exposed by adding it to the constructor's
+prototype:
+
+```cpp
+// myobject.cc
+#include "myobject.h"
+
+namespace demo {
+
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::ObjectTemplate;
+using v8::String;
+using v8::Value;
+
+MyObject::MyObject(double value) : value_(value) {
+}
+
+MyObject::~MyObject() {
+}
+
+void MyObject::Init(Local exports) {
+ Isolate* isolate = exports->GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ Local addon_data_tpl = ObjectTemplate::New(isolate);
+ addon_data_tpl->SetInternalFieldCount(1); // 1 field for the MyObject::New()
+ Local addon_data =
+ addon_data_tpl->NewInstance(context).ToLocalChecked();
+
+ // Prepare constructor template
+ Local tpl = FunctionTemplate::New(isolate, New, addon_data);
+ tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+ // Prototype
+ NODE_SET_PROTOTYPE_METHOD(tpl, "plusOne", PlusOne);
+
+ Local constructor = tpl->GetFunction(context).ToLocalChecked();
+ addon_data->SetInternalField(0, constructor);
+ exports->Set(context, String::NewFromUtf8(
+ isolate, "MyObject").ToLocalChecked(),
+ constructor).FromJust();
+}
+
+void MyObject::New(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ if (args.IsConstructCall()) {
+ // Invoked as constructor: `new MyObject(...)`
+ double value = args[0]->IsUndefined() ?
+ 0 : args[0]->NumberValue(context).FromMaybe(0);
+ MyObject* obj = new MyObject(value);
+ obj->Wrap(args.This());
+ args.GetReturnValue().Set(args.This());
+ } else {
+ // Invoked as plain function `MyObject(...)`, turn into construct call.
+ const int argc = 1;
+ Local argv[argc] = { args[0] };
+ Local cons =
+ args.Data().As()->GetInternalField(0).As();
+ Local result =
+ cons->NewInstance(context, argc, argv).ToLocalChecked();
+ args.GetReturnValue().Set(result);
+ }
+}
+
+void MyObject::PlusOne(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ MyObject* obj = ObjectWrap::Unwrap(args.Holder());
+ obj->value_ += 1;
+
+ args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+}
+
+} // namespace demo
+```
+
+To build this example, the `myobject.cc` file must be added to the
+`binding.gyp`:
+
+```json
+{
+ "targets": [
+ {
+ "target_name": "addon",
+ "sources": [
+ "addon.cc",
+ "myobject.cc"
+ ]
+ }
+ ]
+}
+```
+
+Test it with:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+const obj = new addon.MyObject(10);
+console.log(obj.plusOne());
+// Prints: 11
+console.log(obj.plusOne());
+// Prints: 12
+console.log(obj.plusOne());
+// Prints: 13
+```
+
+The destructor for a wrapper object will run when the object is
+garbage-collected. For destructor testing, there are command-line flags that
+can be used to make it possible to force garbage collection. These flags are
+provided by the underlying V8 JavaScript engine. They are subject to change
+or removal at any time. They are not documented by Node.js or V8, and they
+should never be used outside of testing.
+
+During shutdown of the process or worker threads destructors are not called
+by the JS engine. Therefore it's the responsibility of the user to track
+these objects and ensure proper destruction to avoid resource leaks.
+
+#### Factory of wrapped objects
+
+Alternatively, it is possible to use a factory pattern to avoid explicitly
+creating object instances using the JavaScript `new` operator:
+
+```js
+const obj = addon.createObject();
+// instead of:
+// const obj = new addon.Object();
+```
+
+First, the `createObject()` method is implemented in `addon.cc`:
+
+```cpp
+// addon.cc
+#include
+#include "myobject.h"
+
+namespace demo {
+
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void CreateObject(const FunctionCallbackInfo& args) {
+ MyObject::NewInstance(args);
+}
+
+void InitAll(Local exports, Local module) {
+ MyObject::Init(exports->GetIsolate());
+
+ NODE_SET_METHOD(module, "exports", CreateObject);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+
+} // namespace demo
+```
+
+In `myobject.h`, the static method `NewInstance()` is added to handle
+instantiating the object. This method takes the place of using `new` in
+JavaScript:
+
+```cpp
+// myobject.h
+#ifndef MYOBJECT_H
+#define MYOBJECT_H
+
+#include
+#include
+
+namespace demo {
+
+class MyObject : public node::ObjectWrap {
+ public:
+ static void Init(v8::Isolate* isolate);
+ static void NewInstance(const v8::FunctionCallbackInfo& args);
+
+ private:
+ explicit MyObject(double value = 0);
+ ~MyObject();
+
+ static void New(const v8::FunctionCallbackInfo& args);
+ static void PlusOne(const v8::FunctionCallbackInfo& args);
+ static v8::Global constructor;
+ double value_;
+};
+
+} // namespace demo
+
+#endif
+```
+
+The implementation in `myobject.cc` is similar to the previous example:
+
+```cpp
+// myobject.cc
+#include
+#include "myobject.h"
+
+namespace demo {
+
+using node::AddEnvironmentCleanupHook;
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Global;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+// Warning! This is not thread-safe, this addon cannot be used for worker
+// threads.
+Global MyObject::constructor;
+
+MyObject::MyObject(double value) : value_(value) {
+}
+
+MyObject::~MyObject() {
+}
+
+void MyObject::Init(Isolate* isolate) {
+ // Prepare constructor template
+ Local tpl = FunctionTemplate::New(isolate, New);
+ tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+ // Prototype
+ NODE_SET_PROTOTYPE_METHOD(tpl, "plusOne", PlusOne);
+
+ Local context = isolate->GetCurrentContext();
+ constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+
+ AddEnvironmentCleanupHook(isolate, [](void*) {
+ constructor.Reset();
+ }, nullptr);
+}
+
+void MyObject::New(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ if (args.IsConstructCall()) {
+ // Invoked as constructor: `new MyObject(...)`
+ double value = args[0]->IsUndefined() ?
+ 0 : args[0]->NumberValue(context).FromMaybe(0);
+ MyObject* obj = new MyObject(value);
+ obj->Wrap(args.This());
+ args.GetReturnValue().Set(args.This());
+ } else {
+ // Invoked as plain function `MyObject(...)`, turn into construct call.
+ const int argc = 1;
+ Local argv[argc] = { args[0] };
+ Local cons = Local::New(isolate, constructor);
+ Local instance =
+ cons->NewInstance(context, argc, argv).ToLocalChecked();
+ args.GetReturnValue().Set(instance);
+ }
+}
+
+void MyObject::NewInstance(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ const unsigned argc = 1;
+ Local argv[argc] = { args[0] };
+ Local cons = Local::New(isolate, constructor);
+ Local context = isolate->GetCurrentContext();
+ Local instance =
+ cons->NewInstance(context, argc, argv).ToLocalChecked();
+
+ args.GetReturnValue().Set(instance);
+}
+
+void MyObject::PlusOne(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ MyObject* obj = ObjectWrap::Unwrap(args.Holder());
+ obj->value_ += 1;
+
+ args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+}
+
+} // namespace demo
+```
+
+Once again, to build this example, the `myobject.cc` file must be added to the
+`binding.gyp`:
+
+```json
+{
+ "targets": [
+ {
+ "target_name": "addon",
+ "sources": [
+ "addon.cc",
+ "myobject.cc"
+ ]
+ }
+ ]
+}
+```
+
+Test it with:
+
+```js
+// test.js
+const createObject = require('./build/Release/addon');
+
+const obj = createObject(10);
+console.log(obj.plusOne());
+// Prints: 11
+console.log(obj.plusOne());
+// Prints: 12
+console.log(obj.plusOne());
+// Prints: 13
+
+const obj2 = createObject(20);
+console.log(obj2.plusOne());
+// Prints: 21
+console.log(obj2.plusOne());
+// Prints: 22
+console.log(obj2.plusOne());
+// Prints: 23
+```
+
+#### Passing wrapped objects around
+
+In addition to wrapping and returning C++ objects, it is possible to pass
+wrapped objects around by unwrapping them with the Node.js helper function
+`node::ObjectWrap::Unwrap`. The following examples shows a function `add()`
+that can take two `MyObject` objects as input arguments:
+
+```cpp
+// addon.cc
+#include
+#include
+#include "myobject.h"
+
+namespace demo {
+
+using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void CreateObject(const FunctionCallbackInfo& args) {
+ MyObject::NewInstance(args);
+}
+
+void Add(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ MyObject* obj1 = node::ObjectWrap::Unwrap(
+ args[0]->ToObject(context).ToLocalChecked());
+ MyObject* obj2 = node::ObjectWrap::Unwrap(
+ args[1]->ToObject(context).ToLocalChecked());
+
+ double sum = obj1->value() + obj2->value();
+ args.GetReturnValue().Set(Number::New(isolate, sum));
+}
+
+void InitAll(Local exports) {
+ MyObject::Init(exports->GetIsolate());
+
+ NODE_SET_METHOD(exports, "createObject", CreateObject);
+ NODE_SET_METHOD(exports, "add", Add);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+
+} // namespace demo
+```
+
+In `myobject.h`, a new public method is added to allow access to private values
+after unwrapping the object.
+
+```cpp
+// myobject.h
+#ifndef MYOBJECT_H
+#define MYOBJECT_H
+
+#include
+#include
+
+namespace demo {
+
+class MyObject : public node::ObjectWrap {
+ public:
+ static void Init(v8::Isolate* isolate);
+ static void NewInstance(const v8::FunctionCallbackInfo& args);
+ inline double value() const { return value_; }
+
+ private:
+ explicit MyObject(double value = 0);
+ ~MyObject();
+
+ static void New(const v8::FunctionCallbackInfo& args);
+ static v8::Global constructor;
+ double value_;
+};
+
+} // namespace demo
+
+#endif
+```
+
+The implementation of `myobject.cc` is similar to before:
+
+```cpp
+// myobject.cc
+#include
+#include "myobject.h"
+
+namespace demo {
+
+using node::AddEnvironmentCleanupHook;
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Global;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+// Warning! This is not thread-safe, this addon cannot be used for worker
+// threads.
+Global MyObject::constructor;
+
+MyObject::MyObject(double value) : value_(value) {
+}
+
+MyObject::~MyObject() {
+}
+
+void MyObject::Init(Isolate* isolate) {
+ // Prepare constructor template
+ Local tpl = FunctionTemplate::New(isolate, New);
+ tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+ Local context = isolate->GetCurrentContext();
+ constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+
+ AddEnvironmentCleanupHook(isolate, [](void*) {
+ constructor.Reset();
+ }, nullptr);
+}
+
+void MyObject::New(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+ Local context = isolate->GetCurrentContext();
+
+ if (args.IsConstructCall()) {
+ // Invoked as constructor: `new MyObject(...)`
+ double value = args[0]->IsUndefined() ?
+ 0 : args[0]->NumberValue(context).FromMaybe(0);
+ MyObject* obj = new MyObject(value);
+ obj->Wrap(args.This());
+ args.GetReturnValue().Set(args.This());
+ } else {
+ // Invoked as plain function `MyObject(...)`, turn into construct call.
+ const int argc = 1;
+ Local argv[argc] = { args[0] };
+ Local cons = Local::New(isolate, constructor);
+ Local instance =
+ cons->NewInstance(context, argc, argv).ToLocalChecked();
+ args.GetReturnValue().Set(instance);
+ }
+}
+
+void MyObject::NewInstance(const FunctionCallbackInfo& args) {
+ Isolate* isolate = args.GetIsolate();
+
+ const unsigned argc = 1;
+ Local argv[argc] = { args[0] };
+ Local cons = Local::New(isolate, constructor);
+ Local context = isolate->GetCurrentContext();
+ Local instance =
+ cons->NewInstance(context, argc, argv).ToLocalChecked();
+
+ args.GetReturnValue().Set(instance);
+}
+
+} // namespace demo
+```
+
+Test it with:
+
+```js
+// test.js
+const addon = require('./build/Release/addon');
+
+const obj1 = addon.createObject(10);
+const obj2 = addon.createObject(20);
+const result = addon.add(obj1, obj2);
+
+console.log(result);
+// Prints: 30
+```
+
+[Electron]: https://electronjs.org/
+[Embedder's Guide]: https://v8.dev/docs/embed
+[Linking to libraries included with Node.js]: #linking-to-libraries-included-with-nodejs
+[Native Abstractions for Node.js]: https://github.com/nodejs/nan
+[V8]: https://v8.dev/
+[`Worker`]: worker_threads.md#class-worker
+[bindings]: https://github.com/TooTallNate/node-bindings
+[download]: https://github.com/nodejs/node-addon-examples
+[examples]: https://github.com/nodejs/nan/tree/HEAD/examples/
+[implementation considerations]: n-api.md#implications-of-abi-stability
+[installation instructions]: https://github.com/nodejs/node-gyp#installation
+[libuv]: https://github.com/libuv/libuv
+[node-gyp]: https://github.com/nodejs/node-gyp
+[require]: /api/v20/modules#requireid
+[v8-docs]: https://v8docs.nodesource.com/
diff --git a/content/api/v20/assert.en.md b/content/api/v20/assert.en.md
new file mode 100644
index 0000000000..8fd87ed2ad
--- /dev/null
+++ b/content/api/v20/assert.en.md
@@ -0,0 +1,2221 @@
+---
+title: 'assert'
+displayTitle: 'Assert'
+category: 'api'
+version: 'v20'
+---
+
+
+
+Stable
+
+
+
+
+
+Deprecated
+
+
+
+This feature is deprecated and will be removed in a future version.
+Please consider using alternatives such as the
+[`mock`][] helper function.
+
+####
+
+Legacy: Use [`assert.deepStrictEqual()`][] instead.
+
+
+
+Tests for deep equality between the `actual` and `expected` parameters. Consider
+using [`assert.deepStrictEqual()`][] instead. [`assert.deepEqual()`][] can have
+surprising results.
+
+_Deep equality_ means that the enumerable "own" properties of child objects
+are also recursively evaluated by the following rules.
+
+#### Comparison details
+
+* Primitive values are compared with the [`==` operator][],
+ with the exception of `NaN`. It is treated as being identical in case
+ both sides are `NaN`.
+* [Type tags][Object.prototype.toString()] of objects should be the same.
+* Only [enumerable "own" properties][] are considered.
+* [`Error`][] names and messages are always compared, even if these are not
+ enumerable properties.
+* [Object wrappers][] are compared both as objects and unwrapped values.
+* `Object` properties are compared unordered.
+* [`Map`][] keys and [`Set`][] items are compared unordered.
+* Recursion stops when both sides differ or both sides encounter a circular
+ reference.
+* Implementation does not test the [`[[Prototype]]`][prototype-spec] of
+ objects.
+* [`Symbol`][] properties are not compared.
+* [`WeakMap`][] and [`WeakSet`][] comparison does not rely on their values.
+* [`RegExp`][] lastIndex, flags, and source are always compared, even if these
+ are not enumerable properties.
+
+The following example does not throw an [`AssertionError`][] because the
+primitives are compared using the [`==` operator][].
+
+```mjs|cjs
+import assert from 'node:assert';
+// WARNING: This does not throw an AssertionError!
+
+assert.deepEqual('+00000000', false);
+--------------
+const assert = require('node:assert');
+// WARNING: This does not throw an AssertionError!
+
+assert.deepEqual('+00000000', false);
+```
+
+"Deep" equality means that the enumerable "own" properties of child objects
+are evaluated also:
+
+```mjs|cjs
+import assert from 'node:assert';
+
+const obj1 = {
+ a: {
+ b: 1,
+ },
+};
+const obj2 = {
+ a: {
+ b: 2,
+ },
+};
+const obj3 = {
+ a: {
+ b: 1,
+ },
+};
+const obj4 = { __proto__: obj1 };
+
+assert.deepEqual(obj1, obj1);
+// OK
+
+// Values of b are different:
+assert.deepEqual(obj1, obj2);
+// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
+
+assert.deepEqual(obj1, obj3);
+// OK
+
+// Prototypes are ignored:
+assert.deepEqual(obj1, obj4);
+// AssertionError: { a: { b: 1 } } deepEqual {}
+--------------
+const assert = require('node:assert');
+
+const obj1 = {
+ a: {
+ b: 1,
+ },
+};
+const obj2 = {
+ a: {
+ b: 2,
+ },
+};
+const obj3 = {
+ a: {
+ b: 1,
+ },
+};
+const obj4 = { __proto__: obj1 };
+
+assert.deepEqual(obj1, obj1);
+// OK
+
+// Values of b are different:
+assert.deepEqual(obj1, obj2);
+// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
+
+assert.deepEqual(obj1, obj3);
+// OK
+
+// Prototypes are ignored:
+assert.deepEqual(obj1, obj4);
+// AssertionError: { a: { b: 1 } } deepEqual {}
+```
+
+If the values are not equal, an [`AssertionError`][] is thrown with a `message`
+property set equal to the value of the `message` parameter. If the `message`
+parameter is undefined, a default error message is assigned. If the `message`
+parameter is an instance of an [`Error`][] then it will be thrown instead of the
+[`AssertionError`][].
+
+###
+
+Legacy: Use [`assert.strictEqual()`][] instead.
+
+
+
+Tests shallow, coercive equality between the `actual` and `expected` parameters
+using the [`==` operator][]. `NaN` is specially handled
+and treated as being identical if both sides are `NaN`.
+
+```mjs|cjs
+import assert from 'node:assert';
+
+assert.equal(1, 1);
+// OK, 1 == 1
+assert.equal(1, '1');
+// OK, 1 == '1'
+assert.equal(NaN, NaN);
+// OK
+
+assert.equal(1, 2);
+// AssertionError: 1 == 2
+assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
+// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
+--------------
+const assert = require('node:assert');
+
+assert.equal(1, 1);
+// OK, 1 == 1
+assert.equal(1, '1');
+// OK, 1 == '1'
+assert.equal(NaN, NaN);
+// OK
+
+assert.equal(1, 2);
+// AssertionError: 1 == 2
+assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
+// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
+```
+
+If the values are not equal, an [`AssertionError`][] is thrown with a `message`
+property set equal to the value of the `message` parameter. If the `message`
+parameter is undefined, a default error message is assigned. If the `message`
+parameter is an instance of an [`Error`][] then it will be thrown instead of the
+`AssertionError`.
+
+###
+
+Deprecated: Use `assert.fail([message])` or other assert functions instead.
+
+
+
+* `actual` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types)
+* `expected` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types)
+* `message` [`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+* `operator` [`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) **Default:** `'!='`
+* `stackStartFn` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) **Default:** `assert.fail`
+
+If `message` is falsy, the error message is set as the values of `actual` and
+`expected` separated by the provided `operator`. If just the two `actual` and
+`expected` arguments are provided, `operator` will default to `'!='`. If
+`message` is provided as third argument it will be used as the error message and
+the other arguments will be stored as properties on the thrown object. If
+`stackStartFn` is provided, all stack frames above that function will be
+removed from stacktrace (see [`Error.captureStackTrace`][]). If no arguments are
+given, the default message `Failed` will be used.
+
+```mjs|cjs
+import assert from 'node:assert/strict';
+
+assert.fail('a', 'b');
+// AssertionError [ERR_ASSERTION]: 'a' != 'b'
+
+assert.fail(1, 2, undefined, '>');
+// AssertionError [ERR_ASSERTION]: 1 > 2
+
+assert.fail(1, 2, 'fail');
+// AssertionError [ERR_ASSERTION]: fail
+
+assert.fail(1, 2, 'whoops', '>');
+// AssertionError [ERR_ASSERTION]: whoops
+
+assert.fail(1, 2, new TypeError('need array'));
+// TypeError: need array
+--------------
+const assert = require('node:assert/strict');
+
+assert.fail('a', 'b');
+// AssertionError [ERR_ASSERTION]: 'a' != 'b'
+
+assert.fail(1, 2, undefined, '>');
+// AssertionError [ERR_ASSERTION]: 1 > 2
+
+assert.fail(1, 2, 'fail');
+// AssertionError [ERR_ASSERTION]: fail
+
+assert.fail(1, 2, 'whoops', '>');
+// AssertionError [ERR_ASSERTION]: whoops
+
+assert.fail(1, 2, new TypeError('need array'));
+// TypeError: need array
+```
+
+In the last three cases `actual`, `expected`, and `operator` have no
+influence on the error message.
+
+Example use of `stackStartFn` for truncating the exception's stacktrace:
+
+```mjs|cjs
+import assert from 'node:assert/strict';
+
+function suppressFrame() {
+ assert.fail('a', 'b', undefined, '!==', suppressFrame);
+}
+suppressFrame();
+// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
+// at repl:1:1
+// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
+// ...
+--------------
+const assert = require('node:assert/strict');
+
+function suppressFrame() {
+ assert.fail('a', 'b', undefined, '!==', suppressFrame);
+}
+suppressFrame();
+// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
+// at repl:1:1
+// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
+// ...
+```
+
+###
+
+Legacy: Use [`assert.notDeepStrictEqual()`][] instead.
+
+
+
+Tests for any deep inequality. Opposite of [`assert.deepEqual()`][].
+
+```mjs|cjs
+import assert from 'node:assert';
+
+const obj1 = {
+ a: {
+ b: 1,
+ },
+};
+const obj2 = {
+ a: {
+ b: 2,
+ },
+};
+const obj3 = {
+ a: {
+ b: 1,
+ },
+};
+const obj4 = { __proto__: obj1 };
+
+assert.notDeepEqual(obj1, obj1);
+// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+
+assert.notDeepEqual(obj1, obj2);
+// OK
+
+assert.notDeepEqual(obj1, obj3);
+// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+
+assert.notDeepEqual(obj1, obj4);
+// OK
+--------------
+const assert = require('node:assert');
+
+const obj1 = {
+ a: {
+ b: 1,
+ },
+};
+const obj2 = {
+ a: {
+ b: 2,
+ },
+};
+const obj3 = {
+ a: {
+ b: 1,
+ },
+};
+const obj4 = { __proto__: obj1 };
+
+assert.notDeepEqual(obj1, obj1);
+// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+
+assert.notDeepEqual(obj1, obj2);
+// OK
+
+assert.notDeepEqual(obj1, obj3);
+// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+
+assert.notDeepEqual(obj1, obj4);
+// OK
+```
+
+If the values are deeply equal, an [`AssertionError`][] is thrown with a
+`message` property set equal to the value of the `message` parameter. If the
+`message` parameter is undefined, a default error message is assigned. If the
+`message` parameter is an instance of an [`Error`][] then it will be thrown
+instead of the `AssertionError`.
+
+###
+
+Legacy: Use [`assert.notStrictEqual()`][] instead.
+
+
+
+Tests shallow, coercive inequality with the [`!=` operator][]. `NaN` is
+specially handled and treated as being identical if both sides are `NaN`.
+
+```mjs|cjs
+import assert from 'node:assert';
+
+assert.notEqual(1, 2);
+// OK
+
+assert.notEqual(1, 1);
+// AssertionError: 1 != 1
+
+assert.notEqual(1, '1');
+// AssertionError: 1 != '1'
+--------------
+const assert = require('node:assert');
+
+assert.notEqual(1, 2);
+// OK
+
+assert.notEqual(1, 1);
+// AssertionError: 1 != 1
+
+assert.notEqual(1, '1');
+// AssertionError: 1 != '1'
+```
+
+If the values are equal, an [`AssertionError`][] is thrown with a `message`
+property set equal to the value of the `message` parameter. If the `message`
+parameter is undefined, a default error message is assigned. If the `message`
+parameter is an instance of an [`Error`][] then it will be thrown instead of the
+`AssertionError`.
+
+###
+
+Stable
+
+
+
+
+
+Experimental
+
+
+
+* `fn` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) The function to bind to the current execution context.
+* Returns: [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) A new function that calls `fn` within the captured
+ execution context.
+
+Binds the given function to the current execution context.
+
+#### Static method: `AsyncLocalStorage.snapshot()`
+
+
+
+Experimental
+
+
+
+* Returns: [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) A new function with the signature
+ `(fn: (...args) : R, ...args) : R`.
+
+Captures the current execution context and returns a function that accepts a
+function as an argument. Whenever the returned function is called, it
+calls the function passed to it within the captured context.
+
+```js
+const asyncLocalStorage = new AsyncLocalStorage();
+const runInAsyncScope = asyncLocalStorage.run(123, () => AsyncLocalStorage.snapshot());
+const result = asyncLocalStorage.run(321, () => runInAsyncScope(() => asyncLocalStorage.getStore()));
+console.log(result); // returns 123
+```
+
+AsyncLocalStorage.snapshot() can replace the use of AsyncResource for simple
+async context tracking purposes, for example:
+
+```js
+class Foo {
+ #runInAsyncScope = AsyncLocalStorage.snapshot();
+
+ get() { return this.#runInAsyncScope(() => asyncLocalStorage.getStore()); }
+}
+
+const foo = asyncLocalStorage.run(123, () => new Foo());
+console.log(asyncLocalStorage.run(321, () => foo.get())); // returns 123
+```
+
+####
+
+Experimental
+
+
+
+Disables the instance of `AsyncLocalStorage`. All subsequent calls
+to `asyncLocalStorage.getStore()` will return `undefined` until
+`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
+
+When calling `asyncLocalStorage.disable()`, all current contexts linked to the
+instance will be exited.
+
+Calling `asyncLocalStorage.disable()` is required before the
+`asyncLocalStorage` can be garbage collected. This does not apply to stores
+provided by the `asyncLocalStorage`, as those objects are garbage collected
+along with the corresponding async resources.
+
+Use this method when the `asyncLocalStorage` is not in use anymore
+in the current process.
+
+####
+
+Experimental
+
+
+
+* `store` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types)
+
+Transitions into the context for the remainder of the current
+synchronous execution and then persists the store through any following
+asynchronous calls.
+
+Example:
+
+```js
+const store = { id: 1 };
+// Replaces previous store with the given store object
+asyncLocalStorage.enterWith(store);
+asyncLocalStorage.getStore(); // Returns the store object
+someAsyncOperation(() => {
+ asyncLocalStorage.getStore(); // Returns the same object
+});
+```
+
+This transition will continue for the _entire_ synchronous execution.
+This means that if, for example, the context is entered within an event
+handler subsequent event handlers will also run within that context unless
+specifically bound to another context with an `AsyncResource`. That is why
+`run()` should be preferred over `enterWith()` unless there are strong reasons
+to use the latter method.
+
+```js
+const store = { id: 1 };
+
+emitter.on('my-event', () => {
+ asyncLocalStorage.enterWith(store);
+});
+emitter.on('my-event', () => {
+ asyncLocalStorage.getStore(); // Returns the same object
+});
+
+asyncLocalStorage.getStore(); // Returns undefined
+emitter.emit('my-event');
+asyncLocalStorage.getStore(); // Returns the same object
+```
+
+####
+
+Experimental
+
+
+
+* `callback` [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+* `...args` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types)
+
+Runs a function synchronously outside of a context and returns its
+return value. The store is not accessible within the callback function or
+the asynchronous operations created within the callback. Any `getStore()`
+call done within the callback function will always return `undefined`.
+
+The optional `args` are passed to the callback function.
+
+If the callback function throws an error, the error is thrown by `exit()` too.
+The stacktrace is not impacted by this call and the context is re-entered.
+
+Example:
+
+```js
+// Within a call to run
+try {
+ asyncLocalStorage.getStore(); // Returns the store object or value
+ asyncLocalStorage.exit(() => {
+ asyncLocalStorage.getStore(); // Returns undefined
+ throw new Error();
+ });
+} catch (e) {
+ asyncLocalStorage.getStore(); // Returns the same object or value
+ // The error will be caught here
+}
+```
+
+#### Usage with `async/await`
+
+If, within an async function, only one `await` call is to run within a context,
+the following pattern should be used:
+
+```js
+async function fn() {
+ await asyncLocalStorage.run(new Map(), () => {
+ asyncLocalStorage.getStore().set('key', value);
+ return foo(); // The return value of foo will be awaited
+ });
+}
+```
+
+In this example, the store is only available in the callback function and the
+functions called by `foo`. Outside of `run`, calling `getStore` will return
+`undefined`.
+
+#### Troubleshooting: Context loss
+
+In most cases, `AsyncLocalStorage` works without issues. In rare situations, the
+current store is lost in one of the asynchronous operations.
+
+If your code is callback-based, it is enough to promisify it with
+[`util.promisify()`][] so it starts working with native promises.
+
+If you need to use a callback-based API or your code assumes
+a custom thenable implementation, use the [`AsyncResource`][] class
+to associate the asynchronous operation with the correct execution context.
+Find the function call responsible for the context loss by logging the content
+of `asyncLocalStorage.getStore()` after the calls you suspect are responsible
+for the loss. When the code logs `undefined`, the last callback called is
+probably responsible for the context loss.
+
+###
+
+Experimental. Please migrate away from this API, if you can. We do not recommend using the [`createHook`][], [`AsyncHook`][], and [`executionAsyncResource`][] APIs as they have usability issues, safety risks, and performance implications. Async context tracking use cases are better served by the stable [`AsyncLocalStorage`][] API. If you have a use case for `createHook`, `AsyncHook`, or `executionAsyncResource` beyond the context tracking need solved by [`AsyncLocalStorage`][] or diagnostics data currently provided by [Diagnostics Channel][], please open an issue at describing your use case so we can create a more purpose-focused API.
+
+
+
+
+
+Stable
+
+
+
+
+console.log(Buffer.from('fhqwhgads', 'utf16le'));
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from('hello world', 'utf8');
+
+console.log(buf.toString('hex'));
+// Prints: 68656c6c6f20776f726c64
+console.log(buf.toString('base64'));
+// Prints: aGVsbG8gd29ybGQ=
+
+console.log(Buffer.from('fhqwhgads', 'utf8'));
+// Prints:
+console.log(Buffer.from('fhqwhgads', 'utf16le'));
+// Prints:
+```
+
+Node.js buffers accept all case variations of encoding strings that they
+receive. For example, UTF-8 can be specified as `'utf8'`, `'UTF8'`, or `'uTf8'`.
+
+The character encodings currently supported by Node.js are the following:
+
+* `'utf8'` (alias: `'utf-8'`): Multi-byte encoded Unicode characters. Many web
+ pages and other document formats use [UTF-8][]. This is the default character
+ encoding. When decoding a `Buffer` into a string that does not exclusively
+ contain valid UTF-8 data, the Unicode replacement character `U+FFFD` � will be
+ used to represent those errors.
+
+* `'utf16le'` (alias: `'utf-16le'`): Multi-byte encoded Unicode characters.
+ Unlike `'utf8'`, each character in the string will be encoded using either 2
+ or 4 bytes. Node.js only supports the [little-endian][endianness] variant of
+ [UTF-16][].
+
+* `'latin1'`: Latin-1 stands for [ISO-8859-1][]. This character encoding only
+ supports the Unicode characters from `U+0000` to `U+00FF`. Each character is
+ encoded using a single byte. Characters that do not fit into that range are
+ truncated and will be mapped to characters in that range.
+
+Converting a `Buffer` into a string using one of the above is referred to as
+decoding, and converting a string into a `Buffer` is referred to as encoding.
+
+Node.js also supports the following binary-to-text encodings. For
+binary-to-text encodings, the naming convention is reversed: Converting a
+`Buffer` into a string is typically referred to as encoding, and converting a
+string into a `Buffer` as decoding.
+
+* `'base64'`: [Base64][] encoding. When creating a `Buffer` from a string,
+ this encoding will also correctly accept "URL and Filename Safe Alphabet" as
+ specified in [RFC 4648, Section 5][]. Whitespace characters such as spaces,
+ tabs, and new lines contained within the base64-encoded string are ignored.
+
+* `'base64url'`: [base64url][] encoding as specified in
+ [RFC 4648, Section 5][]. When creating a `Buffer` from a string, this
+ encoding will also correctly accept regular base64-encoded strings. When
+ encoding a `Buffer` to a string, this encoding will omit padding.
+
+* `'hex'`: Encode each byte as two hexadecimal characters. Data truncation
+ may occur when decoding strings that do not exclusively consist of an even
+ number of hexadecimal characters. See below for an example.
+
+The following legacy character encodings are also supported:
+
+* `'ascii'`: For 7-bit [ASCII][] data only. When encoding a string into a
+ `Buffer`, this is equivalent to using `'latin1'`. When decoding a `Buffer`
+ into a string, using this encoding will additionally unset the highest bit of
+ each byte before decoding as `'latin1'`.
+ Generally, there should be no reason to use this encoding, as `'utf8'`
+ (or, if the data is known to always be ASCII-only, `'latin1'`) will be a
+ better choice when encoding or decoding ASCII-only text. It is only provided
+ for legacy compatibility.
+
+* `'binary'`: Alias for `'latin1'`.
+ The name of this encoding can be very misleading, as all of the
+ encodings listed here convert between strings and binary data. For converting
+ between strings and `Buffer`s, typically `'utf8'` is the right choice.
+
+* `'ucs2'`, `'ucs-2'`: Aliases of `'utf16le'`. UCS-2 used to refer to a variant
+ of UTF-16 that did not support characters that had code points larger than
+ U+FFFF. In Node.js, these code points are always supported.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+Buffer.from('1ag123', 'hex');
+// Prints , data truncated when first non-hexadecimal value
+// ('g') encountered.
+
+Buffer.from('1a7', 'hex');
+// Prints , data truncated when data ends in single digit ('7').
+
+Buffer.from('1634', 'hex');
+// Prints , all data represented.
+--------------
+const { Buffer } = require('node:buffer');
+
+Buffer.from('1ag123', 'hex');
+// Prints , data truncated when first non-hexadecimal value
+// ('g') encountered.
+
+Buffer.from('1a7', 'hex');
+// Prints , data truncated when data ends in single digit ('7').
+
+Buffer.from('1634', 'hex');
+// Prints , all data represented.
+```
+
+Modern Web browsers follow the [WHATWG Encoding Standard][] which aliases
+both `'latin1'` and `'ISO-8859-1'` to `'win-1252'`. This means that while doing
+something like `http.get()`, if the returned charset is one of those listed in
+the WHATWG specification it is possible that the server actually returned
+`'win-1252'`-encoded data, and using `'latin1'` encoding may incorrectly decode
+the characters.
+
+### Buffers and TypedArrays
+
+
+console.log(buf2);
+// Prints:
+
+arr[1] = 6000;
+
+console.log(buf1);
+// Prints:
+console.log(buf2);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const arr = new Uint16Array(2);
+
+arr[0] = 5000;
+arr[1] = 4000;
+
+// Copies the contents of `arr`.
+const buf1 = Buffer.from(arr);
+
+// Shares memory with `arr`.
+const buf2 = Buffer.from(arr.buffer);
+
+console.log(buf1);
+// Prints:
+console.log(buf2);
+// Prints:
+
+arr[1] = 6000;
+
+console.log(buf1);
+// Prints:
+console.log(buf2);
+// Prints:
+```
+
+When creating a `Buffer` using a [`TypedArray`][]'s `.buffer`, it is
+possible to use only a portion of the underlying [`ArrayBuffer`][] by passing in
+`byteOffset` and `length` parameters.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const arr = new Uint16Array(20);
+const buf = Buffer.from(arr.buffer, 0, 16);
+
+console.log(buf.length);
+// Prints: 16
+--------------
+const { Buffer } = require('node:buffer');
+
+const arr = new Uint16Array(20);
+const buf = Buffer.from(arr.buffer, 0, 16);
+
+console.log(buf.length);
+// Prints: 16
+```
+
+The `Buffer.from()` and [`TypedArray.from()`][] have different signatures and
+implementations. Specifically, the [`TypedArray`][] variants accept a second
+argument that is a mapping function that is invoked on every element of the
+typed array:
+
+* `TypedArray.from(source[, mapFn[, thisArg]])`
+
+The `Buffer.from()` method, however, does not support the use of a mapping
+function:
+
+* [`Buffer.from(array)`][]
+* [`Buffer.from(buffer)`][]
+* [`Buffer.from(arrayBuffer[, byteOffset[, length]])`][`Buffer.from(arrayBuf)`]
+* [`Buffer.from(string[, encoding])`][`Buffer.from(string)`]
+
+### Buffers and iteration
+
+`Buffer` instances can be iterated over using `for..of` syntax:
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.from([1, 2, 3]);
+
+for (const b of buf) {
+ console.log(b);
+}
+// Prints:
+// 1
+// 2
+// 3
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from([1, 2, 3]);
+
+for (const b of buf) {
+ console.log(b);
+}
+// Prints:
+// 1
+// 2
+// 3
+```
+
+Additionally, the [`buf.values()`][], [`buf.keys()`][], and
+[`buf.entries()`][] methods can be used to create iterators.
+
+###
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.alloc(5);
+
+console.log(buf);
+// Prints:
+```
+
+If `size` is larger than
+[`buffer.constants.MAX_LENGTH`][] or smaller than 0, [`ERR_OUT_OF_RANGE`][]
+is thrown.
+
+If `fill` is specified, the allocated `Buffer` will be initialized by calling
+[`buf.fill(fill)`][`buf.fill()`].
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.alloc(5, 'a');
+
+console.log(buf);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.alloc(5, 'a');
+
+console.log(buf);
+// Prints:
+```
+
+If both `fill` and `encoding` are specified, the allocated `Buffer` will be
+initialized by calling [`buf.fill(fill, encoding)`][`buf.fill()`].
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
+
+console.log(buf);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
+
+console.log(buf);
+// Prints:
+```
+
+Calling [`Buffer.alloc()`][] can be measurably slower than the alternative
+[`Buffer.allocUnsafe()`][] but ensures that the newly created `Buffer` instance
+contents will never contain sensitive data from previous allocations, including
+data that might not have been allocated for `Buffer`s.
+
+A `TypeError` will be thrown if `size` is not a number.
+
+#### Static method: `Buffer.allocUnsafe(size)`
+
+
+
+buf.fill(0);
+
+console.log(buf);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(10);
+
+console.log(buf);
+// Prints (contents may vary):
+
+buf.fill(0);
+
+console.log(buf);
+// Prints:
+```
+
+A `TypeError` will be thrown if `size` is not a number.
+
+The `Buffer` module pre-allocates an internal `Buffer` instance of
+size [`Buffer.poolSize`][] that is used as a pool for the fast allocation of new
+`Buffer` instances created using [`Buffer.allocUnsafe()`][], [`Buffer.from(array)`][],
+and [`Buffer.concat()`][] only when `size` is less than or equal to
+`Buffer.poolSize >> 1` (floor of [`Buffer.poolSize`][] divided by two).
+
+Use of this pre-allocated internal memory pool is a key difference between
+calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.
+Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`
+pool, while `Buffer.allocUnsafe(size).fill(fill)` _will_ use the internal
+`Buffer` pool if `size` is less than or equal to half [`Buffer.poolSize`][]. The
+difference is subtle but can be important when an application requires the
+additional performance that [`Buffer.allocUnsafe()`][] provides.
+
+#### Static method: `Buffer.allocUnsafeSlow(size)`
+
+, ]
+// (This result is equal to: [buf2, buf1].)
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from('1234');
+const buf2 = Buffer.from('0123');
+const arr = [buf1, buf2];
+
+console.log(arr.sort(Buffer.compare));
+// Prints: [ , ]
+// (This result is equal to: [buf2, buf1].)
+```
+
+#### Static method: `Buffer.concat(list[, totalLength])`
+
+
+console.log(bufA.length);
+// Prints: 42
+--------------
+const { Buffer } = require('node:buffer');
+
+// Create a single `Buffer` from a list of three `Buffer` instances.
+
+const buf1 = Buffer.alloc(10);
+const buf2 = Buffer.alloc(14);
+const buf3 = Buffer.alloc(18);
+const totalLength = buf1.length + buf2.length + buf3.length;
+
+console.log(totalLength);
+// Prints: 42
+
+const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
+
+console.log(bufA);
+// Prints:
+console.log(bufA.length);
+// Prints: 42
+```
+
+`Buffer.concat()` may also use the internal `Buffer` pool like
+[`Buffer.allocUnsafe()`][] does.
+
+#### Static method: `Buffer.copyBytesFrom(view[, offset[, length]])`
+
+
+
+// Changing the original Uint16Array changes the Buffer also.
+arr[1] = 6000;
+
+console.log(buf);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const arr = new Uint16Array(2);
+
+arr[0] = 5000;
+arr[1] = 4000;
+
+// Shares memory with `arr`.
+const buf = Buffer.from(arr.buffer);
+
+console.log(buf);
+// Prints:
+
+// Changing the original Uint16Array changes the Buffer also.
+arr[1] = 6000;
+
+console.log(buf);
+// Prints:
+```
+
+The optional `byteOffset` and `length` arguments specify a memory range within
+the `arrayBuffer` that will be shared by the `Buffer`.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const ab = new ArrayBuffer(10);
+const buf = Buffer.from(ab, 0, 2);
+
+console.log(buf.length);
+// Prints: 2
+--------------
+const { Buffer } = require('node:buffer');
+
+const ab = new ArrayBuffer(10);
+const buf = Buffer.from(ab, 0, 2);
+
+console.log(buf.length);
+// Prints: 2
+```
+
+A `TypeError` will be thrown if `arrayBuffer` is not an [`ArrayBuffer`][] or a
+[`SharedArrayBuffer`][] or another type appropriate for `Buffer.from()`
+variants.
+
+It is important to remember that a backing `ArrayBuffer` can cover a range
+of memory that extends beyond the bounds of a `TypedArray` view. A new
+`Buffer` created using the `buffer` property of a `TypedArray` may extend
+beyond the range of the `TypedArray`:
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+console.log(arrA.buffer === arrB.buffer); // true
+
+const buf = Buffer.from(arrB.buffer);
+console.log(buf);
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+console.log(arrA.buffer === arrB.buffer); // true
+
+const buf = Buffer.from(arrB.buffer);
+console.log(buf);
+// Prints:
+```
+
+#### Static method: `Buffer.from(buffer)`
+
+
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from(new String('this is a test'));
+// Prints:
+```
+
+For objects that support `Symbol.toPrimitive`, returns
+`Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding)`.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+class Foo {
+ [Symbol.toPrimitive]() {
+ return 'this is a test';
+ }
+}
+
+const buf = Buffer.from(new Foo(), 'utf8');
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+class Foo {
+ [Symbol.toPrimitive]() {
+ return 'this is a test';
+ }
+}
+
+const buf = Buffer.from(new Foo(), 'utf8');
+// Prints:
+```
+
+A `TypeError` will be thrown if `object` does not have the mentioned methods or
+is not of another type appropriate for `Buffer.from()` variants.
+
+#### Static method: `Buffer.from(string[, encoding])`
+
+, , ]
+// (This result is equal to: [buf1, buf3, buf2].)
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from('ABC');
+const buf2 = Buffer.from('BCD');
+const buf3 = Buffer.from('ABCD');
+
+console.log(buf1.compare(buf1));
+// Prints: 0
+console.log(buf1.compare(buf2));
+// Prints: -1
+console.log(buf1.compare(buf3));
+// Prints: -1
+console.log(buf2.compare(buf1));
+// Prints: 1
+console.log(buf2.compare(buf3));
+// Prints: 1
+console.log([buf1, buf2, buf3].sort(Buffer.compare));
+// Prints: [ , , ]
+// (This result is equal to: [buf1, buf3, buf2].)
+```
+
+The optional `targetStart`, `targetEnd`, `sourceStart`, and `sourceEnd`
+arguments can be used to limit the comparison to specific ranges within `target`
+and `buf` respectively.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);
+
+console.log(buf1.compare(buf2, 5, 9, 0, 4));
+// Prints: 0
+console.log(buf1.compare(buf2, 0, 6, 4));
+// Prints: -1
+console.log(buf1.compare(buf2, 5, 6, 5));
+// Prints: 1
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);
+
+console.log(buf1.compare(buf2, 5, 9, 0, 4));
+// Prints: 0
+console.log(buf1.compare(buf2, 0, 6, 4));
+// Prints: -1
+console.log(buf1.compare(buf2, 5, 6, 5));
+// Prints: 1
+```
+
+[`ERR_OUT_OF_RANGE`][] is thrown if `targetStart < 0`, `sourceStart < 0`,
+`targetEnd > target.byteLength`, or `sourceEnd > source.byteLength`.
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+// Fill a `Buffer` with the ASCII character 'h'.
+
+const b = Buffer.allocUnsafe(50).fill('h');
+
+console.log(b.toString());
+// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
+
+// Fill a buffer with empty string
+const c = Buffer.allocUnsafe(5).fill('');
+
+console.log(c.fill(''));
+// Prints:
+```
+
+`value` is coerced to a `uint32` value if it is not a string, `Buffer`, or
+integer. If the resulting integer is greater than `255` (decimal), `buf` will be
+filled with `value & 255`.
+
+If the final write of a `fill()` operation falls on a multi-byte character,
+then only the bytes of that character that fit into `buf` are written:
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+// Fill a `Buffer` with character that takes up two bytes in UTF-8.
+
+console.log(Buffer.allocUnsafe(5).fill('\u0222'));
+// Prints:
+--------------
+const { Buffer } = require('node:buffer');
+
+// Fill a `Buffer` with character that takes up two bytes in UTF-8.
+
+console.log(Buffer.allocUnsafe(5).fill('\u0222'));
+// Prints:
+```
+
+If `value` contains invalid characters, it is truncated; if no valid
+fill data remains, an exception is thrown:
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.allocUnsafe(5);
+
+console.log(buf.fill('a'));
+// Prints:
+console.log(buf.fill('aazz', 'hex'));
+// Prints:
+console.log(buf.fill('zz', 'hex'));
+// Throws an exception.
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(5);
+
+console.log(buf.fill('a'));
+// Prints:
+console.log(buf.fill('aazz', 'hex'));
+// Prints:
+console.log(buf.fill('zz', 'hex'));
+// Throws an exception.
+```
+
+####
+
+Deprecated: Use [`buf.buffer`][] instead.
+
+
+
+The `buf.parent` property is a deprecated alias for `buf.buffer`.
+
+####
+
+Deprecated: Use [`buf.subarray`][] instead.
+
+
+
+Returns a new `Buffer` that references the same memory as the original, but
+offset and cropped by the `start` and `end` indices.
+
+This method is not compatible with the `Uint8Array.prototype.slice()`,
+which is a superclass of `Buffer`. To copy the slice, use
+`Uint8Array.prototype.slice()`.
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.from('buffer');
+
+const copiedBuf = Uint8Array.prototype.slice.call(buf);
+copiedBuf[0]++;
+console.log(copiedBuf.toString());
+// Prints: cuffer
+
+console.log(buf.toString());
+// Prints: buffer
+
+// With buf.slice(), the original buffer is modified.
+const notReallyCopiedBuf = buf.slice();
+notReallyCopiedBuf[0]++;
+console.log(notReallyCopiedBuf.toString());
+// Prints: cuffer
+console.log(buf.toString());
+// Also prints: cuffer (!)
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from('buffer');
+
+const copiedBuf = Uint8Array.prototype.slice.call(buf);
+copiedBuf[0]++;
+console.log(copiedBuf.toString());
+// Prints: cuffer
+
+console.log(buf.toString());
+// Prints: buffer
+
+// With buf.slice(), the original buffer is modified.
+const notReallyCopiedBuf = buf.slice();
+notReallyCopiedBuf[0]++;
+console.log(notReallyCopiedBuf.toString());
+// Prints: cuffer
+console.log(buf.toString());
+// Also prints: cuffer (!)
+```
+
+####
+
+buf1.swap16();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap16();
+// Throws ERR_INVALID_BUFFER_SIZE.
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+
+console.log(buf1);
+// Prints:
+
+buf1.swap16();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap16();
+// Throws ERR_INVALID_BUFFER_SIZE.
+```
+
+One convenient use of `buf.swap16()` is to perform a fast in-place conversion
+between UTF-16 little-endian and UTF-16 big-endian:
+
+```mjs|cjs
+import { Buffer } from 'node:buffer';
+
+const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
+buf.swap16(); // Convert to big-endian UTF-16 text.
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
+buf.swap16(); // Convert to big-endian UTF-16 text.
+```
+
+####
+
+buf1.swap32();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap32();
+// Throws ERR_INVALID_BUFFER_SIZE.
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+
+console.log(buf1);
+// Prints:
+
+buf1.swap32();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap32();
+// Throws ERR_INVALID_BUFFER_SIZE.
+```
+
+####
+
+buf1.swap64();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap64();
+// Throws ERR_INVALID_BUFFER_SIZE.
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+
+console.log(buf1);
+// Prints:
+
+buf1.swap64();
+
+console.log(buf1);
+// Prints:
+
+const buf2 = Buffer.from([0x1, 0x2, 0x3]);
+
+buf2.swap64();
+// Throws ERR_INVALID_BUFFER_SIZE.
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
+const json = JSON.stringify(buf);
+
+console.log(json);
+// Prints: {"type":"Buffer","data":[1,2,3,4,5]}
+
+const copy = JSON.parse(json, (key, value) => {
+ return value && value.type === 'Buffer' ?
+ Buffer.from(value) :
+ value;
+});
+
+console.log(copy);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeBigInt64BE(0x0102030405060708n, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeBigInt64LE(0x0102030405060708n, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeBigUInt64LE(0xdecafafecacefaden, 0);
+
+console.log(buf);
+// Prints:
+```
+
+This function is also available under the `writeBigUint64LE` alias.
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeDoubleBE(123.456, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(8);
+
+buf.writeDoubleLE(123.456, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeFloatBE(0xcafebabe, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeFloatLE(0xcafebabe, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(2);
+
+buf.writeInt8(2, 0);
+buf.writeInt8(-2, 1);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(2);
+
+buf.writeInt16BE(0x0102, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(2);
+
+buf.writeInt16LE(0x0304, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeInt32BE(0x01020304, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeInt32LE(0x05060708, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(6);
+
+buf.writeIntBE(0x1234567890ab, 0, 6);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(6);
+
+buf.writeIntLE(0x1234567890ab, 0, 6);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeUInt8(0x3, 0);
+buf.writeUInt8(0x4, 1);
+buf.writeUInt8(0x23, 2);
+buf.writeUInt8(0x42, 3);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeUInt16BE(0xdead, 0);
+buf.writeUInt16BE(0xbeef, 2);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeUInt16LE(0xdead, 0);
+buf.writeUInt16LE(0xbeef, 2);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeUInt32BE(0xfeedface, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(4);
+
+buf.writeUInt32LE(0xfeedface, 0);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(6);
+
+buf.writeUIntBE(0x1234567890ab, 0, 6);
+
+console.log(buf);
+// Prints:
+```
+
+####
+--------------
+const { Buffer } = require('node:buffer');
+
+const buf = Buffer.allocUnsafe(6);
+
+buf.writeUIntLE(0x1234567890ab, 0, 6);
+
+console.log(buf);
+// Prints:
+```
+
+####
+
+Deprecated: Use [`Buffer.from(array)`][] instead.
+
+
+
+* `array` integer\[] An array of bytes to copy from.
+
+See [`Buffer.from(array)`][].
+
+####
+
+Deprecated: Use [`Buffer.from(arrayBuffer[, byteOffset[, length]])`][`Buffer.from(arrayBuf)`] instead.
+
+
+
+* `arrayBuffer` [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) | [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) An [`ArrayBuffer`][],
+ [`SharedArrayBuffer`][] or the `.buffer` property of a [`TypedArray`][].
+* `byteOffset` [`integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) Index of first byte to expose. **Default:** `0`.
+* `length` [`integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) Number of bytes to expose.
+ **Default:** `arrayBuffer.byteLength - byteOffset`.
+
+See
+[`Buffer.from(arrayBuffer[, byteOffset[, length]])`][`Buffer.from(arrayBuf)`].
+
+####
+
+Deprecated: Use [`Buffer.from(buffer)`][] instead.
+
+
+
+* `buffer` [`Buffer`](/api/v20/buffer#buffer) | [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) An existing `Buffer` or [`Uint8Array`][] from
+ which to copy data.
+
+See [`Buffer.from(buffer)`][].
+
+####
+
+Deprecated: Use [`Buffer.alloc()`][] instead (also see [`Buffer.allocUnsafe()`][]).
+
+
+
+* `size` [`integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The desired length of the new `Buffer`.
+
+See [`Buffer.alloc()`][] and [`Buffer.allocUnsafe()`][]. This variant of the
+constructor is equivalent to [`Buffer.alloc()`][].
+
+####
+
+Deprecated: Use [`Buffer.from(string[, encoding])`][`Buffer.from(string)`] instead.
+
+
+
+* `string` [`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) String to encode.
+* `encoding` [`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The encoding of `string`. **Default:** `'utf8'`.
+
+See [`Buffer.from(string[, encoding])`][`Buffer.from(string)`].
+
+###
+
+Legacy. Use `Buffer.from(data, 'base64')` instead.
+
+
+
+* `data` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types) The Base64-encoded input string.
+
+Decodes a string of Base64-encoded data into bytes, and encodes those bytes
+into a string using Latin-1 (ISO-8859-1).
+
+The `data` may be any JavaScript-value that can be coerced into a string.
+
+**This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using `Buffer.from(str, 'base64')` and
+`buf.toString('base64')`.**
+
+####
+
+Legacy. Use `buf.toString('base64')` instead.
+
+
+
+* `data` [`any`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types) An ASCII (Latin1) string.
+
+Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
+into a string using Base64.
+
+The `data` may be any JavaScript-value that can be coerced into a string.
+
+**This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using `Buffer.from(str, 'base64')` and
+`buf.toString('base64')`.**
+
+####
+
+Experimental
+
+
+
+* `id` [`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) A `'blob:nodedata:...` URL string returned by a prior call to
+ `URL.createObjectURL()`.
+* Returns: [`Blob`](/api/v20/buffer#blob)
+
+Resolves a `'blob:nodedata:...'` an associated [`Blob`](/api/v20/buffer#blob) object registered using
+a prior call to `URL.createObjectURL()`.
+
+####
+
+Deprecated: Use [`Buffer.allocUnsafeSlow()`][] instead.
+
+
+
+See [`Buffer.allocUnsafeSlow()`][]. This was never a class in the sense that
+the constructor always returned a `Buffer` instance, rather than a `SlowBuffer`
+instance.
+
+#####
+
+Deprecated: Use [`Buffer.allocUnsafeSlow()`][] instead.
+
+
+
+* `size` [`integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The desired length of the new `SlowBuffer`.
+
+See [`Buffer.allocUnsafeSlow()`][].
+
+#### Buffer constants
+
+32 on 64-bit architectures."},{"version":"v14.0.0","pr-url":"https://github.com/nodejs/node/pull/32116","description":"Value is changed from 2