feat: 14.6.0

addons/callbacks.md

@@ -13,7 +13,6 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Null;
 using v8::Object;
 using v8::String;
@@ -26,8 +25,7 @@ void RunCallback(const FunctionCallbackInfo<Value>& args) {
   const unsigned argc = 1;
   Local<Value> argv[argc] = {
       String::NewFromUtf8(isolate,
-                          "hello world",
-                          NewStringType::kNormal).ToLocalChecked() };
+                          "hello world").ToLocalChecked() };
   cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
 }
 

addons/context_aware_addons.md

@@ -91,8 +91,7 @@ NODE_MODULE_INIT(/* exports, module, context */) {
   // 把 `Method` 方法暴露给 JavaScript，
   // 并确保其接收我们通过把 `external` 作为 `FunctionTemplate` 构造函数第三个参数时创建的每个插件实例的数据。
   exports->Set(context,
-               String::NewFromUtf8(isolate, "method", NewStringType::kNormal)
-                  .ToLocalChecked(),
+               String::NewFromUtf8(isolate, "method").ToLocalChecked(),
                FunctionTemplate::New(isolate, Method, external)
                   ->GetFunction(context).ToLocalChecked()).FromJust();
 }

addons/factory_of_wrapped_objects.md

@@ -88,7 +88,6 @@ using v8::FunctionTemplate;
 using v8::Global;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::String;
@@ -106,8 +105,7 @@ MyObject::~MyObject() {
 void MyObject::Init(Isolate* isolate) {
   // 准备构造函数模版
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // 原型

addons/function_arguments.md

@@ -14,7 +14,6 @@ using v8::Exception;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::String;
@@ -29,18 +28,16 @@ void Add(const FunctionCallbackInfo<Value>& args) {
   if (args.Length() < 2) {
     // 抛出一个错误并传回到 JavaScript。
     isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate, 
-	                    "参数的数量错误",
-                            NewStringType::kNormal).ToLocalChecked()));
+        String::NewFromUtf8(isolate,
+                            "参数的数量错误").ToLocalChecked()));
     return;
   }
 
   // 检查参数的类型。
   if (!args[0]->IsNumber() || !args[1]->IsNumber()) {
     isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate, 
-	                    "参数错误",
-                            NewStringType::kNormal).ToLocalChecked()));
+        String::NewFromUtf8(isolate,
+                            "参数错误").ToLocalChecked()));
     return;
   }
 

addons/function_factory.md

@@ -13,15 +13,14 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
 
 void MyFunction(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, "hello world", NewStringType::kNormal).ToLocalChecked());
+      isolate, "hello world").ToLocalChecked());
 }
 
 void CreateFunction(const FunctionCallbackInfo<Value>& args) {
@@ -33,7 +32,7 @@ void CreateFunction(const FunctionCallbackInfo<Value>& args) {
 
   // 可以省略这步使它匿名
   fn->SetName(String::NewFromUtf8(
-      isolate, "theFunction", NewStringType::kNormal).ToLocalChecked());
+      isolate, "theFunction").ToLocalChecked());
 
   args.GetReturnValue().Set(fn);
 }

addons/hello_world.md

@@ -16,15 +16,14 @@ namespace demo {
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
 
 void Method(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, "world", NewStringType::kNormal).ToLocalChecked());
+      isolate, "world").ToLocalChecked());
 }
 
 void Initialize(Local<Object> exports) {

addons/object_factory.md

@@ -12,7 +12,6 @@ using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -24,8 +23,7 @@ void CreateObject(const FunctionCallbackInfo<Value>& args) {
   Local<Object> obj = Object::New(isolate);
   obj->Set(context,
            String::NewFromUtf8(isolate,
-                               "msg",
-                               NewStringType::kNormal).ToLocalChecked(),
+                               "msg").ToLocalChecked(),
                                args[0]->ToString(context).ToLocalChecked())
            .FromJust();
 

addons/passing_wrapped_objects_around.md

@@ -97,7 +97,6 @@ using v8::FunctionTemplate;
 using v8::Global;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -114,8 +113,7 @@ MyObject::~MyObject() {
 void MyObject::Init(Isolate* isolate) {
   // Prepare constructor template
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   Local<Context> context = isolate->GetCurrentContext();

addons/wrapping_c_objects.md

@@ -67,7 +67,6 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
@@ -91,8 +90,7 @@ void MyObject::Init(Local<Object> exports) {
 
   // 准备构造函数模版
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // 原型
@@ -101,8 +99,8 @@ void MyObject::Init(Local<Object> exports) {
   Local<Function> constructor = tpl->GetFunction(context).ToLocalChecked();
   addon_data->SetInternalField(0, constructor);
   exports->Set(context, String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked(),
-               constructor).FromJust();
+      isolate, "MyObject").ToLocalChecked(),
+      constructor).FromJust();
 }
 
 void MyObject::New(const FunctionCallbackInfo<Value>& args) {

assert/assert.md

@@ -3,5 +3,7 @@
 
 > 稳定性: 2 - 稳定
 
+<!-- source_link=lib/assert.js -->
+
 `assert` 模块提供了一组断言函数，用于验证不变量。
 

async_hooks/async_hooks.md

@@ -3,6 +3,8 @@
 
 > Stability: 1 - Experimental
 
+<!-- source_link=lib/async_hooks.js -->
+
 The `async_hooks` module provides an API to track asynchronous resources. It
 can be accessed using:
 

async_hooks/asynchronous_context_example.md

@@ -17,20 +17,17 @@ async_hooks.createHook({
   },
   before(asyncId) {
     const indentStr = ' '.repeat(indent);
-    fs.writeFileSync('log.out',
-                     `${indentStr}before:  ${asyncId}\n`, { flag: 'a' });
+    fs.writeSync(process.stdout.fd, `${indentStr}before:  ${asyncId}\n`);
     indent += 2;
   },
   after(asyncId) {
     indent -= 2;
     const indentStr = ' '.repeat(indent);
-    fs.writeFileSync('log.out',
-                     `${indentStr}after:  ${asyncId}\n`, { flag: 'a' });
+    fs.writeSync(process.stdout.fd, `${indentStr}after:  ${asyncId}\n`);
   },
   destroy(asyncId) {
     const indentStr = ' '.repeat(indent);
-    fs.writeFileSync('log.out',
-                     `${indentStr}destroy:  ${asyncId}\n`, { flag: 'a' });
+    fs.writeSync(process.stdout.fd, `${indentStr}destroy:  ${asyncId}\n`);
   },
 }).enable();
 
@@ -66,14 +63,36 @@ the value of the current execution context; which is delineated by calls to
 Only using `execution` to graph resource allocation results in the following:
 
 ```console
-Timeout(7) -> TickObject(6) -> root(1)
+  root(1)
+     ^
+     |
+TickObject(6)
+     ^
+     |
+ Timeout(7)
 ```
 
 The `TCPSERVERWRAP` is not part of this graph, even though it was the reason for
 `console.log()` being called. This is because binding to a port without a host
 name is a *synchronous* operation, but to maintain a completely asynchronous
-API the user's callback is placed in a `process.nextTick()`.
+API the user's callback is placed in a `process.nextTick()`. Which is why
+`TickObject` is present in the output and is a 'parent' for `.listen()`
+callback.
 
 The graph only shows *when* a resource was created, not *why*, so to track
-the *why* use `triggerAsyncId`.
+the *why* use `triggerAsyncId`. Which can be represented with the following
+graph:
+
+```console
+ bootstrap(1)
+     |
+     ˅
+TCPSERVERWRAP(5)
+     |
+     ˅
+ TickObject(6)
+     |
+     ˅
+  Timeout(7)
+```
 

async_hooks/resource.md

@@ -4,7 +4,7 @@ been initialized. This can contain useful information that can vary based on
 the value of `type`. For instance, for the `GETADDRINFOREQWRAP` resource type,
 `resource` provides the host name used when looking up the IP address for the
 host in `net.Server.listen()`. The API for accessing this information is
-currently not considered public, but using the Embedder API, users can provide
+not supported, but using the Embedder API, users can provide
 and document their own resource objects. For example, such a resource object
 could contain the SQL query being executed.
 

buffer/buf_byteoffset.md

@@ -1,9 +1,9 @@
 
-* {integer} 创建 `Buffer` 对象时基于的底层 `ArrayBuffer` 对象的 `byteOffset`。
+* {integer} `Buffer` 底层的 `ArrayBuffer` 对象的 `byteOffset`。
 
-当 `Buffer.from(ArrayBuffer, byteOffset, length)` 设置了 `byteOffset` 或创建一个小于 `Buffer.poolSize` 的 buffer 时，底层的 `ArrayBuffer` 的偏移量并不是从 0 开始。
+当 `Buffer.from(ArrayBuffer, byteOffset, length)` 设置了 `byteOffset` 或创建一个小于 `Buffer.poolSize` 的 `Buffer` 时，底层的 `ArrayBuffer` 的偏移量并不是从 0 开始。
 
-当直接使用 `buf.buffer` 访问底层的 `ArrayBuffer` 时可能会导致问题，因为 `ArrayBuffer` 的其他部分可能并不指向 `buf` 对象。
+当直接使用 `buf.buffer` 访问底层的 `ArrayBuffer` 时可能会导致问题，因为 `ArrayBuffer` 的其他部分可能并不指向 `Buffer` 对象。
 
 当创建与 `Buffer` 共享其内存的 `TypedArray` 对象时，需要正确地指定 `byteOffset`。
 

buffer/buf_index.md

@@ -9,7 +9,7 @@ name: [index]
 该值指向单个字节，所以有效的值的范围是 `0x00` 至 `0xFF`（十六进制）、或 `0` 至 `255`（十进制）。
 
 该操作符继承自 `Uint8Array`，所以对越界访问的行为与 `Uint8Array` 相同。
-也就是说，当 `index` 为负数或 `>= buf.length` 时，则 `buf[index]` 返回 `undefined`，而如果 `index` 为负数或 `>= buf.length` 时，则 `buf[index] = value` 不会修改该 buffer。
+也就是说，当 `index` 为负数或大于或等于 `buf.length` 时，则 `buf[index]` 返回 `undefined`，而如果 `index` 为负数或 `>= buf.length` 时，则 `buf[index] = value` 不会修改该 buffer。
 
 ```js
 // 拷贝 ASCII 字符串到 `Buffer`，每次拷贝一个字节。

buffer/buf_readbigint64be_offset.md

@@ -0,0 +1,13 @@
+<!-- YAML
+added:
+ - v12.0.0
+ - v10.20.0
+-->
+
+* `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
+* 返回: {bigint}
+
+从 `buf` 中指定的 `offset` 读取一个有符号大端序的 64 位整数值。
+
+从 `Buffer` 中读取的整数值会被解析为二进制补码值。
+

buffer/buf_readbigint64le_offset.md

@@ -7,7 +7,7 @@ added:
 * `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
 * 返回: {bigint}
 
-用指定的[字节序][endianness]（`readBigInt64BE()` 读取为大端序，`readBigInt64LE()` 读取为小端序）从 `buf` 中指定的 `offset` 读取一个有符号的 64 位整数值。
+从 `buf` 中指定的 `offset` 读取一个有符号小端序的 64 位整数值。
 
 从 `Buffer` 中读取的整数值会被解析为二进制补码值。
 

buffer/buf_readbiguint64be_offset.md

@@ -0,0 +1,18 @@
+<!-- YAML
+added:
+ - v12.0.0
+ - v10.20.0
+-->
+
+* `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
+* 返回: {bigint}
+
+从 `buf` 中指定的 `offset` 读取一个无符号大端序的 64 位整数值。
+
+```js
+const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
+
+console.log(buf.readBigUInt64BE(0));
+// 打印: 4294967295n
+```
+

buffer/buf_readbiguint64le_offset.md

@@ -7,14 +7,11 @@ added:
 * `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
 * 返回: {bigint}
 
-用指定的[字节序][endianness]（`readBigUInt64BE()` 读取为大端序，`readBigUInt64LE()` 读取为小端序）从 `buf` 中指定的 `offset` 读取一个无符号的 64 位整数值。
+从 `buf` 中指定的 `offset` 读取一个无符号小端序的 64 位整数值。
 
 ```js
 const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
 
-console.log(buf.readBigUInt64BE(0));
-// 打印: 4294967295n
-
 console.log(buf.readBigUInt64LE(0));
 // 打印: 18446744069414584320n
 ```

buffer/buf_readdoublebe_offset.md

@@ -0,0 +1,21 @@
+<!-- YAML
+added: v0.11.15
+changes:
+  - version: v10.0.0
+    pr-url: https://github.com/nodejs/node/pull/18395
+    description: Removed `noAssert` and no implicit coercion of the offset
+                 to `uint32` anymore.
+-->
+
+* `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
+* 返回: {number}
+
+从 `buf` 中指定的 `offset` 读取一个 64 位的大端序双精度值。
+
+```js
+const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+
+console.log(buf.readDoubleBE(0));
+// 打印: 8.20788039913184e-304
+```
+

buffer/buf_readdoublele_offset.md

@@ -10,13 +10,11 @@ changes:
 * `offset` {integer} 开始读取之前要跳过的字节数。必须满足：`0 <= offset <= buf.length - 8`。**默认值:** `0`。
 * 返回: {number}
 
-用指定的[字节序][endianness]（`readDoubleBE()` 读取为大端序，`readDoubleLE()` 读取为小端序）从 `buf` 中指定的 `offset` 读取一个 64 位双精度值。
+从 `buf` 中指定的 `offset` 读取一个 64 位的小端序双精度值。
 
 ```js
 const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
-console.log(buf.readDoubleBE(0));
-// 打印: 8.20788039913184e-304
 console.log(buf.readDoubleLE(0));
 // 打印: 5.447603722011605e-270
 console.log(buf.readDoubleLE(1));