pamj3bxuk
/
blockvote
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

4 #9

Merged
pamj3bxuk merged 3 commits from cunchu_zc into main 1 year ago
Conversation 0 Commits 3 Files Changed 2
2 changed files with 168 additions and 124 deletions
Show Stats Download Patch File Download Diff File

62
node_modules/minimalistic-crypto-utils/lib/utils.js generated vendored
Unescape View File

@ -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; // 否则，直接返回原始数组
};

230
node_modules/minimist/index.js generated vendored
Unescape View File

@ -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,177 @@ 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);
});
}
// 返回最终解析的 argv 对象，包含所有处理后的命令行参数
return argv;
return argv;
};

Write Preview
Loading…
Cancel
Save