编排新增url/dns/buffer/zlib，新增arrayEditor组件，优化parseFunction

plugin/lib/quickcomposer.js

@@ -3,6 +3,8 @@ const quickcomposer = {
   simulate: require("./quickcomposer/simulate"),
   file: require("./quickcomposer/file"),
   system: require("./quickcomposer/system"),
+  network: require("./quickcomposer/network"),
+  developer: require("./quickcomposer/developer"),
 };
 
 module.exports = quickcomposer;

plugin/lib/quickcomposer/developer/buffer.js

@@ -0,0 +1,140 @@
+// 创建 Buffer
+function from(data, encoding = "utf8") {
+  try {
+    return Buffer.from(data, encoding);
+  } catch (error) {
+    throw new Error(`创建Buffer失败: ${error.message}`);
+  }
+}
+
+// 转换为字符串
+function toString(buffer, encoding = "utf8", start = 0, end = buffer.length) {
+  try {
+    return buffer.toString(encoding, start, end);
+  } catch (error) {
+    throw new Error(`转换字符串失败: ${error.message}`);
+  }
+}
+
+// 写入数据
+function write(
+  buffer,
+  string,
+  offset = 0,
+  length = buffer.length,
+  encoding = "utf8"
+) {
+  try {
+    return buffer.write(string, offset, length, encoding);
+  } catch (error) {
+    throw new Error(`写入数据失败: ${error.message}`);
+  }
+}
+
+// 填充数据
+function fill(
+  buffer,
+  value,
+  offset = 0,
+  end = buffer.length,
+  encoding = "utf8"
+) {
+  try {
+    return buffer.fill(value, offset, end, encoding);
+  } catch (error) {
+    throw new Error(`填充数据失败: ${error.message}`);
+  }
+}
+
+// 复制数据
+function copy(
+  source,
+  target,
+  targetStart = 0,
+  sourceStart = 0,
+  sourceEnd = source.length
+) {
+  try {
+    return source.copy(target, targetStart, sourceStart, sourceEnd);
+  } catch (error) {
+    throw new Error(`复制数据失败: ${error.message}`);
+  }
+}
+
+// 比较数据
+function compare(buf1, buf2) {
+  try {
+    return Buffer.compare(buf1, buf2);
+  } catch (error) {
+    throw new Error(`比较数据失败: ${error.message}`);
+  }
+}
+
+// 连接 Buffer
+function concat(buffers, totalLength) {
+  try {
+    return Buffer.concat(buffers, totalLength);
+  } catch (error) {
+    throw new Error(`连接Buffer失败: ${error.message}`);
+  }
+}
+
+// 查找数据
+function indexOf(buffer, value, byteOffset = 0, encoding = "utf8") {
+  try {
+    return buffer.indexOf(value, byteOffset, encoding);
+  } catch (error) {
+    throw new Error(`查找数据失败: ${error.message}`);
+  }
+}
+
+// 切片数据
+function slice(buffer, start = 0, end = buffer.length) {
+  try {
+    return buffer.slice(start, end);
+  } catch (error) {
+    throw new Error(`切片数据失败: ${error.message}`);
+  }
+}
+
+// 交换字节序
+function swap(buffer, size) {
+  try {
+    switch (size) {
+      case 16:
+        return buffer.swap16();
+      case 32:
+        return buffer.swap32();
+      case 64:
+        return buffer.swap64();
+      default:
+        throw new Error("不支持的字节大小");
+    }
+  } catch (error) {
+    throw new Error(`交换字节序失败: ${error.message}`);
+  }
+}
+
+module.exports = {
+  from,
+  toString,
+  write,
+  fill,
+  copy,
+  compare,
+  concat,
+  indexOf,
+  slice,
+  swap,
+  // 编码类型
+  encodings: [
+    "utf8",
+    "utf16le",
+    "latin1",
+    "base64",
+    "hex",
+    "ascii",
+    "binary",
+    "ucs2",
+  ],
+};

plugin/lib/quickcomposer/developer/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  buffer: require("./buffer"),
+};

plugin/lib/quickcomposer/file/index.js

@@ -1,5 +1,7 @@
 const operation = require("./operation");
+const zlib = require("./zlib");
 
 module.exports = {
   operation: operation.operation,
+  zlib: zlib,
 };

plugin/lib/quickcomposer/file/zlib.js

@@ -0,0 +1,75 @@
+const zlib = require("zlib");
+const { promisify } = require("util");
+
+// 压缩方法
+const gzip = promisify(zlib.gzip);
+const deflate = promisify(zlib.deflate);
+const brotliCompress = promisify(zlib.brotliCompress);
+
+// 解压方法
+const gunzip = promisify(zlib.gunzip);
+const inflate = promisify(zlib.inflate);
+const brotliDecompress = promisify(zlib.brotliDecompress);
+
+// 压缩选项
+const defaultGzipOptions = {
+  level: zlib.constants.Z_DEFAULT_COMPRESSION,
+  memLevel: zlib.constants.Z_DEFAULT_MEMLEVEL,
+  strategy: zlib.constants.Z_DEFAULT_STRATEGY,
+};
+
+const defaultBrotliOptions = {
+  params: {
+    [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_GENERIC,
+    [zlib.constants.BROTLI_PARAM_QUALITY]:
+      zlib.constants.BROTLI_DEFAULT_QUALITY,
+    [zlib.constants.BROTLI_PARAM_SIZE_HINT]: 0,
+  },
+};
+
+// 异步压缩函数
+async function compressData(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return await gzip(buffer, { ...defaultGzipOptions, ...options });
+      case "deflate":
+        return await deflate(buffer, { ...defaultGzipOptions, ...options });
+      case "brotli":
+        return await brotliCompress(buffer, {
+          ...defaultBrotliOptions,
+          ...options,
+        });
+      default:
+        throw new Error("不支持的压缩方法");
+    }
+  } catch (error) {
+    throw new Error(`压缩失败: ${error.message}`);
+  }
+}
+
+// 异步解压函数
+async function decompressData(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return await gunzip(buffer, options);
+      case "deflate":
+        return await inflate(buffer, options);
+      case "brotli":
+        return await brotliDecompress(buffer, options);
+      default:
+        throw new Error("不支持的解压方法");
+    }
+  } catch (error) {
+    throw new Error(`解压失败: ${error.message}`);
+  }
+}
+
+module.exports = {
+  compressData,
+  decompressData,
+  constants: zlib.constants,
+};

plugin/lib/quickcomposer/network/dns.js

@@ -0,0 +1,106 @@
+const dns = require("dns");
+const { promisify } = require("util");
+
+// 将回调函数转换为 Promise
+const lookup = promisify(dns.lookup);
+const resolve = promisify(dns.resolve);
+const resolve4 = promisify(dns.resolve4);
+const resolve6 = promisify(dns.resolve6);
+const resolveMx = promisify(dns.resolveMx);
+const resolveTxt = promisify(dns.resolveTxt);
+const resolveNs = promisify(dns.resolveNs);
+const resolveCname = promisify(dns.resolveCname);
+const reverse = promisify(dns.reverse);
+
+// 解析主机名
+async function lookupHost(hostname, options = {}) {
+  try {
+    return await lookup(hostname, options);
+  } catch (error) {
+    throw new Error(`DNS查询失败: ${error.message}`);
+  }
+}
+
+// 解析所有记录
+async function resolveAll(hostname) {
+  try {
+    return await resolve(hostname);
+  } catch (error) {
+    throw new Error(`DNS解析失败: ${error.message}`);
+  }
+}
+
+// 解析 IPv4 地址
+async function resolveIpv4(hostname) {
+  try {
+    return await resolve4(hostname);
+  } catch (error) {
+    throw new Error(`IPv4解析失败: ${error.message}`);
+  }
+}
+
+// 解析 IPv6 地址
+async function resolveIpv6(hostname) {
+  try {
+    return await resolve6(hostname);
+  } catch (error) {
+    throw new Error(`IPv6解析失败: ${error.message}`);
+  }
+}
+
+// 解析 MX 记录
+async function resolveMxRecords(hostname) {
+  try {
+    return await resolveMx(hostname);
+  } catch (error) {
+    throw new Error(`MX记录解析失败: ${error.message}`);
+  }
+}
+
+// 解析 TXT 记录
+async function resolveTxtRecords(hostname) {
+  try {
+    return await resolveTxt(hostname);
+  } catch (error) {
+    throw new Error(`TXT记录解析失败: ${error.message}`);
+  }
+}
+
+// 解析 NS 记录
+async function resolveNsRecords(hostname) {
+  try {
+    return await resolveNs(hostname);
+  } catch (error) {
+    throw new Error(`NS记录解析失败: ${error.message}`);
+  }
+}
+
+// 解析 CNAME 记录
+async function resolveCnameRecords(hostname) {
+  try {
+    return await resolveCname(hostname);
+  } catch (error) {
+    throw new Error(`CNAME记录解析失败: ${error.message}`);
+  }
+}
+
+// 反向解析 IP 地址
+async function reverseResolve(ip) {
+  try {
+    return await reverse(ip);
+  } catch (error) {
+    throw new Error(`反向解析失败: ${error.message}`);
+  }
+}
+
+module.exports = {
+  lookupHost,
+  resolveAll,
+  resolveIpv4,
+  resolveIpv6,
+  resolveMxRecords,
+  resolveTxtRecords,
+  resolveNsRecords,
+  resolveCnameRecords,
+  reverseResolve,
+};

plugin/lib/quickcomposer/network/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  url: require("./url"),
+  dns: require("./dns"),
+};

plugin/lib/quickcomposer/network/url.js

@@ -0,0 +1,98 @@
+const url = require("url");
+
+// URL 解析
+function parse(urlString, parseQueryString = false) {
+  return url.parse(urlString, parseQueryString);
+}
+
+// URL 格式化
+function format(urlObject) {
+  return url.format(urlObject);
+}
+
+// 解析查询字符串
+function parseQuery(query) {
+  const searchParams = new URLSearchParams(query);
+  const result = {};
+  for (const [key, value] of searchParams) {
+    result[key] = value;
+  }
+  return result;
+}
+
+// 格式化查询字符串
+function formatQuery(queryObject) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(queryObject)) {
+    searchParams.append(key, value);
+  }
+  return searchParams.toString();
+}
+
+// 解析路径名
+function parsePath(path) {
+  return url.parse(path);
+}
+
+// 解析主机名
+function parseHost(host) {
+  const { hostname, port } = url.parse(`http://${host}`);
+  return { hostname, port };
+}
+
+// 解析 URL 参数
+function getQueryParam(urlString, param) {
+  const { query } = url.parse(urlString, true);
+  return query[param];
+}
+
+// 添加 URL 参数
+function addQueryParam(urlString, param, value) {
+  const parsedUrl = url.parse(urlString, true);
+  parsedUrl.query[param] = value;
+  parsedUrl.search = null; // 清除 search，以便 format 时使用 query
+  return url.format(parsedUrl);
+}
+
+// 移除 URL 参数
+function removeQueryParam(urlString, param) {
+  const parsedUrl = url.parse(urlString, true);
+  delete parsedUrl.query[param];
+  parsedUrl.search = null;
+  return url.format(parsedUrl);
+}
+
+// 检查是否是绝对 URL
+function isAbsolute(urlString) {
+  return url.parse(urlString).protocol !== null;
+}
+
+// 解析 URL 的各个部分
+function parseComponents(urlString) {
+  const { protocol, auth, hostname, port, pathname, search, hash } =
+    url.parse(urlString);
+
+  return {
+    protocol: protocol?.replace(":", ""),
+    auth,
+    hostname,
+    port,
+    pathname,
+    search: search?.replace("?", ""),
+    hash: hash?.replace("#", ""),
+  };
+}
+
+module.exports = {
+  parse,
+  format,
+  parseQuery,
+  formatQuery,
+  parsePath,
+  parseHost,
+  getQueryParam,
+  addQueryParam,
+  removeQueryParam,
+  isAbsolute,
+  parseComponents,
+};

plugin/lib/quickcomposer/zlib/index.js

@@ -0,0 +1 @@
+module.exports = require("../file/zlib");

plugin/lib/quickcomposer/zlib/zlib.js

@@ -0,0 +1,126 @@
+const zlib = require("zlib");
+const { promisify } = require("util");
+
+// 压缩方法
+const gzip = promisify(zlib.gzip);
+const deflate = promisify(zlib.deflate);
+const brotliCompress = promisify(zlib.brotliCompress);
+
+// 解压方法
+const gunzip = promisify(zlib.gunzip);
+const inflate = promisify(zlib.inflate);
+const brotliDecompress = promisify(zlib.brotliDecompress);
+
+// 同步方法
+const gzipSync = zlib.gzipSync;
+const gunzipSync = zlib.gunzipSync;
+const deflateSync = zlib.deflateSync;
+const inflateSync = zlib.inflateSync;
+const brotliCompressSync = zlib.brotliCompressSync;
+const brotliDecompressSync = zlib.brotliDecompressSync;
+
+// 压缩选项
+const defaultGzipOptions = {
+  level: zlib.constants.Z_DEFAULT_COMPRESSION,
+  memLevel: zlib.constants.Z_DEFAULT_MEMLEVEL,
+  strategy: zlib.constants.Z_DEFAULT_STRATEGY,
+};
+
+const defaultBrotliOptions = {
+  params: {
+    [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_GENERIC,
+    [zlib.constants.BROTLI_PARAM_QUALITY]:
+      zlib.constants.BROTLI_DEFAULT_QUALITY,
+    [zlib.constants.BROTLI_PARAM_SIZE_HINT]: 0,
+  },
+};
+
+// 异步压缩函数
+async function compressData(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return await gzip(buffer, { ...defaultGzipOptions, ...options });
+      case "deflate":
+        return await deflate(buffer, { ...defaultGzipOptions, ...options });
+      case "brotli":
+        return await brotliCompress(buffer, {
+          ...defaultBrotliOptions,
+          ...options,
+        });
+      default:
+        throw new Error("不支持的压缩方法");
+    }
+  } catch (error) {
+    throw new Error(`压缩失败: ${error.message}`);
+  }
+}
+
+// 异步解压函数
+async function decompressData(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return await gunzip(buffer, options);
+      case "deflate":
+        return await inflate(buffer, options);
+      case "brotli":
+        return await brotliDecompress(buffer, options);
+      default:
+        throw new Error("不支持的解压方法");
+    }
+  } catch (error) {
+    throw new Error(`解压失败: ${error.message}`);
+  }
+}
+
+// 同步压缩函数
+function compressDataSync(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return gzipSync(buffer, { ...defaultGzipOptions, ...options });
+      case "deflate":
+        return deflateSync(buffer, { ...defaultGzipOptions, ...options });
+      case "brotli":
+        return brotliCompressSync(buffer, {
+          ...defaultBrotliOptions,
+          ...options,
+        });
+      default:
+        throw new Error("不支持的压缩方法");
+    }
+  } catch (error) {
+    throw new Error(`压缩失败: ${error.message}`);
+  }
+}
+
+// 同步解压函数
+function decompressDataSync(data, method, options = {}) {
+  try {
+    const buffer = Buffer.from(data);
+    switch (method) {
+      case "gzip":
+        return gunzipSync(buffer, options);
+      case "deflate":
+        return inflateSync(buffer, options);
+      case "brotli":
+        return brotliDecompressSync(buffer, options);
+      default:
+        throw new Error("不支持的解压方法");
+    }
+  } catch (error) {
+    throw new Error(`解压失败: ${error.message}`);
+  }
+}
+
+module.exports = {
+  compressData,
+  decompressData,
+  compressDataSync,
+  decompressDataSync,
+  constants: zlib.constants,
+};