node_modules/multicodec/src/index.js

@@ -11,116 +11,155 @@
  */
 'use strict'
 
-const varint = require('varint')
-const intTable = require('./int-table')
-const codecNameToCodeVarint = require('./varint-table')
-const util = require('./util')
+// 引入 'varint' 模块，可能用于处理可变长度整数（Variable-length Integer）的编码和解码等相关操作
+const varint = require('varint');
+// 引入自定义的 'int-table' 模块，推测其中包含了整数与某种编码相关名称的映射关系等数据结构，用于查找对应信息
+const intTable = require('./int-table');
+// 引入自定义的 'varint-table' 模块，可能是用于将编码名称转换为对应的可变长度整数编码（varint）表示的映射表
+const codecNameToCodeVarint = require('./varint-table');
+// 引入自定义的 'util' 模块，其中应该包含了一些工具函数，用于辅助本模块中的相关操作，例如与可变长度整数缓冲区编码相关的功能
+const util = require('./util');
 
-exports = module.exports
+// 将当前模块的导出对象赋值为 'module.exports'，方便后续添加各种导出内容，使其可以被其他模块引入使用
+exports = module.exports;
 
 /**
  * Prefix a buffer with a multicodec-packed.
+ * 此函数用于给一个缓冲区（buffer）数据添加多编码（multicodec）封装前缀。
+ * 根据传入的参数类型不同，确定前缀的具体内容，然后将前缀和原始数据缓冲区拼接在一起返回。
  *
- * @param {string|number} multicodecStrOrCode
- * @param {Buffer} data
- * @returns {Buffer}
+ * @param {string|number|Buffer} multicodecStrOrCode 可以是表示编码名称的字符串、编码对应的数字或者已经是经过处理的缓冲区形式的编码前缀。
+ * @param {Buffer} data 要添加前缀的二进制数据缓冲区。
+ * @returns {Buffer} 返回添加了多编码封装前缀后的缓冲区数据。
  */
 exports.addPrefix = (multicodecStrOrCode, data) => {
-  let prefix
+  let prefix;
 
+  // 如果传入的 multicodecStrOrCode 参数是缓冲区类型，调用 'util' 模块中的 'varintBufferEncode' 函数对其进行可变长度整数编码处理，将处理后的结果作为前缀
   if (Buffer.isBuffer(multicodecStrOrCode)) {
-    prefix = util.varintBufferEncode(multicodecStrOrCode)
+    prefix = util.varintBufferEncode(multicodecStrOrCode);
   } else {
+    // 如果不是缓冲区类型，先检查在 'codecNameToCodeVarint' 映射表中是否能找到对应的编码（通过传入的编码名称字符串作为键来查找）
     if (codecNameToCodeVarint[multicodecStrOrCode]) {
-      prefix = codecNameToCodeVarint[multicodecStrOrCode]
+      // 如果能找到，直接获取对应的编码值（可能是可变长度整数形式的编码表示）作为前缀
+      prefix = codecNameToCodeVarint[multicodecStrOrCode];
     } else {
-      throw new Error('multicodec not recognized')
+      // 如果在映射表中找不到对应的编码名称，抛出一个错误，提示该多编码未被识别
+      throw new Error('multicodec not recognized');
     }
   }
-  return Buffer.concat([prefix, data])
+  // 使用 'Buffer.concat' 方法将前缀和原始数据缓冲区拼接在一起，形成最终带有多编码封装前缀的缓冲区，并返回该缓冲区
+  return Buffer.concat([prefix, data]);
 }
 
 /**
  * Decapsulate the multicodec-packed prefix from the data.
+ * 此函数用于从给定的数据缓冲区中去除多编码（multicodec）封装的前缀部分，返回去除前缀后的剩余数据缓冲区。
  *
- * @param {Buffer} data
- * @returns {Buffer}
+ * @param {Buffer} data 包含多编码封装前缀的二进制数据缓冲区。
+ * @returns {Buffer} 返回去除前缀后的原始数据缓冲区。
  */
 exports.rmPrefix = (data) => {
-  varint.decode(data)
-  return data.slice(varint.decode.bytes)
+  // 调用 'varint' 模块的 'decode' 函数对数据缓冲区进行解码操作，目的是获取前缀部分的长度信息（因为可变长度整数编码的解码会返回解码后的整数以及消耗的字节数等信息）
+  varint.decode(data);
+  // 根据前面解码得到的消耗字节数，使用 'data.slice' 方法截取缓冲区中除去前缀部分后的剩余数据，即返回去除前缀后的原始数据缓冲区
+  return data.slice(varint.decode.bytes);
 }
 
 /**
  * Get the codec of the prefixed data.
- * @param {Buffer} prefixedData
- * @returns {string}
+ * 此函数用于获取带有前缀数据中所使用的编码（codec）对应的名称。
+ * 通过解析前缀中的可变长度整数编码，在 'intTable' 映射表中查找对应的编码名称并返回。
+ *
+ * @param {Buffer} prefixedData 带有多编码封装前缀的二进制数据缓冲区。
+ * @returns {string} 返回对应的编码名称，如果找不到对应的编码则抛出错误。
  */
 exports.getCodec = (prefixedData) => {
-  const code = varint.decode(prefixedData)
-  const codecName = intTable.get(code)
+  // 调用 'varint' 模块的 'decode' 函数对带有前缀的数据缓冲区进行解码操作，获取前缀中表示编码的数字代码
+  const code = varint.decode(prefixedData);
+  // 使用获取到的代码在 'intTable' 映射表中查找对应的编码名称
+  const codecName = intTable.get(code);
   if (codecName === undefined) {
-    throw new Error(`Code ${code} not found`)
+    // 如果在映射表中找不到对应的编码名称，抛出一个错误，提示该代码对应的编码未找到，并展示具体的代码值
+    throw new Error(`Code ${code} not found`);
   }
-  return codecName
+  return codecName;
 }
 
 /**
  * Get the name of the codec.
- * @param {number} codec
- * @returns {string}
+ * 此函数用于根据给定的编码代码获取对应的编码名称。
+ * 直接通过 'intTable' 映射表查找并返回对应的编码名称，如果找不到则返回 'undefined'（由调用者根据情况进一步处理）。
+ *
+ * @param {number} codec 表示编码的数字代码。
+ * @returns {string} 返回对应的编码名称，如果未找到则返回 'undefined'。
  */
 exports.getName = (codec) => {
-  return intTable.get(codec)
+  return intTable.get(codec);
 }
 
 /**
  * Get the code of the codec
- * @param {string} name
- * @returns {number}
+ * 此函数用于根据给定的编码名称获取对应的编码数字代码。
+ * 通过在 'codecNameToCodeVarint' 映射表中查找编码名称对应的代码值，若找不到则抛出错误，并对找到的代码值进行可变长度整数缓冲区解码操作，返回解码后的结果数组中的第一个元素（通常就是对应的代码值）。
+ *
+ * @param {string} name 表示编码的名称。
+ * @returns {number} 返回对应的编码数字代码，如果编码名称未找到则抛出错误。
  */
 exports.getNumber = (name) => {
-  const code = codecNameToCodeVarint[name]
+  const code = codecNameToCodeVarint[name];
   if (code === undefined) {
-    throw new Error('Codec `' + name + '` not found')
+    // 如果在映射表中找不到对应的编码名称，抛出一个错误，提示该编码未找到，并展示具体的编码名称
+    throw new Error('Codec `' + name + '` not found');
   }
-  return util.varintBufferDecode(code)[0]
+  return util.varintBufferDecode(code)[0];
 }
 
 /**
  * Get the code of the prefixed data.
- * @param {Buffer} prefixedData
- * @returns {number}
+ * 此函数用于获取带有前缀数据中的编码数字代码，直接调用 'varint' 模块的 'decode' 函数对数据缓冲区进行解码操作并返回结果。
+ *
+ * @param {Buffer} prefixedData 带有多编码封装前缀的二进制数据缓冲区。
+ * @returns {number} 返回解析得到的编码数字代码。
  */
 exports.getCode = (prefixedData) => {
-  return varint.decode(prefixedData)
+  return varint.decode(prefixedData);
 }
 
 /**
  * Get the code as varint of a codec name.
- * @param {string} codecName
- * @returns {Buffer}
+ * 此函数用于获取给定编码名称对应的可变长度整数编码（varint）表示形式。
+ * 通过在 'codecNameToCodeVarint' 映射表中查找编码名称对应的代码值，若找不到则抛出错误，并返回找到的代码值（即为对应的可变长度整数编码表示）。
+ *
+ * @param {string} codecName 表示编码的名称。
+ * @returns {Buffer} 返回对应的可变长度整数编码表示形式的缓冲区，如果编码名称未找到则抛出错误。
  */
 exports.getCodeVarint = (codecName) => {
-  const code = codecNameToCodeVarint[codecName]
+  const code = codecNameToCodeVarint[codecName];
   if (code === undefined) {
-    throw new Error('Codec `' + codecName + '` not found')
+    // 如果在映射表中找不到对应的编码名称，抛出一个错误，提示该编码未找到，并展示具体的编码名称
+    throw new Error('Codec `' + codecName + '` not found');
   }
-  return code
+  return code;
 }
 
 /**
  * Get the varint of a code.
- * @param {Number} code
- * @returns {Array.<number>}
+ * 此函数用于获取给定编码数字代码对应的可变长度整数编码（varint）表示形式（通常是将数字编码转换为字节数组形式的可变长度整数表示）。
+ * 调用 'varint' 模块的 'encode' 函数对代码进行编码操作，并返回编码后的结果数组（包含可变长度整数的字节表示形式）。
+ *
+ * @param {Number} code 表示编码的数字代码。
+ * @returns {Array.<number>} 返回可变长度整数编码表示形式的字节数组。
  */
 exports.getVarint = (code) => {
-  return varint.encode(code)
+  return varint.encode(code);
 }
 
 // Make the constants top-level constants
-const constants = require('./constants')
-Object.assign(exports, constants)
+// 引入自定义的 'constants' 模块，其中包含了一些常量定义，将其属性合并到当前模块的导出对象中，使这些常量可以作为顶级常量被外部访问
+const constants = require('./constants');
+Object.assign(exports, constants);
 
 // Human friendly names for printing, e.g. in error messages
-exports.print = require('./print')
+// 引入自定义的 'print' 模块，其中可能包含了一些用于生成便于人类阅读的名称（例如在错误消息中使用）的功能，将其赋值给当前模块的 'print' 属性，方便外部使用
+exports.print = require('./print');

node_modules/multihashes/node_modules/multibase/src/index.js

@@ -4,99 +4,127 @@
  */
 'use strict'
 
-const { Buffer } = require('buffer')
-const constants = require('./constants')
-
-exports = module.exports = multibase
-exports.encode = encode
-exports.decode = decode
-exports.isEncoded = isEncoded
-exports.names = Object.freeze(Object.keys(constants.names))
-exports.codes = Object.freeze(Object.keys(constants.codes))
+// 从Node.js的 'buffer' 模块中解构出 'Buffer' 对象，用于后续处理二进制数据，比如创建字节缓冲区、进行数据的拼接等操作。
+const { Buffer } = require('buffer');
+// 引入自定义的 'constants' 模块，该模块大概率包含了与多基数（Multibase）编码相关的各种常量信息，例如不同编码方式对应的名称、代码等内容。
+const constants = require('./constants');
+
+// 将'multibase' 函数以及其他相关函数（'encode'、'decode'、'isEncoded'）作为模块的导出内容，方便其他模块引入并使用这些功能。
+// 同时，将 'names' 和 'codes' 属性也作为导出内容，它们分别是从 'constants' 模块中获取的编码名称和编码代码的键名数组，并使用 'Object.freeze' 冻结，防止其被意外修改。
+exports = module.exports = multibase;
+exports.encode = encode;
+exports.decode = decode;
+exports.isEncoded = isEncoded;
+exports.names = Object.freeze(Object.keys(constants.names));
+exports.codes = Object.freeze(Object.keys(constants.codes));
 
 /**
  * Create a new buffer with the multibase varint+code.
+ * 此函数用于创建一个新的缓冲区，该缓冲区包含多基数（Multibase）变长整数（varint）和编码代码相关信息以及原始的数据内容。
+ * 简单来说，就是给传入的数据缓冲区添加特定的多基数编码前缀，然后返回添加前缀后的新缓冲区。
  *
- * @param {string|number} nameOrCode - The multibase name or code number.
- * @param {Buffer} buf - The data to be prefixed with multibase.
+ * @param {string|number} nameOrCode - The multibase name or code number. 可以是表示多基数编码的名称（字符串形式）或者编码代码对应的数字，用于确定具体使用哪种多基数编码方式来添加前缀。
+ * @param {Buffer} buf - The data to be prefixed with multibase. 要添加多基数编码前缀的二进制数据缓冲区，也就是原始待处理的数据。
  * @memberof Multibase
- * @returns {Buffer}
+ * @returns {Buffer} 返回一个新的缓冲区，其中包含了按照指定多基数编码方式生成的前缀以及原始的数据内容拼接后的结果。
  */
 function multibase (nameOrCode, buf) {
+  // 如果传入的要添加前缀的数据缓冲区为假值（即没有传入有效的数据缓冲区），则抛出一个错误，提示需要一个已编码的缓冲区作为参数。
   if (!buf) {
-    throw new Error('requires an encoded buffer')
+    throw new Error('requires an encoded buffer');
   }
-  const base = getBase(nameOrCode)
-  const codeBuf = Buffer.from(base.code)
-
-  const name = base.name
-  validEncode(name, buf)
-  return Buffer.concat([codeBuf, buf])
+  // 通过 'getBase' 函数（在代码下方有定义，用于根据名称或代码获取对应的编码基础信息）获取具体的编码基础对象，该对象包含了如编码名称、编码代码以及编码、解码相关的方法等属性。
+  const base = getBase(nameOrCode);
+  // 根据获取到的编码基础对象中的编码代码创建一个字节缓冲区，这个缓冲区将作为多基数编码的前缀部分，后续会和原始数据缓冲区拼接在一起。
+  const codeBuf = Buffer.from(base.code);
+
+  const name = base.name;
+  // 调用 'validEncode' 函数（下方定义的私有函数，用于验证编码是否有效）验证当前编码名称和数据缓冲区是否匹配、能否正确编码，该函数本身无返回值（返回值为 undefined），主要用于进行有效性验证，若验证不通过可能会抛出异常。
+  validEncode(name, buf);
+  // 使用 'Buffer.concat' 方法将编码代码缓冲区（codeBuf）和原始数据缓冲区（buf）拼接在一起，形成最终带有多基数编码前缀的新缓冲区，并返回该缓冲区。
+  return Buffer.concat([codeBuf, buf]);
 }
 
 /**
  * Encode data with the specified base and add the multibase prefix.
+ * 此函数的功能是使用指定的编码基础对传入的数据进行编码，并添加多基数编码前缀，最后返回编码后带有前缀的缓冲区。
+ * 整体上是先对数据进行编码转换，再调用'multibase' 函数添加前缀。
  *
- * @param {string|number} nameOrCode - The multibase name or code number.
- * @param {Buffer} buf - The data to be encoded.
- * @returns {Buffer}
+ * @param {string|number} nameOrCode - The multibase name or code number. 用于指定具体的多基数编码方式，既可以是编码名称（字符串形式）也可以是编码代码对应的数字。
+ * @param {Buffer} buf - The data to be encoded. 要进行编码的二进制数据缓冲区，也就是需要进行多基数编码处理的原始数据。
+ * @returns {Buffer} 返回经过指定编码方式编码并添加多基数编码前缀后的缓冲区。
  * @memberof Multibase
  */
 function encode (nameOrCode, buf) {
-  const base = getBase(nameOrCode)
-  const name = base.name
+  // 通过 'getBase' 函数获取对应的编码基础对象，该对象包含了此次编码所需的相关信息及方法。
+  const base = getBase(nameOrCode);
+  const name = base.name;
 
-  return multibase(name, Buffer.from(base.encode(buf)))
+  // 先调用编码基础对象的 'encode' 方法对数据缓冲区（buf）进行编码转换，将转换后的结果再作为参数传递给'multibase' 函数，
+  // 由'multibase' 函数添加多基数编码前缀后返回最终的编码后带有前缀的缓冲区。
+  return multibase(name, Buffer.from(base.encode(buf)));
 }
 
 /**
  * Takes a buffer or string encoded with multibase header, decodes it and
  * returns the decoded buffer
+ * 此函数用于接收一个已经带有多基数（Multibase）编码头部的缓冲区或者对应的字符串表示形式的数据，对其进行解码操作，最终返回解码后的原始数据缓冲区。
  *
- * @param {Buffer|string} bufOrString
- * @returns {Buffer}
+ * @param {Buffer|string} bufOrString 可以是已经经过多基数编码的二进制数据缓冲区，也可以是其对应的字符串表示形式，包含了多基数编码的相关信息。
+ * @returns {Buffer} 返回解码后的二进制数据缓冲区，也就是去除多基数编码后还原出的原始数据内容。
  * @memberof Multibase
- *
  */
 function decode (bufOrString) {
+  // 如果传入的参数是缓冲区类型，先将其转换为字符串形式，方便后续按照字符串的处理逻辑进行操作，例如截取编码头部等操作都基于字符串更方便实现。
   if (Buffer.isBuffer(bufOrString)) {
-    bufOrString = bufOrString.toString()
+    bufOrString = bufOrString.toString();
   }
 
-  const code = bufOrString.substring(0, 1)
-  bufOrString = bufOrString.substring(1, bufOrString.length)
+  // 截取输入字符串的第一个字符作为编码代码，这个编码代码用于后续确定使用哪种多基数编码方式来对剩余的数据进行解码操作。
+  const code = bufOrString.substring(0, 1);
+  // 截取输入字符串中除去第一个字符（编码代码部分）后的剩余部分，这部分就是要进行解码的实际数据内容，后续会将其再转换为缓冲区类型进行处理。
+  bufOrString = bufOrString.substring(1, bufOrString.length);
 
-  if (typeof bufOrString === 'string') {
-    bufOrString = Buffer.from(bufOrString)
+  // 如果剩余的数据内容仍然是字符串类型（经过前面的截取操作后可能还是字符串），将其转换为缓冲区类型，以便后续调用相应的解码方法进行解码操作，因为很多解码操作可能是基于二进制数据缓冲区来实现的。
+  if (typeof bufOrString ==='string') {
+    bufOrString = Buffer.from(bufOrString);
   }
 
-  const base = getBase(code)
-  return Buffer.from(base.decode(bufOrString.toString()))
+  // 通过 'getBase' 函数根据前面获取的编码代码来确定对应的编码基础对象，该对象包含了对剩余数据进行解码所需的方法等信息。
+  const base = getBase(code);
+  // 调用编码基础对象的 'decode' 方法对数据进行解码操作，将解码后的结果从字符串形式转换为缓冲区形式并返回，这个缓冲区就是解码后的原始数据内容。
+  return Buffer.from(base.decode(bufOrString.toString()));
 }
 
 /**
  * Is the given data multibase encoded?
+ * 此函数用于判断给定的数据（可以是缓冲区或字符串形式）是否是经过多基数（Multibase）编码的。
+ * 通过检查数据开头的编码代码是否能对应到有效的编码基础对象来进行判断，并返回相应的布尔值结果。
  *
- * @param {Buffer|string} bufOrString
- * @returns {boolean}
+ * @param {Buffer|string} bufOrString 要检查是否经过多基数编码的二进制数据缓冲区或者对应的字符串表示形式的数据。
+ * @returns {boolean} 如果给定的数据是经过多基数编码的，则返回 true；否则返回 false。
  * @memberof Multibase
  */
 function isEncoded (bufOrString) {
+  // 如果传入的参数是缓冲区类型，先将其转换为字符串形式，方便后续按照字符串逻辑进行处理，例如截取开头的编码代码等操作基于字符串更方便实现。
   if (Buffer.isBuffer(bufOrString)) {
-    bufOrString = bufOrString.toString()
+    bufOrString = bufOrString.toString();
   }
 
-  // Ensure bufOrString is a string
-  if (Object.prototype.toString.call(bufOrString) !== '[object String]') {
-    return false
+  // 确保经过转换后的数据是字符串类型，如果不是（通过 'Object.prototype.toString.call' 判断其类型不符合 '[object String]'），则直接返回 false，表示不是多基数编码的数据，因为后续的处理逻辑都是基于字符串形式来检查编码情况的。
+  if (Object.prototype.toString.call(bufOrString)!== '[object String]') {
+    return false;
   }
 
-  const code = bufOrString.substring(0, 1)
+  // 截取输入字符串的第一个字符作为编码代码，用于后续尝试获取对应的编码基础对象来判断是否为合法的多基数编码。
+  const code = bufOrString.substring(0, 1);
   try {
-    const base = getBase(code)
-    return base.name
+    // 通过 'getBase' 函数根据编码代码获取对应的编码基础对象，如果能成功获取到（说明编码代码是合法存在的），则进一步判断其是否有对应的编码名称（即是否是有效的已实现的编码方式），返回相应的布尔值结果。
+    const base = getBase(code);
+    return base.name;
   } catch (err) {
-    return false
+    // 如果在获取编码基础对象的过程中出现错误（比如编码代码不被支持等情况），则返回 false，表示不是多基数编码的数据。
+    return false;
   }
 }
 
@@ -105,26 +133,41 @@ function isEncoded (bufOrString) {
  * @param {Buffer} buf
  * @private
  * @returns {undefined}
+ * 此函数是一个私有函数（通过函数命名和没有对外暴露的方式体现私有性），用于验证给定编码名称对应的编码方式能否对传入的数据缓冲区进行正确的编码操作。
+ * 它主要是通过调用对应的编码基础对象的 'decode' 方法进行验证，如果出现问题可能会抛出异常（由调用者处理），本身无返回值（返回 undefined）。
  */
 function validEncode (name, buf) {
-  const base = getBase(name)
-  base.decode(buf.toString())
+  const base = getBase(name);
+  base.decode(buf.toString());
 }
 
+/**
+ * 此函数用于根据传入的多基数编码名称或编码代码获取对应的编码基础对象。
+ * 如果传入的名称或代码在 'constants' 模块定义的编码名称或编码代码集合中能找到对应项，则返回相应的编码基础对象；否则抛出表示不支持该编码的错误信息。
+ * 同时，还会检查获取到的编码基础对象是否已经实现（通过 'isImplemented' 方法判断，具体实现逻辑应该在编码基础对象内部定义），若未实现则抛出相应的错误提示。
+ *
+ * @param {string|number} nameOrCode 多基数编码的名称（字符串形式）或者编码代码对应的数字，用于确定要获取的编码基础对象。
+ * @returns {Object} 返回对应的编码基础对象，该对象包含了如编码名称、编码代码以及编码、解码相关的方法等属性，用于后续的编码、解码等操作。
+ */
 function getBase (nameOrCode) {
-  let base
+  let base;
 
+  // 首先检查传入的名称或代码是否在 'constants' 模块定义的编码名称集合中存在对应项，如果存在则获取对应的编码基础对象。
   if (constants.names[nameOrCode]) {
-    base = constants.names[nameOrCode]
+    base = constants.names[nameOrCode];
   } else if (constants.codes[nameOrCode]) {
-    base = constants.codes[nameOrCode]
+    // 如果在编码名称集合中不存在对应项，再检查是否在编码代码集合中存在对应项，如果存在则获取对应的编码基础对象。
+    base = constants.codes[nameOrCode];
   } else {
-    throw new Error('Unsupported encoding')
+    // 如果在两个集合中都找不到对应项，抛出一个表示不支持该编码的错误，提示对应的多基数编码未被识别或不被支持。
+    throw new Error('Unsupported encoding');
   }
 
+  // 检查获取到的编码基础对象是否已经实现（通过调用其 'isImplemented' 方法判断，具体判断逻辑在对应对象内部实现），
+  // 如果未实现（即返回值为 false），则抛出一个新的错误，提示对应的编码基础对象对应的编码还未被实现，无法进行相关操作。
   if (!base.isImplemented()) {
-    throw new Error('Base ' + nameOrCode + ' is not implemented yet')
+    throw new Error('Base'+ nameOrCode +'is not implemented yet');
   }
 
-  return base
+  return base;
 }

node_modules/multihashes/src/index.js

@@ -5,220 +5,292 @@
  */
 'use strict'
 
-const { Buffer } = require('buffer')
-const multibase = require('multibase')
-const varint = require('varint')
-const cs = require('./constants')
-
-exports.names = cs.names
-exports.codes = cs.codes
-exports.defaultLengths = cs.defaultLengths
+// 从Node.js的 'buffer' 模块中解构出 'Buffer' 对象，用于后续处理二进制数据，例如创建字节缓冲区、进行数据的转换以及判断数据类型等操作。
+const { Buffer } = require('buffer');
+// 引入'multibase' 模块，该模块可能用于处理多基数编码相关的功能，例如对数据进行特定编码格式的转换、添加或去除编码前缀等操作（具体功能依赖其自身实现）。
+const multibase = require('multibase');
+// 引入 'varint' 模块，通常用于处理可变长度整数（Variable-length Integer）的编码和解码操作，在解析或构造包含变长整数结构的数据时会发挥作用。
+const varint = require('varint');
+// 引入自定义的 './constants' 模块，推测其中包含了与多哈希（Multihash）相关的各种常量定义，比如编码名称、编码代码以及默认长度等信息，供本模块中的函数使用。
+const cs = require('./constants');
+
+// 将从 'constants' 模块中获取的编码名称数组作为当前模块的导出属性 'names'，方便外部模块获取多哈希相关的编码名称信息。
+exports.names = cs.names;
+// 将从 'constants' 模块中获取的编码代码数组作为当前模块的导出属性 'codes'，用于外部模块获取多哈希相关的编码代码信息。
+exports.codes = cs.codes;
+// 将从 'constants' 模块中获取的默认长度相关信息作为当前模块的导出属性 'defaultLengths'，可能在涉及长度处理的操作中会用到这些默认值。
 
 /**
  * Convert the given multihash to a hex encoded string.
+ * 此函数用于将给定的多哈希（Multihash）数据（以字节缓冲区形式表示）转换为十六进制编码的字符串形式。
+ * 如果传入的参数不是字节缓冲区类型，会抛出相应的错误提示。
  *
- * @param {Buffer} hash
- * @returns {string}
+ * @param {Buffer} hash 要转换的多哈希数据，必须是字节缓冲区类型，表示经过特定哈希算法处理后的结果等相关数据。
+ * @returns {string} 返回转换后的十六进制编码字符串，表示对应的多哈希数据内容。
  */
 exports.toHexString = function toHexString (hash) {
+  // 首先判断传入的 'hash' 参数是否是字节缓冲区类型，如果不是，则抛出一个错误，提示必须传入字节缓冲区类型的数据，因为后续的操作是基于字节缓冲区来进行转换的。
   if (!Buffer.isBuffer(hash)) {
-    throw new Error('must be passed a buffer')
+    throw new Error('must be passed a buffer');
   }
 
-  return hash.toString('hex')
+  // 如果是字节缓冲区类型，调用字节缓冲区的 'toString' 方法，并指定编码格式为 'hex'（十六进制），将字节缓冲区中的数据转换为十六进制编码的字符串并返回。
+  return hash.toString('hex');
 }
 
 /**
  * Convert the given hex encoded string to a multihash.
+ * 此函数的功能与 'toHexString' 相反，用于将给定的十六进制编码字符串转换回多哈希（Multihash）数据，即转换为字节缓冲区形式。
  *
- * @param {string} hash
- * @returns {Buffer}
+ * @param {string} hash 要转换的十六进制编码字符串，代表着多哈希数据的一种文本表示形式。
+ * @returns {Buffer} 返回转换后的字节缓冲区，也就是对应的多哈希数据内容，可用于后续其他基于字节缓冲区的多哈希相关操作。
  */
 exports.fromHexString = function fromHexString (hash) {
-  return Buffer.from(hash, 'hex')
+  // 直接调用 'Buffer.from' 方法，传入要转换的十六进制编码字符串和指定的编码格式 'hex'，将字符串转换为字节缓冲区并返回，实现了从十六进制字符串到多哈希字节缓冲区数据的转换。
+  return Buffer.from(hash, 'hex');
 }
 
 /**
  * Convert the given multihash to a base58 encoded string.
+ * 此函数用于将给定的多哈希（Multihash）数据（字节缓冲区形式）转换为Base58编码的字符串形式，常用于一些加密货币等领域对数据进行编码以方便展示和传输等操作。
+ * 如果传入的参数不是字节缓冲区类型，会抛出相应的错误提示。
  *
- * @param {Buffer} hash
- * @returns {string}
+ * @param {Buffer} hash 要转换的多哈希数据，必须是字节缓冲区类型，包含了多哈希相关的信息。
+ * @returns {string} 返回转换后的Base58编码字符串，表示对应的多哈希数据经过Base58编码后的内容。
  */
 exports.toB58String = function toB58String (hash) {
+  // 首先判断传入的 'hash' 参数是否是字节缓冲区类型，如果不是，则抛出一个错误，提示必须传入字节缓冲区类型的数据，因为后续的操作依赖于字节缓冲区来进行编码转换。
   if (!Buffer.isBuffer(hash)) {
-    throw new Error('must be passed a buffer')
+    throw new Error('must be passed a buffer');
   }
 
-  return multibase.encode('base58btc', hash).toString().slice(1)
+  // 调用'multibase' 模块的 'encode' 方法，指定编码方式为 'base58btc'（可能是一种特定的Base58编码格式，常用于比特币等相关场景）对多哈希数据进行编码，
+  // 将编码后的结果转换为字符串形式（通过 'toString' 方法），然后去除第一个字符（可能是编码前缀等不需要的部分，具体取决于编码规范），最后返回剩余的Base58编码字符串。
+  return multibase.encode('base58btc', hash).toString().slice(1);
 }
 
 /**
  * Convert the given base58 encoded string to a multihash.
+ * 此函数与 'toB58String' 功能相反，用于将给定的Base58编码字符串转换回多哈希（Multihash）数据，即转换为字节缓冲区形式，以便后续进行多哈希相关的处理操作。
+ * 如果传入的参数本身是字节缓冲区类型，会先将其转换为字符串形式再进行后续处理。
  *
- * @param {string|Buffer} hash
- * @returns {Buffer}
+ * @param {string|Buffer} hash 可以是Base58编码的字符串或者已经是字节缓冲区形式的数据（但如果是字节缓冲区会先转换为字符串），代表着经过Base58编码后的多哈希数据表示形式。
+ * @returns {Buffer} 返回转换后的字节缓冲区，也就是还原后的多哈希数据内容，可用于后续基于多哈希字节缓冲区的操作，如解码等。
  */
 exports.fromB58String = function fromB58String (hash) {
-  let encoded = hash
+  let encoded = hash;
+  // 如果传入的参数是字节缓冲区类型，将其转换为字符串形式，方便后续按照字符串的处理逻辑进行操作，例如添加前缀等（在调用'multibase' 模块的 'decode' 方法时可能需要特定格式的字符串输入）。
   if (Buffer.isBuffer(hash)) {
-    encoded = hash.toString()
+    encoded = hash.toString();
   }
 
-  return multibase.decode('z' + encoded)
+  // 调用'multibase' 模块的 'decode' 方法，在传入的Base58编码字符串前添加一个特定字符 'z'（可能是符合某种多哈希编码规范的前缀要求），
+  // 然后对其进行解码操作，返回解码后的字节缓冲区，即还原出的多哈希数据内容。
+  return multibase.decode('z' + encoded);
 }
 
 /**
  * Decode a hash from the given multihash.
+ * 此函数用于从给定的多哈希（Multihash）字节缓冲区数据中解析出相关的信息，包括哈希函数代码、名称、长度以及实际的摘要数据等内容，并以对象形式返回这些解析结果。
+ * 如果传入的参数不符合要求（不是字节缓冲区类型或者长度过短等情况），会抛出相应的错误提示。
  *
- * @param {Buffer} buf
- * @returns {{code: number, name: string, length: number, digest: Buffer}} result
+ * @param {Buffer} buf 要解码的多哈希数据，必须是字节缓冲区类型，包含了多哈希编码后的完整信息。
+ * @returns {{code: number, name: string, length: number, digest: Buffer}} result 返回一个包含解码后信息的对象，其中 'code' 表示哈希函数代码（数字形式），
+ * 'name' 表示对应的哈希函数名称（字符串形式，从相关常量中获取），'length' 表示摘要数据的长度（数字形式），'digest' 表示实际的摘要数据内容（字节缓冲区形式）。
  */
 exports.decode = function decode (buf) {
+  // 首先判断传入的 'buf' 参数是否是字节缓冲区类型，如果不是，则抛出一个错误，提示多哈希数据必须是字节缓冲区类型，因为后续的解码操作是基于字节缓冲区来进行的。
   if (!(Buffer.isBuffer(buf))) {
-    throw new Error('multihash must be a Buffer')
+    throw new Error('multihash must be a Buffer');
   }
 
+  // 如果字节缓冲区的长度小于2字节，抛出一个错误，提示多哈希数据太短，因为按照多哈希的编码规范，至少需要一定长度的数据才能包含完整的编码信息，这里规定至少要大于2字节。
   if (buf.length < 2) {
-    throw new Error('multihash too short. must be > 2 bytes.')
+    throw new Error('multihash too short. must be > 2 bytes.');
   }
 
-  const code = varint.decode(buf)
+  // 调用 'varint' 模块的 'decode' 方法对字节缓冲区的开头部分进行解码，获取哈希函数代码（因为多哈希编码中开头通常会用可变长度整数来表示哈希函数代码），将解码后的代码存储在 'code' 变量中。
+  const code = varint.decode(buf);
+  // 调用本模块的 'isValidCode' 方法（代码中未展示该方法的具体实现，推测用于判断代码是否是合法的哈希函数代码）来验证获取到的哈希函数代码是否有效，
+  // 如果代码无效，则抛出一个错误，提示多哈希中出现未知的函数代码，并展示该代码的十六进制表示形式。
   if (!exports.isValidCode(code)) {
-    throw new Error(`multihash unknown function code: 0x${code.toString(16)}`)
+    throw new Error(`multihash unknown function code: 0x${code.toString(16)}`);
   }
-  buf = buf.slice(varint.decode.bytes)
+  // 根据前面解码哈希函数代码时消耗的字节数，使用 'buf.slice' 方法截取字节缓冲区中除去已解析的哈希函数代码部分后的剩余数据，更新 'buf' 变量，使其指向剩余待解析的数据部分。
+  buf = buf.slice(varint.decode.bytes);
 
-  const len = varint.decode(buf)
+  // 再次调用 'varint' 模块的 'decode' 方法对剩余的数据部分进行解码，获取摘要数据的长度信息（同样在多哈希编码中长度也是用可变长度整数表示），将解码后的长度存储在 'len' 变量中。
+  const len = varint.decode(buf);
+  // 如果解析出的长度为负数，抛出一个错误，提示多哈希的长度无效，因为长度通常应该是一个非负整数。
   if (len < 0) {
-    throw new Error(`multihash invalid length: ${len}`)
+    throw new Error(`multihash invalid length: ${len}`);
   }
-  buf = buf.slice(varint.decode.bytes)
+  // 根据这次解码长度信息时消耗的字节数，再次使用 'buf.slice' 方法截取字节缓冲区中除去已解析的长度部分后的剩余数据，更新 'buf' 变量，使其指向真正的摘要数据部分。
+  buf = buf.slice(varint.decode.bytes);
 
-  if (buf.length !== len) {
-    throw new Error(`multihash length inconsistent: 0x${buf.toString('hex')}`)
+  // 检查剩余的字节缓冲区（也就是摘要数据部分）的实际长度是否与前面解析出的长度 'len' 一致，如果不一致，抛出一个错误，提示多哈希长度不一致，并展示摘要数据部分的十六进制表示形式。
+  if (buf.length!== len) {
+    throw new Error(`multihash length inconsistent: 0x${buf.toString('hex')}`);
   }
 
+  // 如果所有的验证和解码操作都顺利通过，将解析出的哈希函数代码、对应的哈希函数名称（从 'cs.codes' 常量中根据代码获取名称）、摘要数据长度以及摘要数据内容（字节缓冲区形式）封装成一个对象并返回。
   return {
     code: code,
     name: cs.codes[code],
     length: len,
     digest: buf
-  }
+  };
 }
 
 /**
  *  Encode a hash digest along with the specified function code.
+ * 此函数用于将给定的哈希摘要数据（字节缓冲区形式）以及指定的哈希函数代码进行编码，生成符合多哈希（Multihash）编码规范的字节缓冲区数据。
+ * 需要注意的是，摘要数据的长度通常会根据其自身实际长度来确定（如果未指定长度参数的话）。
+ * 如果传入的参数不符合要求（如缺少必要参数或者参数类型不正确等情况），会抛出相应的错误提示。
  *
- * > **Note:** the length is derived from the length of the digest itself.
- *
- * @param {Buffer} digest
- * @param {string|number} code
- * @param {number} [length]
- * @returns {Buffer}
+ * @param {Buffer} digest 要编码的哈希摘要数据，必须是字节缓冲区类型，包含了实际的哈希计算结果内容。
+ * @param {string|number} code 可以是表示哈希函数代码的字符串或者数字形式，用于指定使用哪种哈希函数进行编码。
+ * @param {number} [length] 可选参数，用于指定摘要数据的长度，如果不传入该参数，则默认使用摘要数据本身的长度。
+ * @returns {Buffer} 返回经过编码后的字节缓冲区数据，符合多哈希编码规范，包含了哈希函数代码、摘要数据长度以及摘要数据内容等信息。
  */
 exports.encode = function encode (digest, code, length) {
+  // 首先检查是否传入了必要的参数，如果摘要数据 'digest' 为空（假值）或者哈希函数代码 'code' 未定义，抛出一个错误，提示多哈希编码至少需要传入摘要数据和哈希函数代码这两个参数。
   if (!digest || code === undefined) {
-    throw new Error('multihash encode requires at least two args: digest, code')
+    throw new Error('multihash encode requires at least two args: digest, code');
   }
 
+  // 调用本模块的 'coerceCode' 方法（代码中未展示该方法的具体实现，推测用于将传入的代码参数转换为合法的哈希函数代码格式等操作）来确保传入的代码是合法的哈希函数代码，将处理后的代码存储在 'hashfn' 变量中。
   // ensure it's a hashfunction code.
-  const hashfn = exports.coerceCode(code)
+  const hashfn = exports.coerceCode(code);
 
+  // 再次检查摘要数据 'digest' 是否是字节缓冲区类型，如果不是，则抛出一个错误，提示摘要数据应该是字节缓冲区类型，因为后续的编码操作是基于字节缓冲区来构建多哈希编码数据的。
   if (!(Buffer.isBuffer(digest))) {
-    throw new Error('digest should be a Buffer')
+    throw new Error('digest should be a Buffer');
   }
 
+  // 如果没有传入长度参数 'length'（即值为 'null'），则默认使用摘要数据本身的长度作为编码时的长度信息，将摘要数据的长度赋值给 'length' 变量。
   if (length == null) {
-    length = digest.length
+    length = digest.length;
   }
 
-  if (length && digest.length !== length) {
-    throw new Error('digest length should be equal to specified length.')
+  // 如果传入了长度参数 'length'，并且摘要数据的实际长度与指定的长度不一致，抛出一个错误，提示摘要数据长度应该与指定的长度相等，确保编码数据的一致性和准确性。
+  if (length && digest.length!== length) {
+    throw new Error('digest length should be equal to specified length.');
   }
 
+  // 使用 'Buffer.concat' 方法将三部分数据拼接在一起形成最终的编码后字节缓冲区数据：
+  // 1. 首先将经过 'varint' 模块的 'encode' 方法对哈希函数代码 'hashfn' 进行编码后的结果转换为字节缓冲区（因为 'varint' 编码后的结果可能是数组形式等，需要转换为字节缓冲区），作为多哈希编码的开头部分，表示哈希函数代码信息。
+  // 2. 接着将经过 'varint' 模块的 'encode' 方法对长度 'length' 进行编码后的结果转换为字节缓冲区，作为中间部分，表示摘要数据的长度信息。
+  // 3. 最后将原始的摘要数据 'digest' 作为结尾部分，包含了实际的哈希计算结果内容。
   return Buffer.concat([
     Buffer.from(varint.encode(hashfn)),
     Buffer.from(varint.encode(length)),
     digest
-  ])
+  ]);
 }
 
 /**
  * Converts a hash function name into the matching code.
  * If passed a number it will return the number if it's a valid code.
- * @param {string|number} name
- * @returns {number}
+ * 此函数用于将哈希函数名称转换为对应的代码（数字形式）。
+ * 如果传入的参数本身就是数字形式且是合法的代码，那么直接返回该数字。
+ *
+ * @param {string|number} name 可以是表示哈希函数名称的字符串，或者是代表哈希函数代码的数字，用于进行转换或验证操作。
+ * @returns {number} 返回对应的哈希函数代码（数字形式），如果传入的参数不符合要求或者无法转换，则会抛出相应的错误。
  */
 exports.coerceCode = function coerceCode (name) {
-  let code = name
+  let code = name;
 
-  if (typeof name === 'string') {
+  // 如果传入的参数是字符串类型，说明可能是哈希函数名称，需要查找对应的代码。
+  if (typeof name ==='string') {
+    // 在自定义的 'cs' 模块（推测包含了哈希函数相关的常量映射信息）的 'names' 属性中查找该名称对应的代码，
+    // 如果找不到（即返回值为 'undefined'），则抛出一个错误，提示该哈希函数名称未被识别，并展示具体的名称内容。
     if (cs.names[name] === undefined) {
-      throw new Error(`Unrecognized hash function named: ${name}`)
+      throw new Error(`Unrecognized hash function named: ${name}`);
     }
-    code = cs.names[name]
+    // 如果能找到对应的代码，将其赋值给 'code' 变量，此时 'code' 就变成了对应的哈希函数代码（数字形式）。
+    code = cs.names[name];
   }
 
-  if (typeof code !== 'number') {
-    throw new Error(`Hash function code should be a number. Got: ${code}`)
+  // 经过前面的处理后，再次检查 'code' 的类型，如果不是数字类型，说明不符合要求（无论是传入的参数本身有问题还是转换过程出现异常），
+  // 抛出一个错误，提示哈希函数代码应该是数字类型，并展示当前 'code' 的实际值（可能是不正确的类型转换结果等）。
+  if (typeof code!== 'number') {
+    throw new Error(`Hash function code should be a number. Got: ${code}`);
   }
 
-  if (cs.codes[code] === undefined && !exports.isAppCode(code)) {
-    throw new Error(`Unrecognized function code: ${code}`)
+  // 检查该代码在 'cs' 模块的 'codes' 属性中是否能找到对应的映射（即是否是一个被定义的合法代码），
+  // 同时调用 'isAppCode' 函数（本模块中定义的另一个函数，用于判断代码是否在应用程序相关的代码范围内）来进一步验证代码的合法性，
+  // 如果在 'cs.codes' 中找不到对应映射且不属于应用程序相关的代码范围，抛出一个错误，提示该函数代码未被识别，并展示具体的代码值。
+  if (cs.codes[code] === undefined &&!exports.isAppCode(code)) {
+    throw new Error(`Unrecognized function code: ${code}`);
   }
 
-  return code
+  // 如果前面的所有验证都通过，说明 'code' 是合法的哈希函数代码，将其返回。
+  return code;
 }
 
 /**
  * Checks wether a code is part of the app range
+ * 此函数用于判断给定的代码是否处于应用程序相关的代码范围内。
  *
- * @param {number} code
- * @returns {boolean}
+ * @param {number} code 要检查的哈希函数代码（数字形式）。
+ * @returns {boolean} 如果代码大于0且小于十六进制的0x10（即十进制的16），则返回 true，表示在应用程序相关的代码范围内；否则返回 false。
  */
 exports.isAppCode = function appCode (code) {
-  return code > 0 && code < 0x10
+  return code > 0 && code < 0x10;
 }
 
 /**
  * Checks whether a multihash code is valid.
+ * 此函数用于判断给定的多哈希（Multihash）代码是否是有效的。
+ * 通过检查代码是否在应用程序相关的代码范围内或者在自定义的 'cs' 模块中是否有对应的定义来进行有效性判断。
  *
- * @param {number} code
- * @returns {boolean}
+ * @param {number} code 要检查有效性的多哈希代码（数字形式）。
+ * @returns {boolean} 如果代码通过了有效性验证（在应用程序相关范围或者在 'cs.codes' 中有定义），则返回 true；否则返回 false。
  */
 exports.isValidCode = function validCode (code) {
+  // 首先调用 'isAppCode' 函数判断代码是否在应用程序相关的代码范围内，如果在该范围内，则直接返回 true，表示代码有效。
   if (exports.isAppCode(code)) {
-    return true
+    return true;
   }
 
+  // 如果不在应用程序相关的代码范围内，再检查在自定义的 'cs' 模块的 'codes' 属性中是否能找到该代码对应的映射（即是否有定义），
+  // 如果能找到，则返回 true，表示代码有效；否则返回 false，表示代码无效。
   if (cs.codes[code]) {
-    return true
+    return true;
   }
 
-  return false
+  return false;
 }
 
 /**
  * Check if the given buffer is a valid multihash. Throws an error if it is not valid.
+ * 此函数用于检查给定的字节缓冲区是否是一个有效的多哈希（Multihash）数据。
+ * 它通过调用本模块的 'decode' 函数（在前面代码中应该有定义，用于解析多哈希数据并进行各种验证）来进行检查，
+ * 如果数据不符合多哈希的规范或者解析过程中出现问题，'decode' 函数会抛出相应的错误，这里直接利用了这个特性来进行有效性验证。
  *
- * @param {Buffer} multihash
- * @returns {undefined}
- * @throws {Error}
+ * @param {Buffer} multihash 要检查有效性的字节缓冲区，代表可能的多哈希数据内容。
+ * @returns {undefined} 该函数无返回值，如果验证通过则正常结束函数执行，如果验证不通过会通过抛出错误来提示数据无效。
+ * @throws {Error} 如果给定的字节缓冲区不是有效的多哈希数据，会抛出相应的错误，错误信息由 'decode' 函数抛出的具体内容决定。
  */
 function validate (multihash) {
-  exports.decode(multihash) // throws if bad.
+  exports.decode(multihash); // throws if bad.
 }
-exports.validate = validate
+// 将 'validate' 函数作为当前模块的导出内容，方便其他模块调用该函数来验证多哈希数据的有效性。
+exports.validate = validate;
 
 /**
  * Returns a prefix from a valid multihash. Throws an error if it is not valid.
+ * 此函数用于从一个有效的多哈希（Multihash）数据（字节缓冲区形式）中获取其前缀部分（通常是开头的特定字节，可能包含哈希函数代码等信息）。
+ * 首先会调用 'validate' 函数（前面定义的用于验证多哈希数据有效性的函数）来确保传入的数据是有效的多哈希数据，
+ * 如果数据无效，验证过程会抛出错误，函数执行会中断；如果数据有效，则提取并返回其前缀部分。
  *
- * @param {Buffer} multihash
- * @returns {undefined}
- * @throws {Error}
+ * @param {Buffer} multihash 要获取前缀的有效多哈希数据，必须是字节缓冲区类型，且已经通过有效性验证。
+ * @returns {undefined} 该函数无返回值，如果验证通过则返回提取的前缀部分（字节缓冲区形式），如果验证不通过会通过抛出错误来提示数据无效。
+ * @throws {Error} 如果给定的字节缓冲区不是有效的多哈希数据，会抛出相应的错误，错误信息由 'validate' 函数抛出的具体内容决定。
  */
 exports.prefix = function prefix (multihash) {
-  validate(multihash)
+  validate(multihash);
 
-  return multihash.slice(0, 2)
+  return multihash.slice(0, 2);
 }

node_modules/mysql/index.js

@@ -1,113 +1,154 @@
+// 创建一个空的对象（原型为空），用于存储后续加载的类，避免重复加载相同的类，起到一种缓存类的作用。
 var Classes = Object.create(null);
 
 /**
  * Create a new Connection instance.
- * @param {object|string} config Configuration or connection string for new MySQL connection
- * @return {Connection} A new MySQL connection
+ * 创建一个新的数据库连接（Connection）实例。
+ * 接收一个配置参数，可以是一个对象形式的配置信息或者是一个连接字符串，用于配置新的MySQL连接相关设置，最终返回一个新创建的MySQL连接实例。
+ *
+ * @param {object|string} config Configuration or connection string for new MySQL connection 用于新的MySQL连接的配置信息，可以是对象或者字符串形式。
+ * @return {Connection} A new MySQL connection 返回一个新创建的MySQL连接实例。
  * @public
  */
 exports.createConnection = function createConnection(config) {
-  var Connection       = loadClass('Connection');
+  // 调用 `loadClass` 函数（内部私有函数，用于加载指定名称的类）加载名为 `Connection` 的类，获取对应的类构造函数或已导出的对象，后续用于创建实例。
+  var Connection = loadClass('Connection');
+  // 同样调用 `loadClass` 函数加载名为 `ConnectionConfig` 的类，用于创建连接配置相关的对象。
   var ConnectionConfig = loadClass('ConnectionConfig');
 
+  // 使用加载到的 `Connection` 类的构造函数创建一个新的实例，传入一个配置对象，该配置对象中的 `config` 属性值是通过 `ConnectionConfig` 类根据传入的 `config` 参数创建的新的连接配置对象，最终返回创建好的连接实例。
   return new Connection({config: new ConnectionConfig(config)});
 };
 
 /**
  * Create a new Pool instance.
- * @param {object|string} config Configuration or connection string for new MySQL connections
- * @return {Pool} A new MySQL pool
+ * 创建一个新的数据库连接池（Pool）实例。
+ * 接收一个配置参数，该参数可以是对象形式的配置信息或者是一个连接字符串，用于配置新的MySQL连接池相关设置，最终返回一个新创建的MySQL连接池实例。
+ *
+ * @param {object|string} config Configuration or connection string for new MySQL connections 用于新的MySQL连接池的配置信息，可以是对象或者字符串形式。
+ * @return {Pool} A new MySQL pool 返回一个新创建的MySQL连接池实例。
  * @public
  */
 exports.createPool = function createPool(config) {
-  var Pool       = loadClass('Pool');
+  // 调用 `loadClass` 函数加载名为 `Pool` 的类，获取对应的类构造函数或已导出的对象，用于后续创建实例。
+  var Pool = loadClass('Pool');
+  // 调用 `loadClass` 函数加载名为 `PoolConfig` 的类，用于创建连接池配置相关的对象。
   var PoolConfig = loadClass('PoolConfig');
 
+  // 使用加载到的 `Pool` 类的构造函数创建一个新的实例，传入一个配置对象，该配置对象中的 `config` 属性值是通过 `PoolConfig` 类根据传入的 `config` 参数创建的新的连接池配置对象，最终返回创建好的连接池实例。
   return new Pool({config: new PoolConfig(config)});
 };
 
 /**
  * Create a new PoolCluster instance.
- * @param {object} [config] Configuration for pool cluster
- * @return {PoolCluster} New MySQL pool cluster
+ * 创建一个新的数据库连接池集群（PoolCluster）实例。
+ * 接收一个可选的配置对象参数，用于配置新的MySQL连接池集群相关设置，最终返回一个新创建的MySQL连接池集群实例。
+ *
+ * @param {object} [config] Configuration for pool cluster 用于新的MySQL连接池集群的配置信息，是一个可选的对象参数。
+ * @return {PoolCluster} New MySQL pool cluster 返回一个新创建的MySQL连接池集群实例。
  * @public
  */
 exports.createPoolCluster = function createPoolCluster(config) {
+  // 调用 `loadClass` 函数加载名为 `PoolCluster` 的类，获取对应的类构造函数或已导出的对象，用于后续创建实例。
   var PoolCluster = loadClass('PoolCluster');
 
+  // 使用加载到的 `PoolCluster` 类的构造函数创建一个新的实例，传入传入的 `config` 参数（如果有的话），最终返回创建好的连接池集群实例。
   return new PoolCluster(config);
 };
 
 /**
  * Create a new Query instance.
- * @param {string} sql The SQL for the query
- * @param {array} [values] Any values to insert into placeholders in sql
- * @param {function} [callback] The callback to use when query is complete
- * @return {Query} New query object
+ * 创建一个新的查询（Query）对象实例。
+ * 接收SQL语句字符串、可选的占位符对应的值数组以及可选的查询完成后的回调函数，用于构建一个新的查询对象，便于后续执行查询操作等。
+ *
+ * @param {string} sql The SQL for the query 要执行的SQL语句字符串。
+ * @param {array} [values] Any values to insert into placeholders in sql 可选参数，用于填充SQL语句中占位符的值的数组。
+ * @param {function} [callback] The callback to use when query is complete 可选参数，查询完成后要调用的回调函数。
+ * @return {Query} New query object 返回一个新创建的查询对象实例。
  * @public
  */
 exports.createQuery = function createQuery(sql, values, callback) {
+  // 调用 `loadClass` 函数加载名为 `Connection` 的类，获取对应的类构造函数或已导出的对象，后续利用该类来创建查询对象。
   var Connection = loadClass('Connection');
 
+  // 通过加载到的 `Connection` 类的静态方法 `createQuery`（假设存在该静态方法，具体功能依赖于 `Connection` 类的实现）创建一个新的查询对象实例，传入相应的参数（SQL语句、值数组、回调函数），并返回创建好的查询对象。
   return Connection.createQuery(sql, values, callback);
 };
 
 /**
  * Escape a value for SQL.
- * @param {*} value The value to escape
- * @param {boolean} [stringifyObjects=false] Setting if objects should be stringified
- * @param {string} [timeZone=local] Setting for time zone to use for Date conversion
- * @return {string} Escaped string value
+ * 对要插入到SQL语句中的值进行转义处理，使其符合SQL语法要求，避免出现语法错误或安全漏洞（如SQL注入问题），最终返回转义后的字符串形式的值。
+ *
+ * @param {*} value The value to escape 要进行转义处理的任意类型的值，可以是字符串、数字、对象等各种类型，具体转义逻辑会根据不同类型进行相应处理。
+ * @param {boolean} [stringifyObjects=false] Setting if objects should be stringified 可选参数，一个布尔值，用于指定是否将对象类型的值转换为字符串形式进行转义处理，默认值为 `false`。
+ * @param {string} [timeZone=local] Setting for time zone to use for Date conversion 可选参数，指定用于日期类型值转换时所使用的时区设置，默认值为 `local`（本地时区，具体含义依赖于实现）。
+ * @return {string} Escaped string value 返回转义后的字符串形式的值，可安全地插入到SQL语句中对应的位置。
  * @public
  */
 exports.escape = function escape(value, stringifyObjects, timeZone) {
+  // 调用 `loadClass` 函数加载名为 `SqlString` 的类，获取对应的类构造函数或已导出的对象，后续利用该类中的转义方法来处理值。
   var SqlString = loadClass('SqlString');
 
+  // 调用 `SqlString` 类的 `escape` 方法（具体转义逻辑在该类中实现），传入要转义的值以及可选的 `stringifyObjects` 和 `timeZone` 参数，进行转义处理，并返回转义后的字符串结果。
   return SqlString.escape(value, stringifyObjects, timeZone);
 };
 
 /**
  * Escape an identifier for SQL.
- * @param {*} value The value to escape
- * @param {boolean} [forbidQualified=false] Setting to treat '.' as part of identifier
- * @return {string} Escaped string value
+ * 对SQL语句中的标识符（例如表名、列名等）进行转义处理，确保其符合SQL语法规范，避免出现语法错误或因特殊字符导致的问题，最终返回转义后的字符串形式的标识符。
+ *
+ * @param {*} value The value to escape 要进行转义处理的标识符，可以是字符串等类型，具体转义逻辑会根据标识符的特点进行相应处理。
+ * @param {boolean} [forbidQualified=false] Setting to treat '.' as part of identifier 可选参数，一个布尔值，用于指定是否将 `.`（点号）视为标识符的一部分来进行处理，默认值为 `false`。
+ * @return {string} Escaped string value 返回转义后的字符串形式的标识符，可安全地在SQL语句中使用。
  * @public
  */
 exports.escapeId = function escapeId(value, forbidQualified) {
+  // 调用 `loadClass` 函数加载名为 `SqlString` 的类，获取对应的类构造函数或已导出的对象，后续利用该类中的标识符转义方法来处理标识符。
   var SqlString = loadClass('SqlString');
 
+  // 调用 `SqlString` 类的 `escapeId` 方法（具体转义逻辑在该类中实现），传入要转义的标识符以及可选的 `forbidQualified` 参数，进行转义处理，并返回转义后的字符串结果。
   return SqlString.escapeId(value, forbidQualified);
 };
 
 /**
  * Format SQL and replacement values into a SQL string.
- * @param {string} sql The SQL for the query
- * @param {array} [values] Any values to insert into placeholders in sql
- * @param {boolean} [stringifyObjects=false] Setting if objects should be stringified
- * @param {string} [timeZone=local] Setting for time zone to use for Date conversion
- * @return {string} Formatted SQL string
+ * 将SQL语句和对应的占位符替换值进行格式化处理，生成最终可以直接在数据库中执行的完整SQL语句字符串，方便后续执行数据库操作。
+ *
+ * @param {string} sql The SQL for the query 要进行格式化的SQL语句字符串，其中可能包含占位符等需要替换的内容。
+ * @param {array} [values] Any values to insert into placeholders in sql 可选参数，用于填充SQL语句中占位符的值的数组。
+ * @param {boolean} [stringifyObjects=false] Setting if objects should be stringified 可选参数，一个布尔值，用于指定是否将对象类型的值转换为字符串形式进行格式化处理，默认值为 `false`。
+ * @param {timeZone=local} [Setting for time zone to use for Date conversion] 可选参数，指定用于日期类型值转换时所使用的时区设置，默认值为 `local`（本地时区，具体含义依赖于实现）。
+ * @return {string} Formatted SQL string 返回格式化后的完整SQL语句字符串，可直接用于数据库执行操作。
  * @public
  */
 exports.format = function format(sql, values, stringifyObjects, timeZone) {
+  // 调用 `loadClass` 函数加载名为 `SqlString` 的类，获取对应的类构造函数或已导出的对象，后续利用该类中的格式化方法来处理SQL语句和值。
   var SqlString = loadClass('SqlString');
 
+  // 调用 `SqlString` 类的 `format` 方法（具体格式化逻辑在该类中实现），传入要格式化的SQL语句、值数组以及可选的 `stringifyObjects` 和 `timeZone` 参数，进行格式化处理，并返回格式化后的SQL语句字符串结果。
   return SqlString.format(sql, values, stringifyObjects, timeZone);
 };
 
 /**
  * Wrap raw SQL strings from escape overriding.
- * @param {string} sql The raw SQL
- * @return {object} Wrapped object
+ * 将原始的SQL语句字符串进行包装处理（具体包装逻辑依赖于 `SqlString` 类的实现），返回包装后的对象，可能用于特殊的SQL处理场景或者满足特定的使用需求。
+ *
+ * @param {string} sql The raw SQL 要进行包装的原始SQL语句字符串。
+ * @return {object} Wrapped object 返回包装后的对象，具体结构和属性由包装逻辑决定。
  * @public
  */
 exports.raw = function raw(sql) {
+  // 调用 `loadClass` 函数加载名为 `SqlString` 的类，获取对应的类构造函数或已导出的对象，后续利用该类中的包装方法来处理原始SQL语句。
   var SqlString = loadClass('SqlString');
 
+  // 调用 `SqlString` 类的 `raw` 方法（具体包装逻辑在该类中实现），传入要包装的原始SQL语句字符串，进行包装处理，并返回包装后的对象结果。
   return SqlString.raw(sql);
 };
 
 /**
  * The type constants.
+ * 定义一个名为 `Types` 的属性，通过 `Object.defineProperty` 方法设置其 `get` 访问器属性，使得在访问该属性时会调用 `loadClass` 函数加载名为 `Types` 的类，获取对应的类构造函数或已导出的对象。
+ * 这样可以以一种动态加载的方式获取类型相关的常量（具体常量内容依赖于 `Types` 类的实现），方便外部代码获取和使用这些常量。
  * @public
  */
 Object.defineProperty(exports, 'Types', {
@@ -116,14 +157,17 @@ Object.defineProperty(exports, 'Types', {
 
 /**
  * Load the given class.
- * @param {string} className Name of class to default
- * @return {function|object} Class constructor or exports
+ * 加载指定名称的类，首先会检查之前是否已经加载过该类（通过在 `Classes` 对象中查找），如果已加载则直接返回对应的类构造函数或已导出的对象；
+ * 如果未加载，则根据类名称通过 `switch` 语句进行不同的 `require` 操作来加载相应的模块，获取类的定义，并将加载后的类存储到 `Classes` 对象中，避免下次重复加载，最后返回加载到的类。
+ *
+ * @param {string} className Name of class to default 要加载的类的名称，用于确定加载哪个模块获取对应的类定义。
+ * @return {function|object} Class constructor or exports 返回对应的类构造函数（如果是构造函数形式的类定义）或者已导出的对象（如果模块导出的是对象形式），用于后续创建实例或其他操作。
  * @private
  */
 function loadClass(className) {
   var Class = Classes[className];
 
-  if (Class !== undefined) {
+  if (Class!== undefined) {
     return Class;
   }
 
@@ -158,4 +202,4 @@ function loadClass(className) {
   Classes[className] = Class;
 
   return Class;
-}
+}

node_modules/nano-json-stream-parser/src/index.js

@@ -1,121 +1,147 @@
 // NJSP is just a straightforward monadic parser for JSON.
 
+// 创建一个空对象Read，从后续代码来看，它可能作为一个类似读取流的占位符或者用于标记读取状态等作用，具体功能在代码逻辑中体现。
 const Read = {};
 
+// 定义一个函数error，当调用该函数时，直接抛出一个字符串 "NoParse"，用于在解析出现不符合预期情况时表示解析失败并抛出异常。
 const error = () => {
   throw "NoParse";
 }
 
+// 定义函数readNonWhite，它接受一个字符参数c和一个函数bind作为参数。
+// 其目的是从读取流（通过bind操作关联到后续实际的读取逻辑）中读取下一个非空白字符。
+// 如果传入的字符c已经是非空白字符，则直接将其作为结果传递给后续的bind操作；
+// 如果c是空白字符或者没有传入（即使用默认的Read标记），则继续从读取流中读取下一个字符，直到找到非空白字符为止。
 const readNonWhite = c => bind =>
-  bind(c || Read, c => /\s/.test(c)
-    ? readNonWhite("")(bind)
-    : c);
+    bind(c || Read, c => /\s/.test(c)
+        ? readNonWhite("")(bind)
+        : c);
 
+// 定义函数parseDigits，用于解析数字字符序列，也就是从读取流中读取连续的数字字符，并将其逐步组合起来。
+// 它接受一个字符参数c和一个函数bind作为参数，通过不断调用bind函数与读取流交互，每次读取到数字字符时，将当前字符和已读取到的数字字符序列进行合并处理，继续读取后续数字字符；如果遇到非数字字符，则停止读取数字字符并返回已读取到的结果（包含最后一个非数字字符和已解析的数字字符序列）。
 const parseDigits = c => bind =>
-  bind(c || Read, c => /[0-9]/.test(c)
-    ? bind(parseDigits("")(bind), cs => [cs[0], c + cs[1]])
-    : [c, ""]);
+    bind(c || Read, c => /[0-9]/.test(c)
+        ? bind(parseDigits("")(bind), cs => [cs[0], c + cs[1]])
+        : [c, ""]);
 
-// Well fuck, this is why the do-notation exists
+// 定义函数parseNumber，用于完整地解析一个数字（可以是整数、小数、带有指数表示等多种形式的数字）。
+// 整体逻辑通过多层嵌套的bind操作和条件判断来逐步解析数字的各个部分，如符号位、整数部分、小数部分以及指数部分，最后将解析出的各部分组合成一个JavaScript的数字类型并返回。
+// 以下是详细的各部分解析逻辑注释：
 const parseNumber = c => bind =>
-  // Parses sign
-  bind(c || Read, c => bind(c === "-"
-    ? ["","-"]
-    : [c,""],
-    ([c,sign]) =>
-  // Parses the base digits
-  bind(c || Read, c => bind(c === "0"
-    ? ["","0"]
-    : /[1-9]/.test(c)
-      ? parseDigits(c)(bind)
-      : error(),
-    ([c, base]) =>
-  // Parses the decimal digits
-  bind(c || Read, c => bind(c === "."
-    ? bind(parseDigits("")(bind), ([c,ds]) => [c, "." + ds])
-    : [c, ""],
-    ([c, frac]) =>
-  // Parses the exponent
-  bind(c || Read, c => bind(/[eE]/.test(c)
-    ? bind(bind(Read, c => /[+-]/.test(c) ? ["", "e" + c] : [c, "e"]), ([c,es]) =>
-      bind(parseDigits(c)(bind), ([c,ds]) => [c, es + ds]))
-    : [c, ""],
-    ([c, exp]) =>
-  // Returns the number
-  [c, Number(sign + base + frac + exp)]))))))));
+    // Parses sign（解析符号位）
+    bind(c || Read, c => bind(c === "-"
+            ? ["", "-"]
+            : [c, ""],
+        ([c, sign]) =>
+            // Parses the base digits（解析整数部分）
+            bind(c || Read, c => bind(c === "0"
+                    ? ["", "0"]
+                    : /[1-9]/.test(c)
+                        ? parseDigits(c)(bind)
+                        : error(),
+                ([c, base]) =>
+                    // Parses the decimal digits（解析小数部分）
+                    bind(c || Read, c => bind(c === "."
+                            ? bind(parseDigits("")(bind), ([c, ds]) => [c, "." + ds])
+                            : [c, ""],
+                        ([c, frac]) =>
+                            // Parses the exponent（解析指数部分）
+                            bind(c || Read, c => bind(/[eE]/.test(c)
+                                    ? bind(bind(Read, c => /[+-]/.test(c)? ["", "e" + c] : [c, "e"]), ([c, es]) =>
+                                        bind(parseDigits(c)(bind), ([c, ds]) => [c, es + ds]))
+                                    : [c, ""],
+                                ([c, exp]) =>
+                                    // Returns the number（将各部分组合成最终的数字并返回）
+                                    [c, Number(sign + base + frac + exp)]))))))));
 
+// 定义函数parseHex，用于解析十六进制数字字符。
+// 它从读取流中读取一个十六进制字符，尝试将其转换为对应的十进制整数，如果读取到的字符不符合十六进制字符规范，则抛出异常（通过调用error函数）。
 const parseHex = bind =>
-  bind(Read, h =>
-    /[0-9a-fA-F]/.test(h)
-      ? parseInt(h,16)
-      : error());
+    bind(Read, h =>
+        /[0-9a-fA-F]/.test(h)
+            ? parseInt(h, 16)
+            : error());
 
-const parseString = bind => 
-  bind(bind(Read, c => c !== "\\" ? c :
-    bind(Read, c => 
-      /[\\"\/bfnrt]/.test(c)
-        ? ({b:"\b",f:"\f",n:"\n",r:"\r",t:"\t","\\":"\\","/":"/",'"':''})[c]
-        : /u/.test(c)
-          ? bind(parseHex(bind), a =>
-            bind(parseHex(bind), b =>
-            bind(parseHex(bind), c =>
-            bind(parseHex(bind), d =>
-              String.fromCharCode(a*4096+b*256+c*16+d)))))
-          : error())), c =>
-  c === '"' ? "" : bind(parseString(bind), s => (c||'"') + s));
+// 定义函数parseString，用于解析字符串内容。
+// 它处理字符串中的转义字符（如常见的 \b、\f、\n、\r、\t 等以及Unicode编码表示的字符），按照JSON字符串的解析规则，从读取流中逐步读取字符并构建最终的字符串内容，直到遇到结束的双引号 " 为止。
+const parseString = bind =>
+    bind(bind(Read, c => c!== "\\"? c :
+        bind(Read, c =>
+            /[\\"\/bfnrt]/.test(c)
+                ? ({ b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", "\\": "\\", "/": "/", '"': '"' })[c]
+                : /u/.test(c)
+                    ? bind(parseHex(bind), a =>
+                        bind(parseHex(bind), b =>
+                            bind(parseHex(bind), c =>
+                                bind(parseHex(bind), d =>
+                                    String.fromCharCode(a * 4096 + b * 256 + c * 16 + d)))))
+                    : error())), c =>
+        c === '"'? "" : bind(parseString(bind), s => (c || '"') + s));
 
+// 定义函数parseArray，用于解析JSON数组结构。
+// 它创建一个空数组，通过内部定义的go函数不断从读取流中读取元素，按照JSON数组的语法规则（元素之间以逗号分隔，以 ] 结尾），依次解析每个元素并添加到数组中，直到遇到结束的 ] 字符为止，最后返回解析好的数组。
 const parseArray = bind => {
   let array = [];
   const go = c => bind =>
-    bind(c || Read, c => c === "]" ? array : 
-    bind(parseValue(c)(bind), ([c,value]) => (array.push(value),
-    bind(readNonWhite(c)(bind), c => /[,\]]/.test(c)
-      ? go(c === "," ? "" : c)(bind)
-      : error()))));
+      bind(c || Read, c => c === "]"? array :
+          bind(parseValue(c)(bind), ([c, value]) => (array.push(value),
+              bind(readNonWhite(c)(bind), c => /[,\]]/.test(c)
+                  ? go(c === ","? "" : c)(bind)
+                  : error()))));
   return go("")(bind);
 }
 
+// 定义函数parseObject，用于解析JSON对象结构。
+// 它创建一个空对象，通过内部定义的go函数按照JSON对象的语法规则（键值对之间以 : 分隔，键是字符串且需要用双引号括起来，键值对之间以逗号分隔，以 } 结尾），从读取流中依次读取键和对应的值，并添加到对象中，直到遇到结束的 } 字符为止，最后返回解析好的对象。
 const parseObject = bind => {
   let object = {};
   const go = c => bind =>
-    bind(c || Read, c => c === "}" ? object : 
-    bind(readNonWhite(c)(bind), c => c !== '"' ? error() :
-    bind(parseString(bind), key =>
-    bind(readNonWhite("")(bind), c => c !== ':' ? error() :
-    bind(parseValue("")(bind), ([c,val]) => (object[key] = val,
-    bind(readNonWhite(c)(bind), c => /[,}]/.test(c)
-      ? go(c === "," ? "" : c)(bind)
-      : error())))))));
+      bind(c || Read, c => c === "}"? object :
+          bind(readNonWhite(c)(bind), c => c!== '"'? error() :
+              bind(parseString(bind), key =>
+                  bind(readNonWhite("")(bind), c => c!== ':'? error() :
+                      bind(parseValue("")(bind), ([c, val]) => (object[key] = val,
+                          bind(readNonWhite(c)(bind), c => /[,}]/.test(c)
+                              ? go(c === ","? "" : c)(bind)
+                              : error())))))));
   return go("")(bind);
 }
 
-const parseExact = str => ret => bind => !str
-  ? ret : bind(Read, c => c !== str[0]
-    ? error()
-    : parseExact(str.slice(1))(ret)(bind));
+// 定义函数parseExact，用于精确匹配一段特定的字符串序列。
+// 它接受一个要匹配的字符串str作为参数，如果读取流中的字符与str中的字符依次匹配，则继续匹配下一个字符，直到整个str都匹配成功；如果在匹配过程中出现不一致的字符，则抛出异常（通过调用error函数）。
+const parseExact = str => ret => bind =>!str
+    ? ret : bind(Read, c => c!== str[0]
+        ? error()
+        : parseExact(str.slice(1))(ret)(bind));
 
+// 定义函数parseValue，用于根据读取到的第一个字符判断要解析的数据类型（是数组、对象、字符串、布尔值还是数字等），然后调用相应的解析函数（如parseArray、parseObject等）进行具体的解析操作，并返回解析后的结果（包含最后一个读取的字符和解析出的数据值）。
 const parseValue = c => bind =>
-  bind(readNonWhite(c)(bind), c => 
-    c === "[" ? bind(parseArray(bind), v => ["",v]) :
-    c === "{" ? bind(parseObject(bind), v => ["",v]) :
-    c === '"' ? bind(parseString(bind), v => ["",v]) :
-    c === 't' ? bind(parseExact("rue")(true)(bind), v => ["",v]) :
-    c === 'f' ? bind(parseExact("alse")(false)(bind), v => ["",v]) :
-    parseNumber(c)(bind));
+    bind(readNonWhite(c)(bind), c =>
+        c === "["? bind(parseArray(bind), v => ["", v]) :
+            c === "{"? bind(parseObject(bind), v => ["", v]) :
+                c === '"'? bind(parseString(bind), v => ["", v]) :
+                    c === 't'? bind(parseExact("rue")(true)(bind), v => ["", v]) :
+                        c === 'f'? bind(parseExact("alse")(false)(bind), v => ["", v]) :
+                            parseNumber(c)(bind));
 
+// 定义函数parseStream，它接受一个解析器函数parser作为参数，主要功能是构建一个与读取流交互的绑定函数bind。
+// 通过判断参数a的类型（是Read标记、函数还是其他普通值）来决定如何调用后续的处理函数b，实现了一种灵活的读取流处理逻辑绑定机制，最后返回调用parser函数并传入构建好的bind函数的结果，用于启动整个解析流程。
 const parseStream = parser => {
   const bind = (a, b) =>
-    a === Read
-      ? c => b(c)
-      : typeof a === "function"
-        ? c => bind(a(c), b)
-        : b(a);
+      a === Read
+          ? c => b(c)
+          : typeof a === "function"
+              ? c => bind(a(c), b)
+              : b(a);
   return parser(bind);
 }
 
+// 定义函数parser，它接受一个解析器函数parser（通常是经过parseStream处理后的解析函数）和一个用于获取解析结果的函数getJSON作为参数。
+// 内部创建了一个基于parseStream处理后的解析函数s，并定义了feed函数用于向解析流程中不断输入字符流进行解析。
+// 在feed函数中，通过循环逐个字符地调用s函数进行解析，遇到异常时重置解析状态，当解析出一个完整的数据结构（即s不再是函数类型，表示解析完成）时，调用getJSON函数传递解析结果，并再次重置解析状态，以便继续解析后续的字符流。最后返回feed函数，使得外部可以不断向解析器输入字符流进行解析操作。
 const parser = parser => getJSON => {
   let s = parseStream(parser);
-  const feed = str => { 
+  const feed = str => {
     for (let i = 0, l = str.length; i < l; ++i) {
       try {
         s = s(str[i]);
@@ -123,7 +149,7 @@ const parser = parser => getJSON => {
         s = parseStream(parser);
         break;
       }
-      if (typeof s !== "function") {
+      if (typeof s!== "function") {
         getJSON(s[1]);
         s = parseStream(parser);
       }
@@ -133,4 +159,5 @@ const parser = parser => getJSON => {
   return feed;
 }
 
-module.exports = parser(parseValue(""));
+// 将按照上述逻辑构建好的解析器（通过调用parser函数并传入初始的parseValue("")解析函数）作为模块的导出内容，使得外部模块可以引入并使用这个JSON解析器来解析相应的字符流数据。
+module.exports = parser(parseValue(""));

node_modules/node-addon-api/tools/check-napi.js

@@ -2,99 +2,128 @@
 // Descend into a directory structure and, for each file matching *.node, output
 // based on the imports found in the file whether it's an N-API module or not.
 
+// 引入Node.js的文件系统模块 'fs'，用于执行文件系统相关的操作，比如读取目录内容、获取文件状态等。
 const fs = require('fs');
+// 引入Node.js的路径模块 'path'，用于处理文件路径的拼接、解析等操作，方便在不同操作系统下正确操作文件路径。
 const path = require('path');
+// 引入Node.js的子进程模块 'child_process'，用于创建和管理子进程，可在Node.js应用中执行外部命令等操作。
 const child_process = require('child_process');
 
-// Read the output of the command, break it into lines, and use the reducer to
-// decide whether the file is an N-API module or not.
+// 此函数用于检查给定的文件是否为N-API模块。它通过启动一个子进程执行指定的命令，并传递相应的参数，然后监听子进程的标准输出和关闭事件来判断文件的性质。
+// 参数说明：
+// - file：要检查的文件路径。
+// - command：要执行的命令，例如在UNIX系统下可能是 'nm'，在Windows系统下可能是 'dumpbin' 等用于查看符号信息的命令。
+// - argv：传递给命令的参数数组，用于指定命令的具体执行方式，如额外的选项等。
+// - reducer：一个回调函数，用于处理子进程输出的每一行数据，根据一定规则判断文件是否为N-API模块，并逐步汇总判断结果。
 function checkFile(file, command, argv, reducer) {
+  // 使用 'child_process.spawn' 方法创建一个子进程来执行指定的命令，传递相应的参数，并配置子进程的标准输入、输出和错误输出流。
+  // 这里将标准输入流设置为 'inherit'，表示继承父进程（当前Node.js进程）的标准输入；标准输出流设置为 'pipe'，表示将子进程的输出通过管道传输，以便后续在Node.js中读取；标准错误输出流设置为 'inherit'，同样继承父进程的标准错误输出。
   const child = child_process.spawn(command, argv, {
     stdio: ['inherit', 'pipe', 'inherit']
   });
+  // 用于存储上一次读取子进程输出数据时剩余未处理完的部分，可能是因为数据刚好在换行符中间截断等情况导致的。
   let leftover = '';
+  // 用于记录文件是否为N-API模块的判断结果，初始值设为 'undefined'，表示尚未确定。
   let isNapi = undefined;
+  // 监听子进程的标准输出流的 'data' 事件，当子进程有新的输出数据时会触发该事件，在此事件处理函数中进行相应的处理。
   child.stdout.on('data', (chunk) => {
+    // 如果当前还未确定文件是否为N-API模块（即 'isNapi' 仍为 'undefined'），则进行以下处理。
     if (isNapi === undefined) {
+      // 将剩余未处理的数据和本次接收到的新数据块拼接起来，并按换行符（'\r\n' 或 '\n'）进行分割，得到一个包含每行数据的数组，模拟按行读取完整输出内容的效果。
       chunk = (leftover + chunk.toString()).split(/[\r\n]+/);
+      // 将分割后的数组的最后一个元素取出，作为剩余未处理完的数据，存储到 'leftover' 变量中，因为它可能是不完整的一行，留待下次处理。
       leftover = chunk.pop();
+      // 使用'reducer' 回调函数对分割后的每一行数据进行处理，将当前的判断结果（初始为 'undefined'）和每一行数据作为参数传递给'reducer'，通过'reducer' 函数内部的逻辑逐步更新判断结果，并将最终结果重新赋值给 'isNapi'。
       isNapi = chunk.reduce(reducer, isNapi);
-      if (isNapi !== undefined) {
+      // 如果经过处理后已经确定了文件是否为N-API模块（即 'isNapi' 不再是 'undefined'），则终止子进程，避免不必要的资源消耗，因为已经得到了需要的判断结果。
+      if (isNapi!== undefined) {
         child.kill();
       }
     }
   });
+  // 监听子进程的 'close' 事件，当子进程结束运行时会触发该事件，在此事件处理函数中根据子进程的退出状态码和终止信号等信息进行相应的处理和输出。
   child.on('close', (code, signal) => {
-    if ((code === null && signal !== null) || (code !== 0)) {
+    // 如果子进程的退出状态码为 'null' 且终止信号不为 'null'，或者退出状态码不为0，表示子进程是非正常结束的，可能是命令执行出错等情况，此时向控制台输出相应的错误提示信息，展示命令的退出状态码和终止信号内容。
+    if ((code === null && signal!== null) || (code!== 0)) {
       console.log(
-        command + ' exited with code: '  + code + ' and signal: ' + signal);
+        command +'exited with code:'+ code +'and signal:'+ signal);
     } else {
-      // Green if it's a N-API module, red otherwise.
+      // 如果子进程正常结束，根据文件是否为N-API模块（通过 'isNapi' 的值判断），以不同颜色在控制台输出相应的提示信息，绿色（'\x1b[42m' 是设置终端背景色为绿色的ANSI转义序列）表示是N-API模块，红色（'\x1b[41m' 是设置终端背景色为红色的ANSI转义序列）表示不是N-API模块，并同时输出文件的路径信息，最后使用 '\x1b[0m' 恢复终端的默认颜色设置。
       console.log(
-          '\x1b[' + (isNapi ? '42' : '41') + 'm' +
-          (isNapi ? '    N-API' : 'Not N-API') +
-          '\x1b[0m: ' + file);
+        '\x1b[' + (isNapi? '42' : '41') +'m' +
+        (isNapi?'   N-API' : 'Not N-API') +
+        '\x1b[0m:'+ file);
     }
   });
 }
 
-// Use nm -a to list symbols.
+// 此函数用于在UNIX系统下检查给定的文件是否为N-API模块。它调用 'checkFile' 函数，并传入适用于UNIX系统的命令（'nm'）及其参数，以及特定的用于处理输出结果的'reducer' 回调函数来进行判断。
 function checkFileUNIX(file) {
   checkFile(file, 'nm', ['-a', file], (soFar, line) => {
+    // 如果当前还未确定文件是否为N-API模块（即'soFar' 为 'undefined'），则进行以下处理，尝试从输出的每一行数据中提取相关信息并判断是否包含N-API相关的符号。
     if (soFar === undefined) {
+      // 使用正则表达式匹配每一行数据，尝试提取出符号地址（可能为空）、符号类型和符号名称等信息，将匹配结果存储在 'line' 数组中（如果匹配成功）。
       line = line.match(/([0-9a-f]*)? ([a-zA-Z]) (.*$)/);
+      // 如果匹配到的符号类型为 'U'（表示未定义的符号，通常是依赖外部库提供的符号），进一步检查符号名称是否以 'napi' 开头，如果是，则认为该文件可能是N-API模块，将'soFar' 设置为 'true'，表示初步判断为是N-API模块。
       if (line[2] === 'U') {
         if (/^napi/.test(line[3])) {
           soFar = true;
         }
       }
     }
+    // 返回当前的判断结果（可能是 'undefined' 或者 'true'），以便 'checkFile' 函数中的'reduce' 操作能继续汇总判断结果。
     return soFar;
   });
 }
 
-// Use dumpbin /imports to list symbols.
+// 此函数用于在Windows系统下检查给定的文件是否为N-API模块。它同样调用 'checkFile' 函数，但传入适用于Windows系统的命令（'dumpbin'）及其参数，以及对应的用于处理输出结果的'reducer' 回调函数来进行判断。
 function checkFileWin32(file) {
   checkFile(file, 'dumpbin', ['/imports', file], (soFar, line) => {
+    // 如果当前还未确定文件是否为N-API模块（即'soFar' 为 'undefined'），则进行以下处理，尝试从输出的每一行数据中提取相关信息并判断是否包含N-API相关的符号。
     if (soFar === undefined) {
+      // 使用正则表达式匹配每一行数据，尝试提取出符号地址（可能为空）、符号类型和符号名称等信息，将匹配结果存储在 'line' 数组中（如果匹配成功）。注意这里的正则表达式与UNIX系统下的稍有不同，以适配 'dumpbin' 命令输出的格式特点。
       line = line.match(/([0-9a-f]*)? +([a-zA-Z0-9]) (.*$)/);
+      // 如果匹配结果存在（即 'line' 不为 'null'），并且符号名称（取匹配结果数组的最后一个元素）以 'napi' 开头，则认为该文件可能是N-API模块，将'soFar' 设置为 'true'，表示初步判断为是N-API模块。
       if (line && /^napi/.test(line[line.length - 1])) {
         soFar = true;
       }
     }
+    // 返回当前的判断结果（可能是 'undefined' 或者 'true'），以便 'checkFile' 函数中的'reduce' 操作能继续汇总判断结果。
     return soFar;
   });
 }
 
-// Descend into a directory structure and pass each file ending in '.node' to
-// one of the above checks, depending on the OS.
+// 此函数用于递归遍历给定的目录及其子目录结构，对每个以 '.node' 结尾的文件，根据当前操作系统类型调用相应的文件检查函数（'checkFileUNIX' 或 'checkFileWin32'）来判断是否为N-API模块。
 function recurse(top) {
+  // 使用 'fs.readdir' 方法读取指定目录下的所有文件和子目录名称，读取成功后会触发回调函数，在回调函数中进行后续处理，如果读取过程出现错误，则抛出相应的错误信息，提示读取目录时出错以及具体的错误内容。
   fs.readdir(top, (error, items) => {
     if (error) {
       throw ("error reading directory " + top + ": " + error);
     }
+    // 遍历读取到的文件和子目录名称数组，对每个元素进行相应处理。
     items.forEach((item) => {
+      // 将当前元素（文件或子目录名称）与给定的目录路径拼接起来，得到完整的文件或子目录路径，方便后续操作。
       item = path.join(top, item);
+      // 使用 'fs.stat' 方法获取指定文件或目录的状态信息（例如是文件还是目录、文件大小、创建时间等），获取成功后会触发回调函数，在回调函数中根据状态信息进行进一步处理，如果获取过程出现错误，则抛出相应的错误信息，提示获取该文件或目录状态时出错以及具体的错误内容。
       fs.stat(item, ((item) => (error, stats) => {
         if (error) {
           throw ("error about " + item + ": " + error);
         }
+        // 如果获取到的状态信息表明当前路径对应的是一个目录，则递归调用'recurse' 函数，继续遍历该子目录及其下的内容。
         if (stats.isDirectory()) {
           recurse(item);
         } else if (/[.]node$/.test(item) &&
-            // Explicitly ignore files called 'nothing.node' because they are
-            // artefacts of node-addon-api having identified a version of
-            // Node.js that ships with a correct implementation of N-API.
-            path.basename(item) !== 'nothing.node') {
-          process.platform === 'win32' ?
-              checkFileWin32(item) :
-              checkFileUNIX(item);
+          // 额外的条件判断，明确忽略名为 'nothing.node' 的文件，因为它可能是 'node-addon-api' 在识别Node.js版本时产生的特定产物（根据注释说明），这些文件不需要进行N-API模块的检查。
+          path.basename(item)!== 'nothing.node') {
+          // 根据当前Node.js进程运行的操作系统平台类型（通过 'process.platform' 获取），选择调用相应的文件检查函数（在Windows系统下调用 'checkFileWin32'，在UNIX系统下调用 'checkFileUNIX'）来检查当前的 '.node' 文件是否为N-API模块。
+          process.platform === 'win32'?
+            checkFileWin32(item) :
+            checkFileUNIX(item);
         }
       })(item));
     });
   });
 }
 
-// Start with the directory given on the command line or the current directory
-// if nothing was given.
-recurse(process.argv.length > 3 ? process.argv[2] : '.');
+// 根据命令行参数来决定从哪个目录开始进行文件检查。如果命令行参数长度大于3（表示有指定要检查的目录路径作为第三个参数），则从指定的目录开始；否则，从当前目录（'.' 表示当前目录）开始，调用'recurse' 函数启动整个目录遍历和文件检查的流程。
+recurse(process.argv.length > 3? process.argv[2] : '.');

node_modules/node-gyp-build/node-gyp-build.js

@@ -1,134 +1,212 @@
-var fs = require('fs')
-var path = require('path')
-var os = require('os')
-
-// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
-var runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require // eslint-disable-line
-
-var vars = (process.config && process.config.variables) || {}
-var prebuildsOnly = !!process.env.PREBUILDS_ONLY
-var abi = process.versions.modules // TODO: support old node where this is undef
-var runtime = isElectron() ? 'electron' : (isNwjs() ? 'node-webkit' : 'node')
-
-var arch = process.env.npm_config_arch || os.arch()
-var platform = process.env.npm_config_platform || os.platform()
-var libc = process.env.LIBC || (isAlpine(platform) ? 'musl' : 'glibc')
-var armv = process.env.ARM_VERSION || (arch === 'arm64' ? '8' : vars.arm_version) || ''
-var uv = (process.versions.uv || '').split('.')[0]
-
-module.exports = load
-
+// 引入Node.js的文件系统模块 'fs'，用于操作文件系统，例如读取文件、读取目录内容等。
+var fs = require('fs');
+// 引入Node.js的路径模块 'path'，用于处理文件路径相关的操作，如路径拼接、路径解析等。
+var path = require('path');
+// 引入Node.js的操作系统模块 'os'，用于获取操作系统相关的信息，像系统架构、操作系统平台等。
+var os = require('os');
+
+// 这是一个解决Webpack构建警告的变通方法。如果在Webpack环境中（即 '__webpack_require__' 是一个函数），
+// 则使用 '__non_webpack_require__'（可能是自定义的一个避免Webpack相关问题的require替代方式）来加载模块；
+// 否则，使用普通的'require' 函数来加载模块。同时，这里禁用了ESLint的相关规则检查（'eslint-disable-line'），
+// 可能是因为该语句的写法不符合某些ESLint默认规范，但在这个特定场景下是有意为之的处理方式。
+var runtimeRequire = typeof __webpack_require__ === 'function'? __non_webpack_require__ : require // eslint-disable-line
+
+// 获取Node.js进程配置中的变量信息（如果有的话），如果不存在则使用一个空对象。这里的变量信息可能是在启动Node.js进程时通过特定方式设置的，
+// 用于在不同环境下传递一些自定义的配置参数等。
+var vars = (process.config && process.config.variables) || {};
+// 通过检查环境变量 'PREBUILDS_ONLY' 的值来确定是否只使用预构建版本，若该环境变量存在（其值转换为布尔值为 'true'），则表示只使用预构建版本，
+// 否则表示不只局限于预构建版本，还可以考虑其他构建方式生成的文件等情况。
+var prebuildsOnly =!!process.env.PREBUILDS_ONLY;
+// 获取Node.js进程中模块的ABI（应用二进制接口）版本信息，尝试从 'process.versions.modules' 获取，不过代码中也提到了对于旧版本Node.js（该属性可能未定义的情况）后续还需要支持处理，目前先按此方式获取。
+var abi = process.versions.modules; // TODO: support old node where this is undef
+// 根据当前运行环境判断运行时环境类型，先通过 'isElectron' 函数判断是否是Electron应用环境，如果是则设置为 'electron'；
+// 如果不是，再通过 'isNwjs' 函数判断是否是NW.js（node-webkit）环境，如果是则设置为 'node-webkit'；
+// 如果都不是，则默认设置为 'node'，用于后续在加载不同运行时对应的构建文件等操作中区分环境类型。
+var runtime = isElectron()? 'electron' : (isNwjs()? 'node-webkit' : 'node');
+
+// 获取架构信息，优先从环境变量 'npm_config_arch' 中获取，如果不存在该环境变量，则通过 'os.arch()' 方法获取操作系统的架构信息（例如 'x64'、'arm64' 等）。
+var arch = process.env.npm_config_arch || os.arch();
+// 获取操作系统平台信息，优先从环境变量 'npm_config_platform' 中获取，如果不存在该环境变量，则通过 'os.platform()' 方法获取操作系统平台名称（例如 'darwin'、'linux'、'win32' 等）。
+var platform = process.env.npm_config_platform || os.platform();
+// 获取C标准库相关信息，优先从环境变量 'LIBC' 中获取，如果不存在该环境变量，则通过 'isAlpine' 函数判断当前操作系统平台是否是Alpine Linux（一种轻量级Linux发行版），
+// 如果是则设置为'musl'（Alpine Linux常用的C标准库），否则设置为 'glibc'（常见的GNU C标准库）。
+var libc = process.env.LIBC || (isAlpine(platform)?'musl' : 'glibc');
+// 获取ARM版本信息，优先从环境变量 'ARM_VERSION' 中获取，如果不存在该环境变量，再判断当前架构是否是 'arm64'，如果是则设置为 '8'，
+// 若都不满足，则尝试从之前获取的自定义变量 'vars.arm_version' 中获取（如果有定义），如果还是获取不到则设置为空字符串。
+var armv = process.env.ARM_VERSION || (arch === 'arm64'? '8' : vars.arm_version) || '';
+// 获取libuv的主版本号信息，通过获取 'process.versions.uv' 的值（如果有定义），然后按 '.' 分割取第一个元素（即主版本号），如果不存在则使用空字符串。
+var uv = (process.versions.uv || '').split('.')[0];
+
+// 将 'load' 函数作为模块的导出内容，外部模块可以通过引入该模块来调用 'load' 函数进行相应的文件加载等操作。
+module.exports = load;
+
+// 'load' 函数用于加载指定目录下的相关文件（从后续逻辑来看主要是查找并加载合适的预构建文件等），
+// 它内部通过调用 'runtimeRequire' 函数（前面定义的根据环境选择的加载模块方式）并传入通过 'load.resolve' 方法（实际上与 'load.path' 指向同一个函数，用于解析文件路径）解析后的路径来实现文件加载。
 function load (dir) {
-  return runtimeRequire(load.resolve(dir))
+  return runtimeRequire(load.resolve(dir));
 }
 
+// 为 'load' 函数添加'resolve' 和 'path' 属性，并将它们指向同一个函数，这个函数用于解析给定目录的路径，
+// 并进一步查找和确定最终要加载的具体文件路径，其内部包含了一系列复杂的逻辑来根据不同条件筛选合适的文件。
 load.resolve = load.path = function (dir) {
-  dir = path.resolve(dir || '.')
+  // 使用 'path.resolve' 方法将传入的目录路径（如果未传入则默认为当前目录 '.'）解析为绝对路径，方便后续操作和确保路径的准确性。
+  dir = path.resolve(dir || '.');
 
   try {
-    var name = runtimeRequire(path.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_')
-    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD']
+    // 尝试读取指定目录下的 'package.json' 文件，通过'require'（这里实际上是 'runtimeRequire'）加载该文件内容，
+    // 获取其中的 'name' 属性并转换为大写字母形式，同时将其中的 '-' 替换为 '_'，目的可能是为了后续按照某种规范格式来查找对应的环境变量或者进行其他匹配操作等。
+    var name = runtimeRequire(path.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_');
+    // 检查是否存在以该名称加上 '_PREBUILD' 为名称的环境变量，如果存在，则将当前要查找文件的目录路径更新为该环境变量的值，
+    // 表示按照环境变量指定的特定预构建路径去查找文件，可能用于覆盖默认的查找路径逻辑，按照项目自定义的配置来查找相应的预构建文件。
+    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD'];
   } catch (err) {}
 
+  // 如果不只是限制使用预构建版本（即 'prebuildsOnly' 为 'false'），则进行以下查找逻辑，尝试在 'build/Release' 目录下查找符合条件的文件。
   if (!prebuildsOnly) {
-    var release = getFirst(path.join(dir, 'build/Release'), matchBuild)
-    if (release) return release
-
-    var debug = getFirst(path.join(dir, 'build/Debug'), matchBuild)
-    if (debug) return debug
+    // 调用 'getFirst' 函数在 'build/Release' 目录下查找第一个符合'matchBuild' 函数定义的匹配规则（即文件名以 '.node' 结尾）的文件，
+    // 如果找到则返回该文件的完整路径，作为最终要加载的文件路径，查找过程结束。
+    var release = getFirst(path.join(dir, 'build/Release'), matchBuild);
+    if (release) return release;
+
+    // 如果在 'build/Release' 目录下没有找到合适的文件，则尝试在 'build/Debug' 目录下进行同样的查找操作，查找第一个符合匹配规则的文件，
+    // 如果找到则返回其完整路径作为最终要加载的文件路径。
+    var debug = getFirst(path.join(dir, 'build/Debug'), matchBuild);
+    if (debug) return debug;
   }
 
-  var prebuild = resolve(dir)
-  if (prebuild) return prebuild
+  // 调用'resolve' 函数（内部定义的一个用于查找预构建文件的函数，在后面有具体实现）尝试查找预构建文件，如果找到则返回其路径作为最终要加载的文件路径。
+  var prebuild = resolve(dir);
+  if (prebuild) return prebuild;
 
-  var nearby = resolve(path.dirname(process.execPath))
-  if (nearby) return nearby
+  // 如果前面的查找都没有找到合适的文件，则尝试在Node.js可执行文件所在目录（通过 'process.execPath' 获取可执行文件路径，再取其目录部分）的相关位置查找预构建文件，
+  // 调用'resolve' 函数进行查找，如果找到则返回其路径作为最终要加载的文件路径。
+  var nearby = resolve(path.dirname(process.execPath));
+  if (nearby) return nearby;
 
+  // 如果所有的查找尝试都失败了，构建一个描述目标环境信息的字符串，包含操作系统平台、架构、运行时环境、ABI版本、libuv版本、ARM版本、C标准库以及Node.js版本等信息，
+  // 每个信息通过 '=' 连接成键值对形式，中间用空格分隔，并且通过 'filter(Boolean)' 过滤掉为空字符串的元素，确保字符串内容准确反映当前环境的关键配置信息。
   var target = [
     'platform=' + platform,
     'arch=' + arch,
     'runtime=' + runtime,
     'abi=' + abi,
     'uv=' + uv,
-    armv ? 'armv=' + armv : '',
+    armv? 'armv=' + armv : '',
     'libc=' + libc,
     'node=' + process.versions.node,
-    process.versions.electron ? 'electron=' + process.versions.electron : '',
-    typeof __webpack_require__ === 'function' ? 'webpack=true' : '' // eslint-disable-line
-  ].filter(Boolean).join(' ')
+    process.versions.electron? 'electron=' + process.versions.electron : '',
+    typeof __webpack_require__ === 'function'? 'webpack=true' : '' // eslint-disable-line
+  ].filter(Boolean).join(' ');
 
-  throw new Error('No native build was found for ' + target + '\n    loaded from: ' + dir + '\n')
+  // 如果最终还是没有找到合适的本地构建文件，则抛出一个错误，提示没有找到对应目标环境的本地构建文件，并展示目标环境信息以及最初尝试加载文件的目录路径信息，方便排查问题。
+  throw new Error('No native build was found for'+ target + '\n    loaded from: '+ dir + '\n');
 
+  // 以下是'resolve' 函数的具体定义，它用于在指定目录下查找符合特定条件的预构建文件路径。
   function resolve (dir) {
-    // Find matching "prebuilds/<platform>-<arch>" directory
-    var tuples = readdirSync(path.join(dir, 'prebuilds')).map(parseTuple)
-    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0]
-    if (!tuple) return
-
-    // Find most specific flavor first
-    var prebuilds = path.join(dir, 'prebuilds', tuple.name)
-    var parsed = readdirSync(prebuilds).map(parseTags)
-    var candidates = parsed.filter(matchTags(runtime, abi))
-    var winner = candidates.sort(compareTags(runtime))[0]
-    if (winner) return path.join(prebuilds, winner.file)
+    // 读取指定目录下 'prebuilds' 子目录中的所有文件和目录名称，通过'readdirSync' 函数（后面有定义，用于同步读取目录内容）获取，
+    // 并对每个名称调用 'parseTuple' 函数（后面有定义，用于解析名称格式并提取相关信息）将其转换为包含平台、架构等信息的对象形式，最终得到一个包含这些信息对象的数组。
+    var tuples = readdirSync(path.join(dir, 'prebuilds')).map(parseTuple);
+    // 从解析后的信息对象数组中筛选出与当前操作系统平台和架构匹配的对象，通过'matchTuple' 函数（后面有定义，用于进行匹配判断）进行筛选，
+    // 然后对筛选后的结果按照 'compareTuples' 函数（后面有定义，用于比较排序，这里优先选择架构单一的预构建，通过比较架构数量来排序）定义的规则进行排序，取第一个元素作为最匹配的信息对象（如果有匹配的话）。
+    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+    if (!tuple) return;
+
+    // 根据找到的最匹配的信息对象中的名称，构建出对应的预构建文件所在的目录路径，即 'prebuilds' 目录下对应的平台 - 架构目录。
+    var prebuilds = path.join(dir, 'prebuilds', tuple.name);
+    // 读取该预构建目录下的所有文件名称，通过'readdirSync' 函数获取，然后对每个文件名称调用 'parseTags' 函数（后面有定义，用于解析文件名称中的各种标签信息）将其转换为包含运行时、ABI、libuv等多种标签信息以及特异性（specificity，用于后续排序比较）的对象形式，最终得到一个包含这些信息对象的数组。
+    var parsed = readdirSync(prebuilds).map(parseTags);
+    // 从解析后的信息对象数组中筛选出与当前运行时环境和ABI版本匹配的对象，通过'matchTags' 函数（后面有定义，用于进行匹配判断）进行筛选，得到符合条件的候选文件信息对象数组。
+    var candidates = parsed.filter(matchTags(runtime, abi));
+    // 对候选文件信息对象数组按照 'compareTags' 函数（后面有定义，用于比较排序，根据运行时、ABI以及特异性等因素确定优先级）定义的规则进行排序，取第一个元素作为最匹配的文件信息对象（如果有匹配的话），
+    // 如果找到最匹配的文件信息对象，则返回该文件在文件系统中的完整路径，即最终找到的合适的预构建文件路径。
+    var winner = candidates.sort(compareTags(runtime))[0];
+    if (winner) return path.join(prebuilds, winner.file);
   }
 }
 
+// 定义'readdirSync' 函数，用于同步读取指定目录下的所有文件和目录名称，它内部通过调用 'fs.readdirSync' 方法来实现读取操作，
+// 如果读取过程中出现错误（例如目录不存在等情况），则返回一个空数组，避免后续代码因为读取失败而报错，以一种相对稳健的方式处理目录读取操作。
 function readdirSync (dir) {
   try {
-    return fs.readdirSync(dir)
+    return fs.readdirSync(dir);
   } catch (err) {
-    return []
+    return [];
   }
 }
 
+// 定义 'getFirst' 函数，用于在指定目录下查找第一个符合给定过滤条件的文件，并返回该文件的完整路径。
+// 它首先通过'readdirSync' 函数读取指定目录下的所有文件和目录名称，然后使用传入的过滤函数 'filter' 对这些名称进行筛选，
+// 如果筛选后得到的数组不为空（即找到了符合条件的文件），则将该文件名称与指定目录路径拼接起来，得到文件的完整路径并返回；如果没有找到符合条件的文件，则返回 'null'。
 function getFirst (dir, filter) {
-  var files = readdirSync(dir).filter(filter)
-  return files[0] && path.join(dir, files[0])
+  var files = readdirSync(dir).filter(filter);
+  return files[0] && path.join(dir, files[0]);
 }
 
+// 定义'matchBuild' 函数，用于判断给定的文件名是否符合特定的构建文件格式要求，这里的要求是文件名以 '.node' 结尾，
+// 通过正则表达式 '/\.node$/.test(name)' 来进行判断，如果文件名符合要求则返回 'true'，否则返回 'false'，用于在查找合适的构建文件时进行文件名的匹配筛选。
 function matchBuild (name) {
-  return /\.node$/.test(name)
+  return /\.node$/.test(name);
 }
 
+// 定义 'parseTuple' 函数，用于解析一个类似 "darwin-x64+arm64" 格式的字符串，将其拆分为平台和架构相关的信息，并封装成一个包含这些信息的对象返回。
+// 具体逻辑是先按 '-' 分割字符串得到包含平台和架构部分的数组，如果数组长度不等于2则返回 'null'（表示格式不符合要求无法解析），
+// 然后将架构部分再按 '+' 分割得到具体的架构列表，如果平台为空、架构列表为空或者架构列表中存在空元素，则同样返回 'null'，
+// 只有当解析出的平台和架构信息都合法时，才返回一个包含名称、平台和架构信息的对象，方便后续根据这些信息进行匹配和筛选等操作。
 function parseTuple (name) {
   // Example: darwin-x64+arm64
-  var arr = name.split('-')
-  if (arr.length !== 2) return
+  var arr = name.split('-');
+  if (arr.length!== 2) return;
 
-  var platform = arr[0]
-  var architectures = arr[1].split('+')
+  var platform = arr[0];
+  var architectures = arr[1].split('+');
 
-  if (!platform) return
-  if (!architectures.length) return
-  if (!architectures.every(Boolean)) return
+  if (!platform) return;
+  if (!architectures.length) return;
+  if (!architectures.every(Boolean)) return;
 
-  return { name, platform, architectures }
+  return { name, platform, architectures };
 }
 
+// 定义'matchTuple' 函数，它返回一个内部函数，用于判断给定的信息对象（通过 'parseTuple' 函数解析得到的包含平台和架构等信息的对象）是否与指定的操作系统平台和架构匹配。
+// 内部函数接收一个信息对象作为参数，如果该对象为 'null'，则直接返回 'false'；如果对象中的平台信息与传入的指定平台不匹配，也返回 'false'；
+// 只有当平台匹配且对象中的架构列表包含传入的指定架构时，才返回 'true'，用于在筛选符合当前操作系统平台和架构的预构建相关信息时进行匹配判断。
 function matchTuple (platform, arch) {
   return function (tuple) {
-    if (tuple == null) return false
-    if (tuple.platform !== platform) return false
-    return tuple.architectures.includes(arch)
+    if (tuple == null) return false;
+    if (tuple.platform!== platform) return false;
+    return tuple.architectures.includes(arch);
   }
 }
 
+// 定义 'compareTuples' 函数，用于比较两个通过 'parseTuple' 函数解析得到的信息对象，比较规则是根据架构数量来判断优先级，
+// 返回两个对象的架构数量之差，目的是在筛选和排序预构建相关信息时，优先选择架构单一的情况（架构数量少的排在前面），
+// 这样可以更精准地匹配特定架构的预构建文件等情况，符合一般的选择优先级逻辑。
 function compareTuples (a, b) {
   // Prefer single-arch prebuilds over multi-arch
-  return a.architectures.length - b.architectures.length
+  return a.architectures.length - b.architectures.length;
 }
 
-function parseTags (file) {
+// 定义 'parseTags' 函数，用于解析文件名中的各种标签信息，例如文件名格式可能类似 "node.abi12.uv1.electron" 这样包含了运行时、ABI、libuv等相关信息的
+
+// 解析文件名并提取标签信息
+function parseTags(file) {
+  // 将文件名按"."分隔成数组
   var arr = file.split('.')
+
+  // 弹出最后一个元素作为文件扩展名
   var extension = arr.pop()
+
+  // 初始化tags对象，包含文件名和默认的特异性
   var tags = { file: file, specificity: 0 }
 
+  // 如果扩展名不是"node"，则返回undefined
   if (extension !== 'node') return
 
+  // 遍历文件名中剩下的部分，并根据规则提取标签
   for (var i = 0; i < arr.length; i++) {
     var tag = arr[i]
 
+    // 根据标签名称设置不同的tag属性
     if (tag === 'node' || tag === 'electron' || tag === 'node-webkit') {
       tags.runtime = tag
     } else if (tag === 'napi') {
@@ -145,63 +223,98 @@ function parseTags (file) {
       continue
     }
 
+    // 增加特异性，表示解析的标签数量
     tags.specificity++
   }
 
+  // 返回解析后的tags对象
   return tags
 }
 
-function matchTags (runtime, abi) {
-  return function (tags) {
+// 匹配标签，返回一个函数用于过滤符合条件的tags
+function matchTags(runtime, abi) {
+  return function(tags) {
+    // 如果tags为空，返回false
     if (tags == null) return false
+
+    // 如果tags.runtime存在且与传入的runtime不匹配，并且不是agnostic（不关心runtime），则返回false
     if (tags.runtime && tags.runtime !== runtime && !runtimeAgnostic(tags)) return false
+
+    // 如果tags.abi存在且不匹配传入的abi，并且tags.napi不存在，返回false
     if (tags.abi && tags.abi !== abi && !tags.napi) return false
+
+    // 如果tags.uv存在且不匹配传入的uv，返回false
     if (tags.uv && tags.uv !== uv) return false
+
+    // 如果tags.armv存在且不匹配传入的armv，返回false
     if (tags.armv && tags.armv !== armv) return false
+
+    // 如果tags.libc存在且不匹配传入的libc，返回false
     if (tags.libc && tags.libc !== libc) return false
 
+    // 其他情况返回true
     return true
   }
 }
 
-function runtimeAgnostic (tags) {
+// 判断tags是否是运行时无关的（即runtime为'node'并且有napi）
+function runtimeAgnostic(tags) {
   return tags.runtime === 'node' && tags.napi
 }
 
-function compareTags (runtime) {
-  // Precedence: non-agnostic runtime, abi over napi, then by specificity.
-  return function (a, b) {
+// 比较两个tags对象的优先级
+function compareTags(runtime) {
+  // 按照优先级进行排序，优先考虑非agnostic的runtime，abi优先于napi，然后是特异性
+  return function(a, b) {
+    // 如果a和b的runtime不同，返回runtime优先级的比较结果
     if (a.runtime !== b.runtime) {
       return a.runtime === runtime ? -1 : 1
-    } else if (a.abi !== b.abi) {
+    }
+    // 如果a和b的abi不同，返回abi优先级的比较结果
+    else if (a.abi !== b.abi) {
       return a.abi ? -1 : 1
-    } else if (a.specificity !== b.specificity) {
+    }
+    // 如果a和b的特异性不同，返回特异性优先级的比较结果
+    else if (a.specificity !== b.specificity) {
       return a.specificity > b.specificity ? -1 : 1
-    } else {
+    }
+    // 如果都相等，则返回0
+    else {
       return 0
     }
   }
 }
 
-function isNwjs () {
+// 判断当前环境是否是NW.js
+function isNwjs() {
+  // 如果process.versions中包含nw，则表示当前环境是NW.js
   return !!(process.versions && process.versions.nw)
 }
 
-function isElectron () {
+// 判断当前环境是否是Electron
+function isElectron() {
+  // 如果process.versions中包含electron，则表示当前环境是Electron
   if (process.versions && process.versions.electron) return true
+
+  // 如果环境变量ELECTRON_RUN_AS_NODE存在，则表示Electron
   if (process.env.ELECTRON_RUN_AS_NODE) return true
+
+  // 如果window对象存在且window.process.type为'renderer'，则也表示Electron
   return typeof window !== 'undefined' && window.process && window.process.type === 'renderer'
 }
 
-function isAlpine (platform) {
+// 判断当前平台是否是 Alpine Linux
+function isAlpine(platform) {
+  // 如果平台是 'linux' 且 '/etc/alpine-release' 文件存在，返回 true，表示是 Alpine Linux
   return platform === 'linux' && fs.existsSync('/etc/alpine-release')
 }
 
-// Exposed for unit tests
-// TODO: move to lib
-load.parseTags = parseTags
-load.matchTags = matchTags
-load.compareTags = compareTags
-load.parseTuple = parseTuple
-load.matchTuple = matchTuple
-load.compareTuples = compareTuples
+// 将以下函数暴露到 `load` 对象中，方便在单元测试中使用
+// TODO: 将这些函数迁移到 lib 文件中
+load.parseTags = parseTags // 将 `parseTags` 函数暴露到 `load` 对象
+load.matchTags = matchTags // 将 `matchTags` 函数暴露到 `load` 对象
+load.compareTags = compareTags // 将 `compareTags` 函数暴露到 `load` 对象
+load.parseTuple = parseTuple // 将 `parseTuple` 函数暴露到 `load` 对象
+load.matchTuple = matchTuple // 将 `matchTuple` 函数暴露到 `load` 对象
+load.compareTuples = compareTuples // 将 `compareTuples` 函数暴露到 `load` 对象
+

node_modules/oboe/Gruntfile.js

@@ -1,5 +1,9 @@
+// 将一个函数作为模块的导出内容，这个函数接收 `grunt` 对象作为参数，`grunt` 是 Grunt 构建工具的核心对象，
+// 通常用于配置任务、加载插件以及执行各种构建相关的操作，在这里的函数内部会基于 `grunt` 进行一系列任务的配置和定义。
 module.exports = function (grunt) {
+  // 定义 `runNpmScript` 函数，用于运行 `npm` 脚本命令，它接收要执行的 `npm` 脚本命令名称（`command`）以及一个回调函数（`cb`）作为参数。
   function runNpmScript (command, cb) {
+    // 配置执行 `npm` 脚本的相关选项，创建一个包含 `cmd`（要执行的命令，这里固定为 `npm`）、`args`（传递给 `npm` 命令的参数数组，这里包含 `run` 和具体的脚本命令名称）以及 `opts`（执行命令的其他选项，这里设置 `stdio` 为 `inherit`，表示继承父进程的标准输入、输出和错误输出流，使得执行过程中的信息能直接在终端显示）的对象 `opts`。
     var opts = {
       cmd: 'npm',
       args: ['run', command],
@@ -8,18 +12,26 @@ module.exports = function (grunt) {
       }
     }
 
+    // 使用 `grunt.util.spawn` 方法来启动一个子进程执行配置好的 `npm` 命令，该方法会异步执行命令并在执行完成后触发回调函数，回调函数接收 `error`（执行过程中出现的错误对象，如果没有错误则为 `null`）、`result`（命令执行的结果信息，具体内容根据命令而定）以及 `code`（命令的退出状态码）作为参数。
     grunt.util.spawn(opts, function (error, result, code) {
+      // 如果执行过程中出现错误（即 `error` 不为 `null`），则使用 `grunt.fail.warn` 方法向终端输出警告信息，提示指定的 `npm` 脚本命令执行失败，并显示命令名称。
       if (error) {
-        grunt.fail.warn(command + ' failed.')
+        grunt.fail.warn(command +'failed.')
       }
+      // 无论命令执行是否成功，都执行传入的回调函数 `cb`，以便外部在调用 `runNpmScript` 函数后能根据需要进行后续的操作，比如继续执行其他任务等。
       cb()
     })
   }
 
+  // 定义一个数组，包含了在某些任务执行时默认自动启动的浏览器名称列表，这里列出了 `Chrome`、`Firefox` 和 `Safari`，
+  // 用于后续配置如测试任务等在哪些浏览器中运行的相关设置。
   var autoStartBrowsers = ['Chrome', 'Firefox', 'Safari']
 
+  // 定义一个常量，表示 HTTP 协议下的流数据源端口号，用于在相关任务（如测试等）中与服务器进行通信等操作时指定端口，这里设置为 `4567`。
   var STREAM_SOURCE_PORT_HTTP = 4567
 
+  // 定义一个数组，包含了触发 Karma 测试任务的文件路径匹配模式，这些文件的变更通常会触发相应的测试任务重新执行，
+  // 例如 `src` 目录下所有子目录中的 `.js` 文件、`test/specs` 目录下的 `.spec.js` 文件等，方便在监听文件变化并自动运行测试的场景下确定哪些文件的变化需要关注。
   var FILES_TRIGGERING_KARMA = [
     'src/**/*.js',
     'test/specs/*.spec.js',
@@ -27,13 +39,22 @@ module.exports = function (grunt) {
     'test/*.js'
   ]
 
+  // 使用 `grunt.initConfig` 方法来初始化 Grunt 的配置对象，在这个对象中可以定义各种任务的配置参数、文件路径等信息，
+  // 后续加载的 Grunt 插件以及自定义的任务都会根据这里的配置来执行相应的操作。
   grunt.initConfig({
 
+    // 读取项目根目录下 `package.json` 文件的内容，并将其解析为 JSON 对象后赋值给 `pkg` 属性，这样在后续配置中可以方便地引用项目的元信息，比如项目名称、版本号等，例如在生成文件名时可以包含版本号等信息。
     pkg: grunt.file.readJSON('package.json'),
 
+    // 配置 `clean` 任务的参数，这里指定要清理的文件路径模式，即 `dist` 目录下所有的 `.js` 文件以及 `build` 目录下所有的 `.js` 文件，
+    // 通常用于在构建之前清理之前生成的旧文件，保证构建环境的干净。
     clean: ['dist/*.js', 'build/*.js'],
 
+    // 配置 `karma` 任务的相关参数，`karma` 通常用于在不同浏览器中运行 JavaScript 测试用例，这里定义了多个不同的配置选项和子任务配置。
     karma: {
+      // 通用的 `karma` 任务选项，适用于所有 `karma` 子任务（除非子任务中单独覆盖这些配置），例如设置 `singleRun` 为 `true` 表示只运行一次测试然后退出，
+      // 设置 `proxies` 用于配置代理，将 `/testServer` 代理到 `http://localhost:` + `STREAM_SOURCE_PORT_HTTP`，方便在测试中访问特定的服务器资源，
+      // 配置 `reporters` 为 `['progress']` 表示使用进度条形式的测试结果报告器，`colors` 为 `true` 表示在输出的报告和日志中启用颜色显示，使输出更直观易读。
       options: {
         singleRun: true,
         proxies: {
@@ -47,6 +68,9 @@ module.exports = function (grunt) {
         colors: true
       },
 
+      // `coverage` 子任务配置，用于生成测试覆盖率报告，设置 `reporters` 为 `['coverage']` 表示使用覆盖率报告器，
+      // 配置 `preprocessors` 来指定哪些源文件需要生成覆盖率信息（这里是 `src` 目录下所有子目录中的 `.js` 文件，这些文件会被 Istanbul 工具进行插桩处理以收集覆盖率数据），
+      // 指定 `browsers` 为 `['PhantomJS']` 表示在 PhantomJS 浏览器中运行测试，`configFile` 为 `test/unit.conf.js` 表示使用该配置文件来进一步配置 Karma 任务的详细参数。
       'coverage': {
         reporters: ['coverage'],
         preprocessors: {
@@ -58,6 +82,9 @@ module.exports = function (grunt) {
         configFile: 'test/unit.conf.js'
       },
 
+      // `precaptured-dev` 子任务配置，用于在开发过程中针对已经捕获的浏览器（可能是之前手动启动或者通过其他方式准备好的浏览器环境）进行单次测试运行，
+      // 适用于在一些特殊情况下（如在 Unix 开发环境中要在 Windows VM 里运行的 IE 浏览器等 Karma 不容易直接启动的浏览器环境）运行测试，这里 `browsers` 设为空数组表示使用已捕获的浏览器，
+      // `configFile` 为 `test/unit.conf.js`，`singleRun` 设为 `true` 表示单次运行测试。
       'precaptured-dev': {
         // for doing a single test run with already captured browsers during development.
         // this is good for running tests in browsers karma can't easily start such as
@@ -67,31 +94,44 @@ module.exports = function (grunt) {
         singleRun: 'true'
       },
 
+      // `single-dev` 子任务配置，用于在开发过程中在默认自动启动的浏览器（前面定义的 `autoStartBrowsers` 数组中的浏览器）中运行测试，
+      // `configFile` 为 `test/unit.conf.js`，表示使用该配置文件来配置详细的测试参数。
       'single-dev': {
         browsers: autoStartBrowsers,
         configFile: 'test/unit.conf.js'
       },
 
+      // `single-concat` 子任务配置，类似 `single-dev`，也是在默认自动启动的浏览器中运行测试，但使用 `test/concat.conf.js` 作为配置文件，
+      // 可能在这个配置文件中定义了与文件合并（concat）相关的测试特定设置，具体配置取决于该文件内容。
       'single-concat': {
         browsers: autoStartBrowsers,
         configFile: 'test/concat.conf.js'
       },
 
+      // `single-minified` 子任务配置，同样在默认自动启动的浏览器中运行测试，不过使用 `test/min.conf.js` 作为配置文件，
+      // 可能该配置文件针对测试已经压缩（minified）后的代码进行了相应的配置，用于验证压缩后代码的测试情况等。
       'single-minified': {
         browsers: autoStartBrowsers,
         configFile: 'test/min.conf.js'
       },
 
+      // `single-amd` 子任务配置，在默认自动启动的浏览器中运行测试，使用 `test/amd.conf.js` 作为配置文件，
+      // 也许这个配置文件是针对使用 AMD（Asynchronous Module Definition，异步模块定义）规范的代码进行测试相关的设置，用于测试遵循 AMD 规范的模块情况。
       'single-amd': {
         browsers: autoStartBrowsers,
         configFile: 'test/amd.conf.js'
       },
 
+      // `single-browser-http` 子任务配置，在默认自动启动的浏览器中运行测试，使用 `test/http.conf.js` 作为配置文件，
+      // 推测该配置文件与基于 HTTP 协议相关的测试场景或者配置有联系，用于特定的 HTTP 相关的测试需求。
       'single-browser-http': {
         browsers: autoStartBrowsers,
         configFile: 'test/http.conf.js'
       },
 
+      // `persist` 子任务配置，用于设置一个持久化的 Karma 服务器，`singleRun` 设为 `false` 表示服务器启动后不会自动运行一次测试就关闭，而是持续运行等待后续指令，
+      // `background` 设为 `true` 表示在后台运行服务器，`browsers` 设为空数组可能表示初始启动时不指定具体浏览器，后续可以通过其他方式添加浏览器来运行测试，
+      // `configFile` 为 `test/unit.conf.js`，表示使用该配置文件来配置服务器的基本参数，通过 `karma:persist` 任务可以启动这个服务器，通过 `karma:persist:run` 任务可以在已启动的服务器上运行测试。
       'persist': {
         // for setting up a persistent karma server.
         // To start the server, the task is:
@@ -104,39 +144,56 @@ module.exports = function (grunt) {
         background: true
       },
 
+      // `single-heap` 子任务配置，使用 `test/heap.conf.js` 作为配置文件来运行测试，具体配置取决于该配置文件内容，可能与内存堆（heap）相关的测试场景或者设置有关系。
       'single-heap': {
         configFile: 'test/heap.conf.js'
       }
     },
 
+    // 配置 `exec` 任务的相关参数，`exec` 任务通常用于在 Grunt 构建过程中执行外部命令，这里定义了多个不同的命令配置，每个配置对应一个子任务。
     exec: {
+      // `reportMinifiedSize` 子任务配置，执行一个命令用于报告压缩后的文件大小，通过 `echo` 命令输出 `minified size is` 以及使用 `wc -c` 命令统计 `dist/oboe-browser.min.js` 文件的字节数，
+      // 这里的命令在 Windows 系统下可能不太适用（注释中也提到了，建议使用 Cygwin），因为 `wc` 等命令是类 Unix 系统下常用的文本处理命令。
       // these might not go too well on Windows :-) - get Cygwin.
       reportMinifiedSize: {
         command: 'echo minified size is `wc -c < dist/oboe-browser.min.js` bytes'
       },
+      // `reportMinifiedAndGzippedSize` 子任务配置，执行一个命令用于报告压缩并经过 `gzip` 处理后的文件大小，通过 `echo` 命令输出 `Size after gzip is` 以及使用 `gzip --best --stdout` 对 `dist/oboe-browser.min.js` 文件进行最佳压缩并输出到标准输出，
+      // 再通过 `wc -c` 命令统计输出内容的字节数，最后显示字节数并提示最大值为 `5120`，同样这个命令在 Windows 系统下可能需要特殊处理（如借助 Cygwin 等工具）才能正确执行。
       reportMinifiedAndGzippedSize: {
         command: 'echo Size after gzip is `gzip --best --stdout dist/oboe-browser.min.js | wc -c` bytes - max 5120'
       },
+      // `createGitVersionJs` 子任务配置，执行一个命令用于创建一个包含 Git 版本描述信息的文件，通过 `echo` 命令将 `git describe` 执行的结果（获取当前 Git 仓库的版本描述信息）输出到 `build/version.txt` 文件中，用于记录项目的版本相关信息。
       createGitVersionJs: {
         command: 'echo "`git describe`" > build/version.txt'
       },
+      // `webpackBrowser` 子任务配置，执行 `npm run webpack` 命令，通常用于启动 Webpack 构建任务来处理浏览器相关的代码，比如打包、编译等操作，具体 Webpack 的配置取决于项目中 `webpack` 脚本对应的配置。
       webpackBrowser: {
         command: 'npm run webpack'
       },
+      // `webpackNode` 子任务配置，执行 `npm run webpack -- --config webpack.config.node.js` 命令，同样是启动 Webpack 构建任务，但使用 `webpack.config.node.js` 作为 Webpack 的配置文件，
+      // 用于处理 Node.js 相关代码的打包、编译等操作，与处理浏览器代码的 Webpack 配置可能有所不同，例如在模块加载、目标环境等方面会有差异。
       webpackNode: {
         command: 'npm run webpack -- --config webpack.config.node.js'
       },
+      // `standard` 子任务配置，执行 `npm run standard -- --fix --envs jasmine` 命令，可能是用于运行代码规范检查工具（如 ESLint 等，这里猜测是 `standard` 相关的工具），
+      // 并尝试自动修复代码规范问题（通过 `--fix` 参数），同时设置特定的环境（`--envs jasmine`，可能是针对 Jasmine 测试框架相关的代码环境进行规范检查）。
       standard: {
         command: 'npm run standard -- --fix --envs jasmine'
       }
     },
 
+    // 配置 `watch` 任务的相关参数，`watch` 任务用于监听文件的变化，当指定的文件发生变化时自动触发相应的任务执行，这里定义了多个不同的监听配置，每个配置对应一个子任务。
     watch: {
+      // `karma` 子任务配置，监听触发 Karma 测试任务的文件（前面定义的 `FILES_TRIGGERING_KARMA` 中的文件），当这些文件有变化时，执行 `karma:persist:run` 任务，
+      // 即运行在持久化 Karma 服务器上的测试任务，实现自动重新运行测试的功能，方便在开发过程中实时查看代码修改对测试结果的影响。
       karma: {
         files: FILES_TRIGGERING_KARMA,
         tasks: ['karma:persist:run']
       },
 
+      // `karmaAndSize` 子任务配置，类似 `watch:karma`，也是监听触发 Karma 测试任务的文件，当文件变化时，执行多个任务，包括 `karma:persist:run`（运行测试）、`browser-build`（推测是与浏览器相关的构建任务，具体内容需看对应任务定义）以及 `dist-sizes`（可能是用于查看生成文件大小相关的任务，具体要看对应任务配置），
+      // 这样在开发过程中不仅能自动运行测试，还能查看构建文件大小情况，确保文件大小不会超出预期等。
       // like above but reports the file size. This is good for
       // watching while developing to make sure it doesn't get
       // too big. Doesn't run tests against minified.
@@ -148,101 +205,157 @@ module.exports = function (grunt) {
           'dist-sizes']
       },
 
+      // `testNode` 子任务配置，监听触发 Karma 测试任务的文件，当文件变化时，执行 `node-build` 任务（推测是与 Node.js 相关的构建任务，具体要看对应任务定义），
+      // 用于在开发 Node.js 相关代码时，自动触发相应的构建操作，方便及时查看代码修改后的构建效果。
+      // like above but reports the file size. This is good for
+      // watching while developing to
+
       // like above but reports the file size. This is good for
       // watching while developing to make sure it doesn't get
       // too big. Doesn't run tests against minified.
+// `testNode` 子任务配置，用于 `watch` 任务中，监听那些会触发 `Karma` 测试任务的文件（前面已定义 `FILES_TRIGGERING_KARMA` 数组中的文件），
+// 当这些文件发生变化时，会触发执行 `node-build` 任务，该任务可能是针对 Node.js 相关代码进行构建相关操作的任务，具体操作取决于 `node-build` 任务的定义。
       testNode: {
         files: FILES_TRIGGERING_KARMA,
         tasks: [
-          'node-build']
+          'node-build'
+        ]
       },
 
+// `restartStreamSourceAndRunTests` 子任务配置，同样用于 `watch` 任务里。它监听 `test/streamsource.js` 文件的变化，
+// 当该文件改变时，会依次执行 `start-stream-source` 和 `karma:persist:run` 这两个任务。不过当前存在一个问题（注释中提到），
+// 即 `start-stream-source` 任务如果多次运行会失败，因为其占用的端口会被占用（可能每次启动都尝试使用同一个固定端口导致冲突）。
       restartStreamSourceAndRunTests: {
+        // 此处注释说明了当前存在的问题，即 `start-stream-source` 任务多次运行会失败，原因是端口被占用。
         // this fails at the moment because start-stream-source
         // fails if run more than once - the port is taken.
         files: ['test/streamsource.js'],
         tasks: ['start-stream-source', 'karma:persist:run']
       },
 
+// `standard` 子任务配置，用于 `watch` 任务里，监听那些触发 `Karma` 测试任务的文件（`FILES_TRIGGERING_KARMA` 数组中的文件）变化，
+// 一旦这些文件有变动，就会执行 `exec:standard` 任务，这个任务大概率是运行代码规范检查相关的操作（前面 `exec` 任务配置中有相关定义），比如检查代码是否符合特定的代码规范标准，并可能进行自动修复等操作。
       standard: {
         files: FILES_TRIGGERING_KARMA,
         tasks: ['exec:standard']
-      }
-    },
+      },
 
-    concurrent: {
-      watchDev: {
-        tasks: [ 'watch:karmaAndSize', 'watch:restartStreamSourceAndRunTests' ],
-        options: {
-          logConcurrentOutput: true
+// `concurrent` 配置部分，主要用于定义可以同时执行的多个任务组合，这里定义了 `watchDev` 任务配置。
+      concurrent: {
+        // `watchDev` 任务配置，用于同时运行多个 `watch` 子任务，具体是 `watch:karmaAndSize` 和 `watch:restartStreamSourceAndRunTests` 这两个任务，
+        // 通过设置 `logConcurrentOutput` 为 `true`，可以让这些同时执行的任务的输出信息都能正常显示出来，方便查看每个任务的执行情况，
+        // 常用于在开发环境下同时监听多个不同类型的文件变化并执行相应的关联任务，提高开发效率。
+        watchDev: {
+          tasks: [ 'watch:karmaAndSize', 'watch:restartStreamSourceAndRunTests' ],
+          options: {
+            logConcurrentOutput: true
+          }
         }
       }
-    }
 
-  })
+// 初始化 Grunt 配置对象结束的括号，至此完成了对 Grunt 构建任务中如 `clean`、`karma`、`exec`、`watch`、`concurrent` 等多个任务相关配置参数的定义。
+    })
 
+// 使用 `require('matchdep').filterDev('grunt-*')` 来筛选出开发环境下所有以 `grunt-` 开头的插件，然后通过 `forEach` 方法遍历并调用 `grunt.loadNpmTasks` 函数加载这些插件，
+// 使得这些插件定义的任务可以在 Grunt 构建流程中被使用，方便扩展 Grunt 的功能，添加各种自定义的构建、测试等相关任务。
   require('matchdep').filterDev('grunt-*').forEach(grunt.loadNpmTasks)
 
-  var streamSource
+// 定义一个变量 `streamSource`，用于后续管理流数据源相关的操作，初始时它未被赋值，具体的赋值和使用在相关任务中进行。
+  var streamSource;
 
+// 注册一个名为 `start-stream-source` 的 Grunt 任务，这个任务的功能是启动一个流数据源服务，在任务函数内部实现了相关的逻辑来确保服务正确启动。
   grunt.registerTask('start-stream-source', function () {
-    grunt.log.ok('do we have a streaming source already?', !!streamSource)
+    // 使用 `grunt.log.ok` 方法向控制台输出一条信息，用于检查当前是否已经存在一个流数据源（通过将 `streamSource` 转换为布尔值来判断，若已赋值则表示存在），
+    // 主要是为了在启动新的流数据源之前了解当前状态，便于后续做相应处理，比如如果已经存在就先停止它等操作。
+    grunt.log.ok('do we have a streaming source already?',!!streamSource);
 
-    // if we previously loaded the streamsource, stop it to let the new one in:
+    // 如果 `streamSource` 已经有值（即之前已经启动过流数据源服务），则执行以下操作，先通过 `grunt.log.ok` 向控制台输出一条提示信息，表示似乎已经存在一个流数据源服务器，
+    // 然后调用 `streamSource.stop()` 方法（这里假设 `streamSource` 对象有 `stop` 方法来停止之前的服务）来停止它，以便释放相关资源，为启动新的流数据源服务做准备。
     if (streamSource) {
-      grunt.log.ok('there seems to be a streaming server already, let\'s stop it')
-      streamSource.stop()
+      grunt.log.ok('there seems to be a streaming server already, let\'s stop it');
+      streamSource.stop();
     }
 
-    streamSource = require('./test/streamsource.js')
-    streamSource.start(STREAM_SOURCE_PORT_HTTP, grunt)
-  })
+    // 通过 `require` 加载 `./test/streamsource.js` 文件（这个文件应该是定义了流数据源相关的逻辑，比如启动服务的具体实现等），并将返回的对象赋值给 `streamSource` 变量，
+    // 然后调用 `streamSource.start` 方法（同样假设该对象有 `start` 方法），传入 `STREAM_SOURCE_PORT_HTTP`（前面定义的流数据源端口号）和 `grunt` 对象作为参数来启动流数据源服务，
+    // 使得后续的任务（比如测试任务等）可以基于这个流数据源进行相应的操作，比如获取测试数据等。
+    streamSource = require('./test/streamsource.js');
+    streamSource.start(STREAM_SOURCE_PORT_HTTP, grunt);
+  });
 
+// 注册一个名为 `jasmine_node_oboe` 的 Grunt 任务，任务描述为 `Runs jasmine-node.`，用于运行 `jasmine-node` 相关的测试操作，
+// 在任务函数内部通过调用 `runNpmScript` 函数（前面有定义，用于运行 `npm` 脚本命令）来执行 `test-node` 这个 `npm` 脚本，并传入 `this.async()`，
+// `this.async()` 是 Grunt 任务中用于支持异步操作的方法，它返回一个回调函数，用于告知 Grunt 任务何时完成，确保任务的异步执行逻辑能正确被 Grunt 框架识别和管理。
   grunt.registerTask('jasmine_node_oboe', 'Runs jasmine-node.', function () {
-    runNpmScript('test-node', this.async())
-  })
+    runNpmScript('test-node', this.async());
+  });
 
-  // change the auto-starting browsers so that future tests will use
-  // phantomjs instead of actual browsers. Can do:
-  //    grunt headless-mode default
-  // to run without any actual browsers
+// 注册一个名为 `headless-mode` 的 Grunt 任务，这个任务的作用是改变自动启动浏览器的配置，将原本默认自动启动的浏览器列表（`autoStartBrowsers`）清空，
+// 然后添加 `PhantomJS` 作为唯一的自动启动浏览器，这样后续执行相关测试任务时（比如某些默认使用自动启动浏览器的 `Karma` 测试任务）就会使用 `PhantomJS` 浏览器进行测试，
+// 实现了切换到无界面（headless）模式进行测试的功能，方便在不需要实际浏览器界面展示的情况下运行测试，例如在持续集成环境中或者只关注测试结果不关心界面展示的场景下使用。
+// 通过执行 `grunt headless-mode default` 命令就可以在不使用实际浏览器的情况下运行测试任务（这里 `default` 可能是后续其他默认配置相关的操作，具体要看整体使用场景）。
   grunt.registerTask('headless-mode', function () {
-    autoStartBrowsers.length = 0
-    autoStartBrowsers.push('PhantomJS')
-  })
+    autoStartBrowsers.length = 0;
+    autoStartBrowsers.push('PhantomJS');
+  });
 
+// 注册一个名为 `test-start-server` 的 Grunt 任务，该任务只包含一个子任务 `karma:persist`，
+// 其目的是启动一个持久化的 `Karma` 服务器，方便后续可以多次向这个服务器提交测试任务去运行，而不需要每次都重新启动服务器，常用于开发过程中持续进行测试的场景。
   grunt.registerTask('test-start-server', [
     'karma:persist'
-  ])
+  ]);
 
+// 注册一个名为 `test-run` 的 Grunt 任务，该任务包含 `karma:persist:run` 子任务，用于在已经启动的持久化 `Karma` 服务器（通过 `test-start-server` 任务启动）上运行测试任务，
+// 实现了将服务器启动和运行测试分离的操作方式，使得可以灵活控制服务器的启动时机以及测试的执行时间，提高测试执行的灵活性和效率。
   grunt.registerTask('test-run', [
     'karma:persist:run'
-  ])
+  ]);
 
+// 注册一个名为 `dist-sizes` 的 Grunt 任务，该任务包含 `exec:reportMinifiedAndGzippedSize` 子任务，
+// 其作用是执行获取压缩并经过 `gzip` 处理后的文件大小的相关命令（前面 `exec` 任务配置中有具体定义），用于查看构建生成的文件在经过相关处理后的大小情况，
+// 方便开发人员监控文件大小是否符合预期，比如是否超出了某个限制等，对于优化项目构建输出有一定的帮助。
   grunt.registerTask('dist-sizes', [
     'exec:reportMinifiedAndGzippedSize'
-  ])
+  ]);
 
+// 注册一个名为 `node-build` 的 Grunt 任务，该任务包含 `exec:createGitVersionJs` 和 `exec:webpackNode` 两个子任务，
+// 主要用于执行与 Node.js 相关的构建操作，先是通过 `exec:createGitVersionJs` 创建包含 Git 版本描述信息的文件（可能用于版本管理或者在构建输出中体现版本信息等），
+// 然后通过 `exec:webpackNode` 启动 Webpack 针对 Node.js 相关代码的构建任务（使用特定的 Node.js 相关的 Webpack 配置文件），完成 Node.js 代码的打包、编译等构建流程。
   grunt.registerTask('node-build', [
     'exec:createGitVersionJs',
     'exec:webpackNode'
-  ])
+  ]);
 
+// 注册一个名为 `node-build-test` 的 Grunt 任务，该任务包含 `node-build` 和 `jasmine_node_oboe` 两个子任务，
+// 先是执行 `node-build` 任务完成 Node.js 相关代码的构建操作，然后执行 `jasmine_node_oboe` 任务运行 `jasmine-node` 相关的测试，实现了构建后立即进行测试的流程，
+// 便于及时发现 Node.js 代码在构建后是否存在问题，保证代码质量，常用于开发过程中的持续集成和代码验证环节。
   grunt.registerTask('node-build-test', [
     'node-build',
     'jasmine_node_oboe'
-  ])
+  ]);
 
+// 注册一个名为 `node` 的 Grunt 任务，该任务包含 `start-stream-source` 和 `node-build-test` 两个子任务，
+// 先启动流数据源服务（通过 `start-stream-source` 任务），为后续测试等操作提供数据支持等，然后执行 `node-build-test` 任务完成 Node.js 相关代码的构建与测试流程，
+// 整合了相关前置准备和主要的构建测试操作，在整个项目构建和测试体系中作为针对 Node.js 部分的一个完整流程任务存在。
   grunt.registerTask('node', [
     'start-stream-source',
     'node-build-test'
-  ])
+  ]);
 
+// 注册一个名为 `browser-build` 的 Grunt 任务，该任务包含 `exec:createGitVersionJs` 和 `exec:webpackBrowser` 两个子任务，
+// 主要用于执行与浏览器相关代码的构建操作，先是通过 `exec:createGitVersionJs` 创建包含 Git 版本描述信息的文件（同样可能用于版本管理等目的），
+// 然后通过 `exec:webpackBrowser` 启动 Webpack 针对浏览器相关代码的构建任务（使用默认的浏览器相关的 Webpack 配置），完成浏览器端代码的打包、编译等构建流程，
+// 以生成适合在浏览器中运行的代码文件，是浏览器端代码构建环节的重要任务配置。
   grunt.registerTask('browser-build', [
     'exec:createGitVersionJs',
     'exec:webpackBrowser'
-  ])
+  ]);
 
+// 注册一个名为 `browser-build-test` 的 Grunt 任务，该任务包含多个子任务，按照顺序依次执行 `karma:single-dev`（在默认自动启动的浏览器中运行开发相关的测试）、
+// `karma:single-browser-http`（在默认自动启动的浏览器中运行基于 HTTP 相关配置的测试）、`browser-build`（执行浏览器相关代码的构建操作）、
+// `karma:single-concat`（在默认自动启动的浏览器中运行与文件合并相关的测试）、`karma:single-minified`（在默认自动启动的浏览器中运行针对压缩后代码的测试）、
+// `karma:single-amd`（在默认自动启动的浏览器中运行针对遵循 AMD 规范的代码的测试）等任务，实现了浏览器端代码构建、多种不同类型测试的完整流程，
+// 可以全面地对浏览器端代码进行验证，确保代码在不同场景和配置下都能正常运行并符合预期，是浏览器端代码质量保障的重要任务组合。
   grunt.registerTask('browser-build-test', [
     'karma:single-dev',
     'karma:single-browser-http',
@@ -250,44 +363,50 @@ module.exports = function (grunt) {
     'karma:single-concat',
     'karma:single-minified',
     'karma:single-amd'
-  ])
+  ]);
 
+// 注册一个名为 `build` 的 Grunt 任务，该任务只包含 `exec:webpackBrowser` 子任务，主要就是启动 Webpack 针对浏览器相关代码的构建任务，
+// 侧重于单纯的浏览器端代码构建操作，相对比较简洁直接，适用于只需要进行基本的浏览器代码打包、编译等场景，而不需要像 `browser-build-test` 那样执行一系列测试任务的情况。
   grunt.registerTask('build', [
     'exec:webpackBrowser'
-  ])
+  ]);
 
-  // build and run just the integration tests.
+// 注册一个名为 `build-integration-test` 的 Grunt 任务，该任务包含多个子任务，先是执行 `build` 任务完成浏览器相关代码的构建，然后启动流数据源服务（通过 `start-stream-source` 任务），
+// 接着在默认自动启动的浏览器中运行与文件合并相关的测试（`karma:single-concat`），再运行 `jasmine-node` 相关的测试（`jasmine_node_oboe`），最后查看构建生成文件的大小情况（`dist-sizes`），
+// 实现了构建、数据源准备、多种测试以及文件大小监控的完整流程，用于对整个项目进行集成测试，确保不同部分协同工作正常，代码在集成环境下的整体功能和性能符合预期。
   grunt.registerTask('build-integration-test', [
     'build',
     'start-stream-source',
     'karma:single-concat',
     'jasmine_node_oboe',
     'dist-sizes'
-  ])
+  ]);
 
+// 注册一个名为 `default` 的 Grunt 任务，这个任务通常是在没有指定具体执行哪个任务时默认执行的任务组合，包含多个子任务，
+// 先是执行 `clear`（这里不确定 `clear` 具体定义，如果存在可能是用于清理某些通用的内容，比如临时文件等，不过代码中前面未明确看到其配置，可能是遗漏或者在其他地方定义）和 `clean`（用于清理指定的文件，前面 `clean` 任务配置中有定义）任务清理相关文件和环境，
+// 然后启动流数据源服务（`start-stream-source`），接着执行 `browser-build-test`（完成浏览器端代码构建与多种测试）、`node-build-test`（完成 Node.js 相关代码构建与测试），最后查看构建生成文件的大小情况（`dist-sizes`），
+// 整合了项目中主要的清理、构建、测试以及文件大小监控等操作，作为一个默认的完整项目构建和验证流程存在，方便在日常开发或者简单部署场景下直接使用。
   grunt.registerTask('default', [
-
     'clear',
     'clean',
     'start-stream-source',
-
     'browser-build-test',
-
     'node-build-test',
-
     'dist-sizes'
-  ])
+  ]);
 
-  // browser-test-auto-run or node-test-auto-run
-  //
-  // The most useful for developing. Start this task, capture some browsers
-  // (unless node) then edit the code. Tests will be run as the code is
-  // saved.
+// 注册一个名为 `browser-test-auto-run` 的 Grunt 任务，该任务包含 `start-stream-source`、`karma:persist` 和 `concurrent:watchDev` 三个子任务，
+// 先启动流数据源服务，接着启动一个持久化的 `Karma` 服务器，然后同时运行 `watchDev` 相关的多个 `watch` 任务（前面 `concurrent` 配置中有定义，用于监听文件变化并执行相应测试等任务），
+// 实现了在开发过程中自动监听文件变化并自动运行浏览器相关测试的功能，开发人员只需要启动这个任务，然后捕获好相关浏览器（可能是手动启动一些浏览器并让 `Karma` 能连接到它们等操作），
+// 之后在编辑代码保存时，就能自动触发测试任务运行，极大地提高了开发效率，方便及时发现代码修改对浏览器端代码功能的影响。
   grunt.registerTask('browser-test-auto-run', [
     'start-stream-source',
     'karma:persist',
     'concurrent:watchDev'
-  ])
+  ]);
+
+// 注册一个名为 `node-test-auto-run` 的 Grunt 任务，该任务包含 `start-stream-source` 和 `watch:testNode` 两个子任务，
+// 先启动流数据源服务，然后启动监听 Node.js 相关代码文件变化的 `watch` 任务（前面 `watch` 任务配置中有定义），当 Node.js 相关代码文件发生变化时，
   grunt.registerTask('node-test-auto-run', [
     'start-stream-source',
     'watch:testNode'