melperjs 5.0.0 → 6.0.0

package/mjs/index.js

@@ -1,157 +1,157 @@
-import xss from "xss";
-import camelCase from "lodash/camelCase.js";
-import capitalize from "lodash/capitalize.js";
-import isEmpty from "lodash/isEmpty.js";
-import setCookieParser from "set-cookie-parser";
-export const CONSTANTS = {
-  LOWER_CASE: "abcdefghijklmnopqrstuvwxyz",
-  UPPER_CASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
-  HEXADECIMAL: "0123456789abcdef",
-  NUMBERS: "0123456789"
-};
-export function Exception(message, response = {}, name = null) {
-  response.status = response.status || 400;
-  return {
-    name: pascalCase(name),
-    message,
-    response
-  };
-}
-export function time() {
-  return Math.floor(Date.now() / 1000);
-}
-export async function sleepMs(milliseconds) {
-  return new Promise(resolve => setTimeout(resolve, milliseconds));
-}
-export async function sleep(seconds) {
-  return await sleepMs(seconds * 1000);
-}
-export function promiseTimeout(milliseconds, promise) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error('Promise timed out after ' + milliseconds + 'ms'));
-    }, milliseconds);
-    promise.then(value => {
-      clearTimeout(timer);
-      resolve(value);
-    }).catch(reason => {
-      clearTimeout(timer);
-      reject(reason);
-    });
-  });
-}
-export function splitLines(text) {
-  return text.split(/\r?\n/).filter(item => !checkEmpty(item)).map(item => item.trim());
-}
-export function findKeyNode(key, node, pair = null) {
-  if (node && node.hasOwnProperty(key) && (pair ? node[key] === pair : true)) {
-    return node;
-  } else if (typeof node === 'object') {
-    for (let index in node) {
-      const result = findKeyNode(key, node[index], pair);
-      if (result) {
-        return result;
-      }
-    }
-  }
-  return null;
-}
-export function checkEmpty(value) {
-  if (typeof value === "number") {
-    return value === 0;
-  } else {
-    return isEmpty(value);
-  }
-}
-export function pascalCase(str) {
-  return upperCaseFirst(camelCase(str));
-}
-export function upperCaseFirst(str) {
-  str = str || "";
-  return str[0].toUpperCase() + str.slice(1);
-}
-export function lowerCaseFirst(str) {
-  str = str || "";
-  return str[0].toLowerCase() + str.slice(1);
-}
-export function titleString(str) {
-  str = str || "";
-  return str.split(' ').map(word => capitalize(word)).join(' ');
-}
-export function limitString(str, limit = 35) {
-  str = str || "";
-  if (str.length <= limit) {
-    return str;
-  } else {
-    return str.substring(0, limit - 3) + "...";
-  }
-}
-export function safeString(str) {
-  str = str || "";
-  return xss(str, {
-    whiteList: {},
-    stripIgnoreTag: true,
-    stripIgnoreTagBody: ["script"]
-  });
-}
-export function randomString(length, useNumbers = true, useUppercase = false) {
-  let characters = CONSTANTS.LOWER_CASE;
-  if (useUppercase) characters += CONSTANTS.UPPER_CASE;
-  if (useNumbers) characters += CONSTANTS.NUMBERS;
-  let randomString = '';
-  for (let i = 0; i < length; i++) {
-    const randomIndex = Math.floor(Math.random() * characters.length);
-    randomString += characters[randomIndex];
-  }
-  return randomString;
-}
-export function randomHex(length) {
-  let result = '';
-  for (let i = 0; i < length; i++) {
-    const randomIndex = Math.floor(Math.random() * CONSTANTS.HEXADECIMAL.length);
-    result += CONSTANTS.HEXADECIMAL[randomIndex];
-  }
-  return result;
-}
-export function randomUuid(useDashes = true) {
-  let d = Date.now();
-  const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-    const r = (d + Math.random() * 16) % 16 | 0;
-    d = Math.floor(d / 16);
-    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
-  });
-  return useDashes ? uuid : uuid.replaceAll("-", "");
-}
-export function randomWeighted(dict, randomFunc = totalWeight => Math.random() * totalWeight) {
-  let elements = Object.keys(dict);
-  let weights = Object.values(dict);
-  let totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
-  let randomNum = randomFunc(totalWeight);
-  let weightSum = 0;
-  for (let i = 0; i < elements.length; i++) {
-    weightSum += weights[i];
-    if (randomNum <= weightSum) {
-      return elements[i];
-    }
-  }
-}
-export function cookieDict(res, decodeValues = false) {
-  let dict = {};
-  const cookies = setCookieParser.parse(res, {
-    decodeValues: decodeValues
-  });
-  for (let cookie of cookies) {
-    dict[cookie.name] = cookie.value;
-  }
-  return dict;
-}
-export function cookieHeader(cookieDict) {
-  return Object.entries(cookieDict).map(([key, value]) => `${key}=${value}`).join(';');
-}
-export function isIntlHttpCode(httpCode) {
-  return httpCode === undefined || httpCode === null || httpCode === 0 || httpCode === 402 || httpCode === 407 || httpCode === 466 || 500 <= httpCode;
-}
-export function isIntlError(e) {
-  return e?.message?.toLowerCase?.()?.includes?.("timeout") || e?.message?.toLowerCase?.()?.includes?.("aborted") || e?.message?.toLowerCase?.()?.includes?.("tls connection") || e?.message?.toLowerCase?.()?.includes?.("socket hang") || isIntlHttpCode(e?.response?.status);
-}
+import xss from "xss";
+import camelCase from "lodash/camelCase.js";
+import capitalize from "lodash/capitalize.js";
+import isEmpty from "lodash/isEmpty.js";
+import setCookieParser from "set-cookie-parser";
+export const CONSTANTS = {
+  LOWER_CASE: "abcdefghijklmnopqrstuvwxyz",
+  UPPER_CASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  HEXADECIMAL: "0123456789abcdef",
+  NUMBERS: "0123456789"
+};
+export function Exception(message, response = {}, name = null) {
+  response.status = response.status || 400;
+  return {
+    name: pascalCase(name),
+    message,
+    response
+  };
+}
+export function time() {
+  return Math.floor(Date.now() / 1000);
+}
+export async function sleepMs(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+export async function sleep(seconds) {
+  return await sleepMs(seconds * 1000);
+}
+export function promiseTimeout(milliseconds, promise) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error('Promise timed out after ' + milliseconds + 'ms'));
+    }, milliseconds);
+    promise.then(value => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch(reason => {
+      clearTimeout(timer);
+      reject(reason);
+    });
+  });
+}
+export function splitLines(text) {
+  return text.split(/\r?\n/).filter(item => !checkEmpty(item)).map(item => item.trim());
+}
+export function findKeyNode(key, node, pair = null) {
+  if (node && node.hasOwnProperty(key) && (pair ? node[key] === pair : true)) {
+    return node;
+  } else if (typeof node === 'object') {
+    for (let index in node) {
+      const result = findKeyNode(key, node[index], pair);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  return null;
+}
+export function checkEmpty(value) {
+  if (typeof value === "number") {
+    return value === 0;
+  } else {
+    return isEmpty(value);
+  }
+}
+export function pascalCase(str) {
+  return upperCaseFirst(camelCase(str));
+}
+export function upperCaseFirst(str) {
+  str = str || "";
+  return str[0].toUpperCase() + str.slice(1);
+}
+export function lowerCaseFirst(str) {
+  str = str || "";
+  return str[0].toLowerCase() + str.slice(1);
+}
+export function titleString(str) {
+  str = str || "";
+  return str.split(' ').map(word => capitalize(word)).join(' ');
+}
+export function limitString(str, limit = 35) {
+  str = str || "";
+  if (str.length <= limit) {
+    return str;
+  } else {
+    return str.substring(0, limit - 3) + "...";
+  }
+}
+export function safeString(str) {
+  str = str || "";
+  return xss(str, {
+    whiteList: {},
+    stripIgnoreTag: true,
+    stripIgnoreTagBody: ["script"]
+  });
+}
+export function randomString(length, useNumbers = true, useUppercase = false) {
+  let characters = CONSTANTS.LOWER_CASE;
+  if (useUppercase) characters += CONSTANTS.UPPER_CASE;
+  if (useNumbers) characters += CONSTANTS.NUMBERS;
+  let randomString = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    randomString += characters[randomIndex];
+  }
+  return randomString;
+}
+export function randomHex(length) {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * CONSTANTS.HEXADECIMAL.length);
+    result += CONSTANTS.HEXADECIMAL[randomIndex];
+  }
+  return result;
+}
+export function randomUuid(useDashes = true) {
+  let d = Date.now();
+  const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+export function randomWeighted(dict, randomFunc = totalWeight => Math.random() * totalWeight) {
+  let elements = Object.keys(dict);
+  let weights = Object.values(dict);
+  let totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  let randomNum = randomFunc(totalWeight);
+  let weightSum = 0;
+  for (let i = 0; i < elements.length; i++) {
+    weightSum += weights[i];
+    if (randomNum <= weightSum) {
+      return elements[i];
+    }
+  }
+}
+export function cookieDict(res, decodeValues = false) {
+  let dict = {};
+  const cookies = setCookieParser.parse(res, {
+    decodeValues: decodeValues
+  });
+  for (let cookie of cookies) {
+    dict[cookie.name] = cookie.value;
+  }
+  return dict;
+}
+export function cookieHeader(cookieDict) {
+  return Object.entries(cookieDict).map(([key, value]) => `${key}=${value}`).join(';');
+}
+export function isIntlHttpCode(httpCode) {
+  return httpCode === undefined || httpCode === null || httpCode === 0 || httpCode === 402 || httpCode === 407 || httpCode === 466 || 500 <= httpCode;
+}
+export function isIntlError(e) {
+  return e?.message?.toLowerCase?.()?.includes?.("timeout") || e?.message?.toLowerCase?.()?.includes?.("aborted") || e?.message?.toLowerCase?.()?.includes?.("tls connection") || e?.message?.toLowerCase?.()?.includes?.("socket hang") || isIntlHttpCode(e?.response?.status);
+}
 //# sourceMappingURL=index.js.map

package/mjs/node.js

@@ -1,176 +1,176 @@
-import fs from "fs";
-import path from "path";
-import crypto from "crypto";
-import { networkInterfaces } from "os";
-import { execSync } from "child_process";
-import bcrypt from "bcrypt";
-import axios from "axios";
-import { HttpsProxyAgent } from "hpagent";
-import { CONSTANTS, randomWeighted, sleep } from "./index.js";
-export function tokenString(length, useNumbers = true, useUppercase = false) {
-  const lowercaseChars = CONSTANTS.LOWER_CASE;
-  const uppercaseChars = CONSTANTS.UPPER_CASE;
-  const numbers = CONSTANTS.NUMBERS;
-  let characters = lowercaseChars;
-  if (useUppercase) characters += uppercaseChars;
-  if (useNumbers) characters += numbers;
-  let randomString = '';
-  while (randomString.length < length) {
-    const byte = crypto.randomBytes(1)[0];
-    const index = byte % characters.length;
-    if (byte < 256 - 256 % characters.length) {
-      randomString += characters[index];
-    }
-  }
-  return randomString;
-}
-export function tokenHex(length) {
-  return crypto.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
-}
-export function tokenUuid(useDashes = true) {
-  const uuid = crypto.randomUUID().toString();
-  return useDashes ? uuid : uuid.replaceAll("-", "");
-}
-export function tokenWeighted(dict) {
-  return randomWeighted(dict, crypto.randomInt);
-}
-export function serverIp() {
-  const interfaces = networkInterfaces();
-  for (const devName in interfaces) {
-    const interfaceValue = interfaces[devName];
-    for (let i = 0; i < interfaceValue.length; i++) {
-      const alias = interfaceValue[i];
-      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.address.startsWith("192.168.") && !alias.internal) return alias.address;
-    }
-  }
-  return '127.0.0.1';
-}
-export function getVersion() {
-  try {
-    const date = new Date(execSync('git show -s --format=%ci HEAD').toString().trim());
-    const formatDatePart = value => value.toString().padStart(2, '0');
-    const year = date.getFullYear().toString().slice(-2);
-    const month = formatDatePart(date.getMonth() + 1);
-    const day = formatDatePart(date.getDate());
-    const hour = formatDatePart(date.getHours());
-    const minute = formatDatePart(date.getMinutes());
-    return parseFloat(`${year}${month}.${day}${hour}${minute}`);
-  } catch {
-    return 1.0;
-  }
-}
-export function createNumDir(mainDirectory) {
-  fs.mkdirSync(mainDirectory, {
-    recursive: true
-  });
-  for (let i = 0; i <= 9; i++) {
-    try {
-      fs.mkdirSync(path.join(mainDirectory, i.toString()));
-    } catch (e) {
-      console.error(`createNumDir:${i}`, e.message);
-    }
-  }
-}
-export function md5(data) {
-  return crypto.createHash('md5').update(data).digest("hex");
-}
-export function hashBcrypt(plainText) {
-  return bcrypt.hashSync(plainText, bcrypt.genSaltSync(10));
-}
-export function verifyBcrypt(plainText, hash) {
-  return bcrypt.compareSync(plainText, hash);
-}
-export function formatProxy(proxy, protocol = "http") {
-  proxy = proxy.trim();
-  const splitByProtocol = proxy.split("://");
-  if (1 < splitByProtocol.length) protocol = splitByProtocol[0];
-  proxy = splitByProtocol[splitByProtocol.length - 1];
-  if (!proxy.includes("@")) {
-    const proxyParts = proxy.split(":");
-    if (4 <= proxyParts.length) {
-      proxy = `${proxyParts[proxyParts.length - 2]}:${proxyParts[proxyParts.length - 1]}@`;
-      proxyParts.pop();
-      proxyParts.pop();
-      proxy += proxyParts.join(":");
-    }
-  }
-  const proxyParts = proxy.split(':');
-  const proxyEnd = parseInt(proxyParts[proxyParts.length - 1]);
-  const proxyStart = proxyParts[proxyParts.length - 2];
-  if (!proxyStart.includes(".")) {
-    proxyParts.pop();
-    proxyParts[proxyParts.length - 1] = crypto.randomInt(parseInt(proxyStart), proxyEnd + 1).toString();
-  }
-  return protocol + "://" + proxyParts.join(':');
-}
-export function proxyObject(...args) {
-  let proxy = formatProxy(...args);
-  const splitByProtocol = proxy.split('://');
-  const splitById = splitByProtocol[splitByProtocol.length - 1].split('@');
-  const splitByConn = splitById[splitById.length - 1].split(':');
-  proxy = {
-    protocol: splitByProtocol[0],
-    host: splitByConn[0],
-    port: parseInt(splitByConn[1])
-  };
-  if (1 < splitById.length) {
-    const splitByAuth = splitById[0].split(':');
-    proxy.auth = {
-      username: splitByAuth[0],
-      password: splitByAuth[1]
-    };
-  }
-  return proxy;
-}
-export async function proxify(proxyConfig, callback = formatProxy) {
-  proxyConfig = proxyConfig || {};
-  const timeout = 7000;
-  if (proxyConfig.mode === 1) {
-    return callback(proxyConfig.proxy);
-  } else if (proxyConfig.mode === 2) {
-    const proxy = callback(proxyConfig.proxy);
-    try {
-      await axios.get(proxyConfig.resetApi, {
-        timeout
-      });
-    } catch {
-      return false;
-    }
-    await sleep(5);
-    for (let i = 0; i < 5; i++) {
-      try {
-        const res = await axios.get("https://api64.ipify.org", {
-          timeout,
-          httpsAgent: new HttpsProxyAgent({
-            proxy,
-            timeout: 7000
-          })
-        });
-        if (res.status === 200) return proxy;
-      } catch {
-        await sleep(3);
-      }
-    }
-  } else if (proxyConfig.mode === 3) {
-    try {
-      const res = await axios.get(proxyConfig.resetApi, {
-        timeout
-      });
-      if (res.status === 200) return callback(proxyConfig.proxy);
-    } catch {
-      return false;
-    }
-  } else if (proxyConfig.mode === 4) {
-    return callback(proxyConfig.proxy).replace("{SESSION}", tokenHex(8));
-  } else if (proxyConfig.mode === 5) {
-    try {
-      const lines = proxyConfig.proxy.split("\n");
-      const line = lines[crypto.randomInt(0, lines.length)];
-      return callback(line);
-    } catch {
-      return false;
-    }
-  }
-  return null;
-}
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { networkInterfaces } from "os";
+import { execSync } from "child_process";
+import bcrypt from "bcrypt";
+import axios from "axios";
+import { HttpsProxyAgent } from "hpagent";
+import { CONSTANTS, randomWeighted, sleep } from "./index.js";
+export function tokenString(length, useNumbers = true, useUppercase = false) {
+  const lowercaseChars = CONSTANTS.LOWER_CASE;
+  const uppercaseChars = CONSTANTS.UPPER_CASE;
+  const numbers = CONSTANTS.NUMBERS;
+  let characters = lowercaseChars;
+  if (useUppercase) characters += uppercaseChars;
+  if (useNumbers) characters += numbers;
+  let randomString = '';
+  while (randomString.length < length) {
+    const byte = crypto.randomBytes(1)[0];
+    const index = byte % characters.length;
+    if (byte < 256 - 256 % characters.length) {
+      randomString += characters[index];
+    }
+  }
+  return randomString;
+}
+export function tokenHex(length) {
+  return crypto.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
+}
+export function tokenUuid(useDashes = true) {
+  const uuid = crypto.randomUUID().toString();
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+export function tokenWeighted(dict) {
+  return randomWeighted(dict, crypto.randomInt);
+}
+export function serverIp() {
+  const interfaces = networkInterfaces();
+  for (const devName in interfaces) {
+    const interfaceValue = interfaces[devName];
+    for (let i = 0; i < interfaceValue.length; i++) {
+      const alias = interfaceValue[i];
+      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.address.startsWith("192.168.") && !alias.internal) return alias.address;
+    }
+  }
+  return '127.0.0.1';
+}
+export function getVersion() {
+  try {
+    const date = new Date(execSync('git show -s --format=%ci HEAD').toString().trim());
+    const formatDatePart = value => value.toString().padStart(2, '0');
+    const year = date.getFullYear().toString().slice(-2);
+    const month = formatDatePart(date.getMonth() + 1);
+    const day = formatDatePart(date.getDate());
+    const hour = formatDatePart(date.getHours());
+    const minute = formatDatePart(date.getMinutes());
+    return parseFloat(`${year}${month}.${day}${hour}${minute}`);
+  } catch {
+    return 1.0;
+  }
+}
+export function createNumDir(mainDirectory) {
+  fs.mkdirSync(mainDirectory, {
+    recursive: true
+  });
+  for (let i = 0; i <= 9; i++) {
+    try {
+      fs.mkdirSync(path.join(mainDirectory, i.toString()));
+    } catch (e) {
+      console.error(`createNumDir:${i}`, e.message);
+    }
+  }
+}
+export function md5(data) {
+  return crypto.createHash('md5').update(data).digest("hex");
+}
+export function hashBcrypt(plainText) {
+  return bcrypt.hashSync(plainText, bcrypt.genSaltSync(10));
+}
+export function verifyBcrypt(plainText, hash) {
+  return bcrypt.compareSync(plainText, hash);
+}
+export function formatProxy(proxy, protocol = "http") {
+  proxy = proxy.trim();
+  const splitByProtocol = proxy.split("://");
+  if (1 < splitByProtocol.length) protocol = splitByProtocol[0];
+  proxy = splitByProtocol[splitByProtocol.length - 1];
+  if (!proxy.includes("@")) {
+    const proxyParts = proxy.split(":");
+    if (4 <= proxyParts.length) {
+      proxy = `${proxyParts[proxyParts.length - 2]}:${proxyParts[proxyParts.length - 1]}@`;
+      proxyParts.pop();
+      proxyParts.pop();
+      proxy += proxyParts.join(":");
+    }
+  }
+  const proxyParts = proxy.split(':');
+  const proxyEnd = parseInt(proxyParts[proxyParts.length - 1]);
+  const proxyStart = proxyParts[proxyParts.length - 2];
+  if (!proxyStart.includes(".")) {
+    proxyParts.pop();
+    proxyParts[proxyParts.length - 1] = crypto.randomInt(parseInt(proxyStart), proxyEnd + 1).toString();
+  }
+  return protocol + "://" + proxyParts.join(':');
+}
+export function proxyObject(...args) {
+  let proxy = formatProxy(...args);
+  const splitByProtocol = proxy.split('://');
+  const splitById = splitByProtocol[splitByProtocol.length - 1].split('@');
+  const splitByConn = splitById[splitById.length - 1].split(':');
+  proxy = {
+    protocol: splitByProtocol[0],
+    host: splitByConn[0],
+    port: parseInt(splitByConn[1])
+  };
+  if (1 < splitById.length) {
+    const splitByAuth = splitById[0].split(':');
+    proxy.auth = {
+      username: splitByAuth[0],
+      password: splitByAuth[1]
+    };
+  }
+  return proxy;
+}
+export async function proxify(proxyConfig, callback = formatProxy) {
+  proxyConfig = proxyConfig || {};
+  const timeout = 7000;
+  if (proxyConfig.mode === 1) {
+    return callback(proxyConfig.proxy);
+  } else if (proxyConfig.mode === 2) {
+    const proxy = callback(proxyConfig.proxy);
+    try {
+      await axios.get(proxyConfig.resetApi, {
+        timeout
+      });
+    } catch {
+      return false;
+    }
+    await sleep(5);
+    for (let i = 0; i < 5; i++) {
+      try {
+        const res = await axios.get("https://api64.ipify.org", {
+          timeout,
+          httpsAgent: new HttpsProxyAgent({
+            proxy,
+            timeout: 7000
+          })
+        });
+        if (res.status === 200) return proxy;
+      } catch {
+        await sleep(3);
+      }
+    }
+  } else if (proxyConfig.mode === 3) {
+    try {
+      const res = await axios.get(proxyConfig.resetApi, {
+        timeout
+      });
+      if (res.status === 200) return callback(proxyConfig.proxy);
+    } catch {
+      return false;
+    }
+  } else if (proxyConfig.mode === 4) {
+    return callback(proxyConfig.proxy).replace("{SESSION}", tokenHex(8));
+  } else if (proxyConfig.mode === 5) {
+    try {
+      const lines = proxyConfig.proxy.split("\n");
+      const line = lines[crypto.randomInt(0, lines.length)];
+      return callback(line);
+    } catch {
+      return false;
+    }
+  }
+  return null;
+}
 //# sourceMappingURL=node.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melperjs",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "Javascript module to use predefined common functions and utilities",
   "keywords": [
     "helper",