From 7698369d2f8812c99e61f217923a2beccf8c5d20 Mon Sep 17 00:00:00 2001 From: zhangchao <3393187263@qq.com> Date: Tue, 17 Dec 2024 13:20:13 +0800 Subject: [PATCH 1/3] 4 --- .../minimalistic-crypto-utils/lib/utils.js | 62 +++++++++++++------ 1 file changed, 44 insertions(+), 18 deletions(-) diff --git a/node_modules/minimalistic-crypto-utils/lib/utils.js b/node_modules/minimalistic-crypto-utils/lib/utils.js index cd48daf..3a93fd1 100644 --- a/node_modules/minimalistic-crypto-utils/lib/utils.js +++ b/node_modules/minimalistic-crypto-utils/lib/utils.js @@ -1,58 +1,84 @@ 'use strict'; -var utils = exports; +var utils = exports; // 导出一个 utils 对象，使得该对象的功能可以被外部访问和使用 +// toArray: 将输入的 msg 转换为一个数组，支持不同类型的编码 function toArray(msg, enc) { + // 如果 msg 已经是一个数组，返回其副本 if (Array.isArray(msg)) return msg.slice(); + + // 如果 msg 是 null 或 undefined，返回一个空数组 if (!msg) return []; - var res = []; + + var res = []; // 用于存放转换后的结果数组 + + // 如果 msg 不是字符串，则将其视为类数组对象，逐个元素转换为整数并存入 res 数组 if (typeof msg !== 'string') { for (var i = 0; i < msg.length; i++) - res[i] = msg[i] | 0; + res[i] = msg[i] | 0; // 使用按位 OR 操作将每个元素转换为数字类型 return res; } + + // 如果 msg 是字符串，并且编码方式是 'hex'（十六进制） if (enc === 'hex') { + // 去除字符串中的所有非字母和数字字符（忽略大小写） msg = msg.replace(/[^a-z0-9]+/ig, ''); + + // 如果 msg 的长度是奇数，补充一个 '0' 在前面，确保可以按两位一组处理 if (msg.length % 2 !== 0) msg = '0' + msg; + + // 每两位字符组成一个字节（16 进制），将其转换为十进制并推入结果数组 for (var i = 0; i < msg.length; i += 2) - res.push(parseInt(msg[i] + msg[i + 1], 16)); + res.push(parseInt(msg[i] + msg[i + 1], 16)); // 将两个十六进制字符组合成一个字节（数字） } else { + // 如果 msg 是普通的字符串，按 UTF-16 编码将每个字符转换为数字 for (var i = 0; i < msg.length; i++) { - var c = msg.charCodeAt(i); - var hi = c >> 8; - var lo = c & 0xff; + var c = msg.charCodeAt(i); // 获取字符的 UTF-16 编码 + var hi = c >> 8; // 获取字符的高字节 + var lo = c & 0xff; // 获取字符的低字节 + + // 如果字符编码大于 255（即有高字节），将高字节和低字节都存入结果数组 if (hi) res.push(hi, lo); else - res.push(lo); + res.push(lo); // 如果字符编码小于或等于 255，只存入低字节 } } - return res; + + return res; // 返回转换后的数组 } -utils.toArray = toArray; +utils.toArray = toArray; // 将 toArray 函数赋值给 utils 对象，供外部调用 +// zero2: 确保输入字符串长度为两位数，不足时前面补零 function zero2(word) { + // 如果输入的字符串长度为 1，前面补充一个 '0' if (word.length === 1) return '0' + word; else - return word; + return word; // 如果已是两位数，则返回原字符串 } -utils.zero2 = zero2; +utils.zero2 = zero2; // 将 zero2 函数赋值给 utils 对象，供外部调用 +// toHex: 将数字数组转换为十六进制字符串，每个数字转换为两位的十六进制字符串 function toHex(msg) { - var res = ''; + var res = ''; // 用于存放最终的十六进制字符串 + + // 遍历输入的数组，将每个数字转换为十六进制并拼接成字符串 for (var i = 0; i < msg.length; i++) - res += zero2(msg[i].toString(16)); - return res; + res += zero2(msg[i].toString(16)); // 每个数字转换为十六进制并加上前导零（如果需要） + + return res; // 返回拼接后的十六进制字符串 } -utils.toHex = toHex; +utils.toHex = toHex; // 将 toHex 函数赋值给 utils 对象，供外部调用 +// encode: 根据指定的编码方式将数组进行编码，如果是 'hex'，则将其转换为十六进制字符串 utils.encode = function encode(arr, enc) { if (enc === 'hex') - return toHex(arr); + return toHex(arr); // 如果编码方式是 'hex'，则调用 toHex 函数进行转换 else - return arr; + return arr; // 否则，直接返回原始数组 }; + -- 2.34.1 From 60ae735c31b8c18c800e72d2696d1b81e9a1d2b0 Mon Sep 17 00:00:00 2001 From: zhangchao <3393187263@qq.com> Date: Tue, 17 Dec 2024 13:25:56 +0800 Subject: [PATCH 2/3] 5 --- node_modules/minimist/index.js | 227 ++++++++++++++++++--------------- 1 file changed, 121 insertions(+), 106 deletions(-) diff --git a/node_modules/minimist/index.js b/node_modules/minimist/index.js index f020f39..ca36957 100644 --- a/node_modules/minimist/index.js +++ b/node_modules/minimist/index.js @@ -1,54 +1,63 @@ 'use strict'; +// hasKey: 判断给定的对象中是否包含某个键（支持嵌套键） function hasKey(obj, keys) { - var o = obj; + var o = obj; // 初始对象 + // 遍历所有的键（除了最后一个），逐层深入查找对象 keys.slice(0, -1).forEach(function (key) { - o = o[key] || {}; + o = o[key] || {}; // 如果某层键不存在，则将其替换为一个空对象 }); - - var key = keys[keys.length - 1]; - return key in o; + var key = keys[keys.length - 1]; // 获取最后一个键 + return key in o; // 检查最后一个键是否在当前对象中 } +// isNumber: 判断给定的值是否为一个有效的数字（支持十六进制和科学计数法） function isNumber(x) { - if (typeof x === 'number') { return true; } - if ((/^0x[0-9a-f]+$/i).test(x)) { return true; } - return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x); + if (typeof x === 'number') { return true; } // 如果是数字，返回 true + if ((/^0x[0-9a-f]+$/i).test(x)) { return true; } // 如果是十六进制格式，返回 true + return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x); // 正则判断是否符合数字格式（包括科学计数法） } +// isConstructorOrProto: 判断对象中是否有 'constructor' 或 '__proto__' 键 function isConstructorOrProto(obj, key) { return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__'; } +// 主要模块功能：解析命令行参数 module.exports = function (args, opts) { - if (!opts) { opts = {}; } + if (!opts) { opts = {}; } // 如果没有传递 opts，则初始化为空对象 var flags = { - bools: {}, - strings: {}, - unknownFn: null, + bools: {}, // 存储布尔类型标记的键 + strings: {}, // 存储字符串类型标记的键 + unknownFn: null, // 存储未知参数的处理函数 }; + // 如果 opts 中定义了 unknown 函数，则保存该函数 if (typeof opts.unknown === 'function') { flags.unknownFn = opts.unknown; } + // 处理布尔类型标记（参数是布尔类型） if (typeof opts.boolean === 'boolean' && opts.boolean) { - flags.allBools = true; + flags.allBools = true; // 如果 opts.boolean 为 true，则标记所有参数为布尔类型 } else { + // 如果 opts.boolean 是数组，则将数组中的每个元素标记为布尔类型 [].concat(opts.boolean).filter(Boolean).forEach(function (key) { flags.bools[key] = true; }); } - var aliases = {}; + var aliases = {}; // 存储别名的映射 + // aliasIsBoolean: 判断别名是否对应布尔类型 function aliasIsBoolean(key) { return aliases[key].some(function (x) { return flags.bools[x]; }); } + // 设置别名的映射关系 Object.keys(opts.alias || {}).forEach(function (key) { aliases[key] = [].concat(opts.alias[key]); aliases[key].forEach(function (x) { @@ -58,6 +67,7 @@ module.exports = function (args, opts) { }); }); + // 标记 opts.string 中的键为字符串类型，并处理别名的影响 [].concat(opts.string).filter(Boolean).forEach(function (key) { flags.strings[key] = true; if (aliases[key]) { @@ -67,10 +77,11 @@ module.exports = function (args, opts) { } }); - var defaults = opts.default || {}; + var defaults = opts.default || {}; // 获取默认值 - var argv = { _: [] }; + var argv = { _: [] }; // 存储解析后的参数 + // argDefined: 判断参数是否已定义 function argDefined(key, arg) { return (flags.allBools && (/^--[^=]+$/).test(arg)) || flags.strings[key] @@ -78,17 +89,14 @@ module.exports = function (args, opts) { || aliases[key]; } + // setKey: 根据嵌套键设置对象的属性值，创建中间对象（如果需要） function setKey(obj, keys, value) { var o = obj; for (var i = 0; i < keys.length - 1; i++) { var key = keys[i]; if (isConstructorOrProto(o, key)) { return; } if (o[key] === undefined) { o[key] = {}; } - if ( - o[key] === Object.prototype - || o[key] === Number.prototype - || o[key] === String.prototype - ) { + if (o[key] === Object.prototype || o[key] === Number.prototype || o[key] === String.prototype) { o[key] = {}; } if (o[key] === Array.prototype) { o[key] = []; } @@ -97,167 +105,174 @@ module.exports = function (args, opts) { var lastKey = keys[keys.length - 1]; if (isConstructorOrProto(o, lastKey)) { return; } - if ( - o === Object.prototype - || o === Number.prototype - || o === String.prototype - ) { + if (o === Object.prototype || o === Number.prototype || o === String.prototype) { o = {}; } if (o === Array.prototype) { o = []; } + // 如果目标位置未定义或是布尔值类型，则直接赋值 if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') { o[lastKey] = value; - } else if (Array.isArray(o[lastKey])) { + } else if (Array.isArray(o[lastKey])) { // 如果目标位置是数组，则推入值 o[lastKey].push(value); - } else { + } else { // 否则将值包装成数组 o[lastKey] = [o[lastKey], value]; } } + // setArg: 设置参数值，并根据标记处理不同的类型 function setArg(key, val, arg) { if (arg && flags.unknownFn && !argDefined(key, arg)) { if (flags.unknownFn(arg) === false) { return; } } var value = !flags.strings[key] && isNumber(val) - ? Number(val) + ? Number(val) // 如果值是数字字符串并且该键没有标记为字符串类型，则转换为数字 : val; - setKey(argv, key.split('.'), value); + setKey(argv, key.split('.'), value); // 设置参数值 - (aliases[key] || []).forEach(function (x) { + (aliases[key] || []).forEach(function (x) { // 处理别名 setKey(argv, x.split('.'), value); }); } + // 对于所有布尔类型的键，设置默认值 Object.keys(flags.bools).forEach(function (key) { setArg(key, defaults[key] === undefined ? false : defaults[key]); }); var notFlags = []; + // 如果参数中包含 `--`，则将后面的参数视为非标志参数 if (args.indexOf('--') !== -1) { notFlags = args.slice(args.indexOf('--') + 1); args = args.slice(0, args.indexOf('--')); } + // 遍历所有参数，处理不同的参数格式 for (var i = 0; i < args.length; i++) { var arg = args[i]; var key; var next; - if ((/^--.+=/).test(arg)) { - // Using [\s\S] instead of . because js doesn't support the - // 'dotall' regex modifier. See: - // http://stackoverflow.com/a/1068308/13216 + if ((/^--.+=/).test(arg)) { // 处理形如 `--key=value` 的参数 var m = arg.match(/^--([^=]+)=([\s\S]*)$/); key = m[1]; var value = m[2]; if (flags.bools[key]) { - value = value !== 'false'; + value = value !== 'false'; // 对布尔类型进行特殊处理 } setArg(key, value, arg); - } else if ((/^--no-.+/).test(arg)) { + } else if ((/^--no-.+/).test(arg)) { // 处理形如 `--no-key` 的布尔参数 key = arg.match(/^--no-(.+)/)[1]; setArg(key, false, arg); - } else if ((/^--.+/).test(arg)) { + } else if ((/^--.+/).test(arg)) { // 处理形如 `--key` 的单个标志参数 key = arg.match(/^--(.+)/)[1]; next = args[i + 1]; - if ( - next !== undefined - && !(/^(-|--)[^-]/).test(next) - && !flags.bools[key] - && !flags.allBools - && (aliases[key] ? !aliasIsBoolean(key) : true) - ) { + // 判断是否为下一个值，如果是，则设置该值 + if (next !== undefined && !(/^(-|--)[^-]/).test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) { setArg(key, next, arg); i += 1; - } else if ((/^(true|false)$/).test(next)) { - setArg(key, next === 'true', arg); - i += 1; } else { - setArg(key, flags.strings[key] ? '' : true, arg); + setArg(key, flags.strings[key] ? '' : true, arg); // 如果下一个值是布尔类型，设置为 true } - } else if ((/^-[^-]+/).test(arg)) { + } else if ((/^-[^-]+/).test(arg)) { // 处理短标志参数，例如 `-a` 或 `-abc` var letters = arg.slice(1, -1).split(''); - var broken = false; for (var j = 0; j < letters.length; j++) { next = arg.slice(j + 2); - + // 判断是否为单独的短参数 if (next === '-') { setArg(letters[j], next, arg); continue; } + // 处理其他情况：例如，短参数后 + // 处理短标志参数（如 -a, -abc 等），并对不同的情况进行处理 if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') { - setArg(letters[j], next.slice(1), arg); - broken = true; - break; + // 如果当前字母是字母（A-Z 或 a-z），并且下一个值以 '=' 开头， + // 则处理形如 "-a=value" 的参数 + setArg(letters[j], next.slice(1), arg); // 将 'value' 作为参数值设置 + broken = true; // 标记该参数已处理 + break; // 退出当前的循环，继续处理下一个参数 } +// 处理类似 "-a=123" 的情况，数字值（包括科学计数法） if ( - (/[A-Za-z]/).test(letters[j]) - && (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next) + (/([A-Za-z])/).test(letters[j]) // 检查当前字母是否是字母 + && (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next) // 检查下一个值是否是数字或科学计数法 ) { - setArg(letters[j], next, arg); - broken = true; - break; + setArg(letters[j], next, arg); // 将数字作为参数值设置 + broken = true; // 标记该参数已处理 + break; // 退出循环 } +// 处理下一个字符是非字母/数字的情况，如 "-a@" if (letters[j + 1] && letters[j + 1].match(/\W/)) { - setArg(letters[j], arg.slice(j + 2), arg); - broken = true; - break; + setArg(letters[j], arg.slice(j + 2), arg); // 将剩余部分作为参数值设置 + broken = true; // 标记该参数已处理 + break; // 退出循环 } else { - setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); + // 如果下一个字符是字母/数字并且是布尔类型，则设置为 true + setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); // 设置布尔值或默认值 } - } - key = arg.slice(-1)[0]; - if (!broken && key !== '-') { - if ( - args[i + 1] - && !(/^(-|--)[^-]/).test(args[i + 1]) - && !flags.bools[key] - && (aliases[key] ? !aliasIsBoolean(key) : true) - ) { - setArg(key, args[i + 1], arg); - i += 1; - } else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) { - setArg(key, args[i + 1] === 'true', arg); - i += 1; - } else { - setArg(key, flags.strings[key] ? '' : true, arg); +// 获取当前参数的最后一个字符 + key = arg.slice(-1)[0]; + if (!broken && key !== '-') { // 如果当前参数没有被标记为 "broken" 且最后一个字符不是 "-"（即短参数） + // 处理带有值的标志，如 "-a value" 或 "-a=true/false" + if ( + args[i + 1] // 判断是否有下一个参数 + && !(/^(-|--)[^-]/).test(args[i + 1]) // 确保下一个参数不是另一个标志（以 "-" 或 "--" 开头） + && !flags.bools[key] // 如果当前标志不是布尔类型 + && (aliases[key] ? !aliasIsBoolean(key) : true) // 如果该标志没有布尔类型的别名 + ) { + setArg(key, args[i + 1], arg); // 将下一个参数作为值设置 + i += 1; // 跳过下一个参数 + } else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) { // 如果下一个值是布尔值 true 或 false + setArg(key, args[i + 1] === 'true', arg); // 将 "true" 或 "false" 转换为布尔类型 + i += 1; // 跳过下一个参数 + } else { + // 如果没有值或下一个参数是标志，设置为 true 或默认值 + setArg(key, flags.strings[key] ? '' : true, arg); + } + } + +// 处理没有标志（即非标志参数）的情况 + } else { + // 如果没有提供 `unknownFn` 或 `unknownFn` 函数返回值不为 false，说明该参数是合法的 + if (!flags.unknownFn || flags.unknownFn(arg) !== false) { + // 如果该参数不是数字，且不是在字符串标志中，则将其作为字符串处理；否则，转换为数字 + argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg)); + } + + // 如果设置了 `stopEarly`，则提前结束解析，处理完当前参数后直接将剩余参数加入 `_` + if (opts.stopEarly) { + argv._.push.apply(argv._, args.slice(i + 1)); + break; // 停止处理后续的参数 } } - } else { - if (!flags.unknownFn || flags.unknownFn(arg) !== false) { - argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg)); - } - if (opts.stopEarly) { - argv._.push.apply(argv._, args.slice(i + 1)); - break; - } - } - } - Object.keys(defaults).forEach(function (k) { - if (!hasKey(argv, k.split('.'))) { - setKey(argv, k.split('.'), defaults[k]); +// 遍历 defaults 对象，将未定义的默认值设置到 argv 对象中 + Object.keys(defaults).forEach(function (k) { + if (!hasKey(argv, k.split('.'))) { // 如果 argv 对象中没有该键（支持嵌套的键名） + setKey(argv, k.split('.'), defaults[k]); // 设置默认值 - (aliases[k] || []).forEach(function (x) { - setKey(argv, x.split('.'), defaults[k]); + // 处理别名，确保别名的键也设置为默认值 + (aliases[k] || []).forEach(function (x) { + setKey(argv, x.split('.'), defaults[k]); + }); + } }); - } - }); - if (opts['--']) { - argv['--'] = notFlags.slice(); - } else { - notFlags.forEach(function (k) { - argv._.push(k); - }); - } +// 如果 opts 中包含 `--`，将非标志参数（即 "--" 后面的参数）保存到 `argv['--']` + if (opts['--']) { + argv['--'] = notFlags.slice(); + } else { + // 否则，将其保存到 argv._ 中 + notFlags.forEach(function (k) { + argv._.push(k); + }); + } - return argv; -}; +// 返回最终解析的 argv 对象，包含所有处理后的命令行参数 + return argv; -- 2.34.1 From 8fd40e3b2781361586a643f0bdad648b2ecb8937 Mon Sep 17 00:00:00 2001 From: zhangchao <3393187263@qq.com> Date: Tue, 17 Dec 2024 13:28:28 +0800 Subject: [PATCH 3/3] 6 --- node_modules/minimist/index.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/node_modules/minimist/index.js b/node_modules/minimist/index.js index ca36957..bd28034 100644 --- a/node_modules/minimist/index.js +++ b/node_modules/minimist/index.js @@ -276,3 +276,6 @@ module.exports = function (args, opts) { // 返回最终解析的 argv 对象，包含所有处理后的命令行参数 return argv; + + + -- 2.34.1