chore(api): sync auto-generated docs

Author: ovflowd

content/api/v16/assert.en.md

@@ -26,11 +26,9 @@ in other languages.
 The `AsyncLocalStorage` and `AsyncResource` classes are part of the
 `node:async_hooks` module:
 
-```mjs
+```mjs|cjs
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
-```
-
-```cjs
+--------------
 const { AsyncLocalStorage, AsyncResource } = require('node:async_hooks');
 ```
 
@@ -49,7 +47,7 @@ The following example uses `AsyncLocalStorage` to build a simple logger
 that assigns IDs to incoming HTTP requests and includes them in messages
 logged within each request.
 
-```mjs
+```mjs|cjs
 import http from 'node:http';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
@@ -79,9 +77,7 @@ http.get('http://localhost:8080');
 //   1: start
 //   0: finish
 //   1: finish
-```
-
-```cjs
+--------------
 const http = require('node:http');
 const { AsyncLocalStorage } = require('node:async_hooks');
 
@@ -331,7 +327,7 @@ The `init` hook will trigger when an `AsyncResource` is instantiated.
 
 The following is an overview of the `AsyncResource` API.
 
-```mjs
+```mjs|cjs
 import { AsyncResource, executionAsyncId } from 'node:async_hooks';
 
 // AsyncResource() is meant to be extended. Instantiating a
@@ -357,9 +353,7 @@ asyncResource.asyncId();
 
 // Return the trigger ID for the AsyncResource instance.
 asyncResource.triggerAsyncId();
-```
-
-```cjs
+--------------
 const { AsyncResource, executionAsyncId } = require('node:async_hooks');
 
 // AsyncResource() is meant to be extended. Instantiating a
@@ -492,14 +486,12 @@ database connection pools, can follow a similar model.
 Assuming that the task is adding two numbers, using a file named
 `task_processor.js` with the following content:
 
-```mjs
+```mjs|cjs
 import { parentPort } from 'node:worker_threads';
 parentPort.on('message', (task) => {
   parentPort.postMessage(task.a + task.b);
 });
-```
-
-```cjs
+--------------
 const { parentPort } = require('node:worker_threads');
 parentPort.on('message', (task) => {
   parentPort.postMessage(task.a + task.b);
@@ -508,7 +500,7 @@ parentPort.on('message', (task) => {
 
 a Worker pool around it could use the following structure:
 
-```mjs
+```mjs|cjs
 import { AsyncResource } from 'node:async_hooks';
 import { EventEmitter } from 'node:events';
 import path from 'node:path';
@@ -594,9 +586,7 @@ export default class WorkerPool extends EventEmitter {
     for (const worker of this.workers) worker.terminate();
   }
 }
-```
-
-```cjs
+--------------
 const { AsyncResource } = require('node:async_hooks');
 const { EventEmitter } = require('node:events');
 const path = require('node:path');
@@ -694,7 +684,7 @@ were scheduled.
 
 This pool could be used as follows:
 
-```mjs
+```mjs|cjs
 import WorkerPool from './worker_pool.js';
 import os from 'node:os';
 
@@ -708,9 +698,7 @@ for (let i = 0; i < 10; i++) {
       pool.close();
   });
 }
-```
-
-```cjs
+--------------
 const WorkerPool = require('./worker_pool.js');
 const os = require('node:os');
 
@@ -736,7 +724,7 @@ The following example shows how to use the `AsyncResource` class to properly
 associate an event listener with the correct execution context. The same
 approach can be applied to a [`Stream`][] or a similar event-driven class.
 
-```mjs
+```mjs|cjs
 import { createServer } from 'node:http';
 import { AsyncResource, executionAsyncId } from 'node:async_hooks';
 
@@ -749,9 +737,7 @@ const server = createServer((req, res) => {
   });
   res.end();
 }).listen(3000);
-```
-
-```cjs
+--------------
 const { createServer } = require('node:http');
 const { AsyncResource, executionAsyncId } = require('node:async_hooks');
 

content/api/v16/async_context.en.md

@@ -18,11 +18,9 @@ Experimental
 The `node:async_hooks` module provides an API to track asynchronous resources.
 It can be accessed using:
 
-```mjs
+```mjs|cjs
 import async_hooks from 'node:async_hooks';
-```
-
-```cjs
+--------------
 const async_hooks = require('node:async_hooks');
 ```
 
@@ -42,7 +40,7 @@ interface, and each thread will use a new set of async IDs.
 
 Following is a simple overview of the public API.
 
-```mjs
+```mjs|cjs
 import async_hooks from 'node:async_hooks';
 
 // Return the ID of the current execution context.
@@ -88,9 +86,7 @@ function destroy(asyncId) { }
 // resolve() function passed to the Promise constructor is invoked
 // (either directly or through other means of resolving a promise).
 function promiseResolve(asyncId) { }
-```
-
-```cjs
+--------------
 const async_hooks = require('node:async_hooks');
 
 // Return the ID of the current execution context.
@@ -161,16 +157,14 @@ be tracked, then only the `destroy` callback needs to be passed. The
 specifics of all functions that can be passed to `callbacks` is in the
 [Hook Callbacks][] section.
 
-```mjs
+```mjs|cjs
 import { createHook } from 'node:async_hooks';
 
 const asyncHook = createHook({
   init(asyncId, type, triggerAsyncId, resource) { },
   destroy(asyncId) { }
 });
-```
-
-```cjs
+--------------
 const async_hooks = require('node:async_hooks');
 
 const asyncHook = async_hooks.createHook({
@@ -226,17 +220,15 @@ synchronous logging operation such as `fs.writeFileSync(file, msg, flag)`.
 This will print to the file and will not invoke `AsyncHook` recursively because
 it is synchronous.
 
-```mjs
+```mjs|cjs
 import { writeFileSync } from 'node:fs';
 import { format } from 'node:util';
 
 function debug(...args) {
   // Use a function like this one when debugging inside an AsyncHook callback
   writeFileSync('log.out', `${format(...args)}\n`, { flag: 'a' });
 }
-```
-
-```cjs
+--------------
 const fs = require('node:fs');
 const util = require('node:util');
 
@@ -267,13 +259,11 @@ provided, enabling is a no-op.
 The `AsyncHook` instance is disabled by default. If the `AsyncHook` instance
 should be enabled immediately after creation, the following pattern can be used.
 
-```mjs
+```mjs|cjs
 import { createHook } from 'node:async_hooks';
 
 const hook = createHook(callbacks).enable();
-```
-
-```cjs
+--------------
 const async_hooks = require('node:async_hooks');
 
 const hook = async_hooks.createHook(callbacks).enable();
@@ -313,15 +303,13 @@ This behavior can be observed by doing something like opening a resource then
 closing it before the resource can be used. The following snippet demonstrates
 this.
 
-```mjs
+```mjs|cjs
 import { createServer } from 'node:net';
 
 createServer().listen(function() { this.close(); });
 // OR
 clearTimeout(setTimeout(() => {}, 10));
-```
-
-```cjs
+--------------
 require('node:net').createServer().listen(function() { this.close(); });
 // OR
 clearTimeout(setTimeout(() => {}, 10));
@@ -367,7 +355,7 @@ created, while `triggerAsyncId` shows _why_ a resource was created.
 
 The following is a simple demonstration of `triggerAsyncId`:
 
-```mjs
+```mjs|cjs
 import { createHook, executionAsyncId } from 'node:async_hooks';
 import { stdout } from 'node:process';
 import net from 'node:net';
@@ -382,9 +370,7 @@ createHook({
 }).enable();
 
 net.createServer((conn) => {}).listen(8080);
-```
-
-```cjs
+--------------
 const { createHook, executionAsyncId } = require('node:async_hooks');
 const { stdout } = require('node:process');
 const net = require('node:net');
@@ -619,17 +605,15 @@ Using `executionAsyncResource()` in the top-level execution context will
 return an empty object as there is no handle or request object to use,
 but having an object representing the top-level can be helpful.
 
-```mjs
+```mjs|cjs
 import { open } from 'node:fs';
 import { executionAsyncId, executionAsyncResource } from 'node:async_hooks';
 
 console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
 open(new URL(import.meta.url), 'r', (err, fd) => {
   console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
 });
-```
-
-```cjs
+--------------
 const { open } = require('node:fs');
 const { executionAsyncId, executionAsyncResource } = require('node:async_hooks');
 
@@ -642,7 +626,7 @@ open(__filename, 'r', (err, fd) => {
 This can be used to implement continuation local storage without the
 use of a tracking `Map` to store the metadata:
 
-```mjs
+```mjs|cjs
 import { createServer } from 'node:http';
 import {
   executionAsyncId,
@@ -666,9 +650,7 @@ const server = createServer((req, res) => {
     res.end(JSON.stringify(executionAsyncResource()[sym]));
   }, 100);
 }).listen(3000);
-```
-
-```cjs
+--------------
 const { createServer } = require('node:http');
 const {
   executionAsyncId,
@@ -701,16 +683,14 @@ const server = createServer((req, res) => {
 * Returns: [`number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The `asyncId` of the current execution context. Useful to
   track when something calls.
 
-```mjs
+```mjs|cjs
 import { executionAsyncId } from 'node:async_hooks';
 
 console.log(executionAsyncId());  // 1 - bootstrap
 fs.open(path, 'r', (err, fd) => {
   console.log(executionAsyncId());  // 6 - open()
 });
-```
-
-```cjs
+--------------
 const async_hooks = require('node:async_hooks');
 
 console.log(async_hooks.executionAsyncId());  // 1 - bootstrap
@@ -778,17 +758,15 @@ expensive nature of the [promise introspection API][PromiseHooks] provided by
 V8. This means that programs using promises or `async`/`await` will not get
 correct execution and trigger ids for promise callback contexts by default.
 
-```mjs
+```mjs|cjs
 import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';
 
 Promise.resolve(1729).then(() => {
   console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
 });
 // produces:
 // eid 1 tid 0
-```
-
-```cjs
+--------------
 const { executionAsyncId, triggerAsyncId } = require('node:async_hooks');
 
 Promise.resolve(1729).then(() => {
@@ -806,17 +784,15 @@ the resource that caused (triggered) the `then()` callback to be executed.
 Installing async hooks via `async_hooks.createHook` enables promise execution
 tracking:
 
-```mjs
+```mjs|cjs
 import { createHook, executionAsyncId, triggerAsyncId } from 'node:async_hooks';
 createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.
 Promise.resolve(1729).then(() => {
   console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
 });
 // produces:
 // eid 7 tid 6
-```
-
-```cjs
+--------------
 const { createHook, executionAsyncId, triggerAsyncId } = require('node:async_hooks');
 
 createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.