melperjs 15.0.0 → 16.0.0

package/lib/cjs/node.cjs

@@ -0,0 +1,301 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.base64Decode = base64Decode;
+exports.base64Encode = base64Encode;
+exports.bcryptHash = bcryptHash;
+exports.bcryptVerify = bcryptVerify;
+exports.clearDirectory = clearDirectory;
+exports.createNumberedDirs = createNumberedDirs;
+exports.executeCommand = executeCommand;
+exports.gitVersion = gitVersion;
+exports.hash = hash;
+exports.hostIp = hostIp;
+exports.md5 = md5;
+exports.normalizeProxy = normalizeProxy;
+exports.parseProxy = parseProxy;
+exports.proxyValue = proxyValue;
+exports.readJsonFile = readJsonFile;
+exports.readJsonFileSync = readJsonFileSync;
+exports.secureRandomBoolean = secureRandomBoolean;
+exports.secureRandomElement = secureRandomElement;
+exports.secureRandomHex = secureRandomHex;
+exports.secureRandomInteger = secureRandomInteger;
+exports.secureRandomString = secureRandomString;
+exports.secureRandomUuid = secureRandomUuid;
+exports.secureRandomWeighted = secureRandomWeighted;
+exports.sha256 = sha256;
+exports.uuidFromSeed = uuidFromSeed;
+exports.writeJsonFile = writeJsonFile;
+exports.writeJsonFileSync = writeJsonFileSync;
+var _fs = _interopRequireWildcard(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _crypto = _interopRequireDefault(require("crypto"));
+var _os = require("os");
+var _child_process = require("child_process");
+var _util = require("util");
+var _bcryptjs = _interopRequireDefault(require("bcryptjs"));
+var _index = require("./index.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const execAsync = (0, _util.promisify)(_child_process.exec);
+function secureRandomBoolean() {
+  return _crypto.default.randomInt(2) === 0;
+}
+function secureRandomString(length, useNumbers = true, useUppercase = false) {
+  let characters = _index.CONSTANTS.LOWER_CASE;
+  if (useUppercase) characters += _index.CONSTANTS.UPPER_CASE;
+  if (useNumbers) characters += _index.CONSTANTS.NUMBERS;
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += characters[_crypto.default.randomInt(0, characters.length)];
+  }
+  return result;
+}
+function secureRandomHex(length) {
+  return _crypto.default.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
+}
+function secureRandomInteger(min, max) {
+  return _crypto.default.randomInt(min, max);
+}
+function secureRandomUuid(useDashes = true) {
+  const uuid = _crypto.default.randomUUID();
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+function secureRandomWeighted(object) {
+  const elements = Object.keys(object);
+  const weights = Object.values(object);
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  const randomNum = secureRandomInteger(0, totalWeight);
+  let weightSum = 0;
+  for (let i = 0; i < elements.length; i++) {
+    weightSum += weights[i];
+    if (randomNum < weightSum) {
+      return elements[i];
+    }
+  }
+}
+function secureRandomElement(object) {
+  if (!object) return undefined;
+  const values = Array.isArray(object) ? object : Object.values(object);
+  if (values.length === 0) return undefined;
+  return values[_crypto.default.randomInt(0, values.length)];
+}
+function uuidFromSeed(seed, useDashes = true) {
+  const hash = _crypto.default.createHash('md5').update(seed).digest();
+  hash[6] = hash[6] & 0x0f | 0x30;
+  hash[8] = hash[8] & 0x3f | 0x80;
+  const hex = hash.toString('hex');
+  if (!useDashes) return hex;
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function hash(algorithm, data) {
+  return _crypto.default.createHash(algorithm).update(data).digest("hex");
+}
+function md5(data) {
+  return hash("md5", data);
+}
+function sha256(data) {
+  return hash("sha256", data);
+}
+function base64Encode(data) {
+  return Buffer.from(data).toString('base64');
+}
+function base64Decode(data, encoding = 'utf8') {
+  return Buffer.from(data, 'base64').toString(encoding);
+}
+function bcryptHash(plainText, {
+  key = "",
+  strength = 12,
+  preHash = true
+} = {}) {
+  let input = plainText + key;
+  if (preHash) {
+    input = sha256(input);
+  }
+  return _bcryptjs.default.hashSync(input, strength);
+}
+function bcryptVerify(plainText, hash, {
+  key = "",
+  preHash = true
+} = {}) {
+  let input = plainText + key;
+  if (preHash) {
+    input = sha256(input);
+  }
+  return _bcryptjs.default.compareSync(input, hash);
+}
+function normalizeProxy(proxy, protocol = "http") {
+  proxy = proxy?.trim();
+  if (!proxy) return null;
+  const schemeMatch = proxy.match(/^([a-z][a-z0-9+.-]*):\/\/(.+)$/i);
+  if (schemeMatch) {
+    protocol = schemeMatch[1];
+    proxy = schemeMatch[2];
+  }
+  let auth = "";
+  let body = proxy;
+  const atIdx = body.lastIndexOf("@");
+  if (atIdx !== -1) {
+    auth = body.slice(0, atIdx) + "@";
+    body = body.slice(atIdx + 1);
+  }
+  if (!auth) {
+    // Note: when the password itself is all-digit and port-shaped (e.g. "admin:1234:host:port"),
+    // the heuristic cannot distinguish auth-first from host-first ordering and may pick the wrong branch.
+    const parts = body.split(":");
+    const isPort = s => /^\d+$/.test(s) && +s >= 1 && +s <= 65535;
+    if (parts.length === 4) {
+      if (isPort(parts[3]) && !isPort(parts[1])) {
+        // user:pass:host:port
+        auth = `${parts[0]}:${parts[1]}@`;
+        body = `${parts[2]}:${parts[3]}`;
+      } else {
+        // host:port:user:pass (default)
+        auth = `${parts[2]}:${parts[3]}@`;
+        body = `${parts[0]}:${parts[1]}`;
+      }
+    } else if (parts.length === 5) {
+      if (isPort(parts[3]) && isPort(parts[4]) && !isPort(parts[1])) {
+        // user:pass:host:portStart:portEnd
+        auth = `${parts[0]}:${parts[1]}@`;
+        body = `${parts[2]}:${parts[3]}:${parts[4]}`;
+      } else {
+        // host:portStart:portEnd:user:pass (default)
+        auth = `${parts[3]}:${parts[4]}@`;
+        body = `${parts[0]}:${parts[1]}:${parts[2]}`;
+      }
+    }
+  }
+  const parts = body.split(":");
+  if (parts.length === 3) {
+    const start = Number(parts[1]);
+    const end = Number(parts[2]);
+    if (Number.isInteger(start) && Number.isInteger(end) && start >= 0 && start <= end) {
+      body = `${parts[0]}:${_crypto.default.randomInt(start, end + 1)}`;
+    }
+  }
+  return `${protocol}://${auth}${body}`;
+}
+function parseProxy(proxy, protocol = "http") {
+  const normalized = normalizeProxy(proxy, protocol);
+  if (!normalized) return null;
+  const [scheme, rest] = normalized.split("://");
+  const atIdx = rest.lastIndexOf("@");
+  const authPart = atIdx === -1 ? null : rest.slice(0, atIdx);
+  const hostPart = atIdx === -1 ? rest : rest.slice(atIdx + 1);
+  const [host, port] = hostPart.split(":");
+  const result = {
+    protocol: scheme,
+    host,
+    port: parseInt(port, 10)
+  };
+  if (authPart !== null) {
+    const colonIdx = authPart.indexOf(":");
+    const [username, password] = colonIdx === -1 ? [authPart, ""] : [authPart.slice(0, colonIdx), authPart.slice(colonIdx + 1)];
+    result.auth = {
+      username,
+      password
+    };
+  }
+  return result;
+}
+function proxyValue(rawProxy, replacements = {}) {
+  const list = (0, _index.splitTrim)(rawProxy || "");
+  if (list.length === 0) return null;
+  const picked = list[(0, _index.randomInteger)(0, list.length)];
+  const {
+    SESSION,
+    ...rest
+  } = replacements;
+  let sessionValue;
+  if (SESSION === undefined) {
+    sessionValue = (0, _index.randomHex)(8);
+  } else if (typeof SESSION === "function") {
+    sessionValue = SESSION();
+  } else {
+    sessionValue = (0, _index.seedHex)(String(SESSION), 8);
+  }
+  let result = normalizeProxy(picked);
+  if (!result) return null;
+  result = result.replace("{SESSION}", sessionValue);
+  for (const [key, value] of Object.entries(rest)) {
+    const v = typeof value === "function" ? value() : String(value);
+    result = result.replace(`{${key}}`, v);
+  }
+  return result;
+}
+async function readJsonFile(filePath, defaultValue = {}) {
+  try {
+    const data = await _fs.promises.readFile(filePath, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return defaultValue;
+  }
+}
+function readJsonFileSync(filePath, defaultValue = {}) {
+  try {
+    const data = _fs.default.readFileSync(filePath, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return defaultValue;
+  }
+}
+function writeJsonFile(filePath, data) {
+  const jsonData = JSON.stringify(data);
+  return _fs.promises.writeFile(filePath, jsonData, 'utf8');
+}
+function writeJsonFileSync(filePath, data) {
+  const jsonData = JSON.stringify(data);
+  return _fs.default.writeFileSync(filePath, jsonData, 'utf8');
+}
+async function clearDirectory(directoryPath, keepDir = true) {
+  await _fs.promises.rm(directoryPath, {
+    recursive: true,
+    force: true
+  });
+  if (keepDir) await _fs.promises.mkdir(directoryPath, {
+    recursive: true
+  });
+}
+function createNumberedDirs(mainDirectory, start = 0, end = 9) {
+  _fs.default.mkdirSync(mainDirectory, {
+    recursive: true
+  });
+  for (let i = start; i <= end; i++) {
+    _fs.default.mkdirSync(_path.default.join(mainDirectory, `${i}`), {
+      recursive: true
+    });
+  }
+}
+async function executeCommand(command) {
+  const {
+    stdout
+  } = await execAsync(command);
+  return stdout.trim();
+}
+function hostIp() {
+  for (const list of Object.values((0, _os.networkInterfaces)())) {
+    for (const alias of list) {
+      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';
+}
+function gitVersion() {
+  try {
+    const raw = (0, _child_process.execFileSync)('git', ['show', '-s', '--format=%ct', 'HEAD'], {
+      encoding: 'utf8'
+    }).trim();
+    const timestamp = parseInt(raw, 10);
+    if (isNaN(timestamp)) return "1.0";
+    const iso = new Date(timestamp * 1000).toISOString();
+    return `${iso.slice(2, 4)}${iso.slice(5, 7)}${iso.slice(8, 10)}.${iso.slice(11, 13)}${iso.slice(14, 16)}`;
+  } catch {
+    return "1.0";
+  }
+}

package/lib/esm/index.mjs

@@ -0,0 +1,306 @@
+import xss from "xss";
+import setCookieParser from "set-cookie-parser";
+import camelCase from "lodash/camelCase.js";
+import upperFirst from "lodash/upperFirst.js";
+import isEmpty from "lodash/isEmpty.js";
+import shuffle from "lodash/shuffle.js";
+export const CONSTANTS = {
+  LOWER_CASE: "abcdefghijklmnopqrstuvwxyz",
+  UPPER_CASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  HEXADECIMAL: "0123456789abcdef",
+  NUMBERS: "0123456789",
+  INT32_MIN: -2147483648,
+  INT32_MAX: 2147483647
+};
+const NUMBER_PATTERN = /^-?\d+(\.\d+)?(e[+-]?\d+)?$/i;
+const INTEGER_PATTERN = /^-?\d+$/;
+export function Exception(message, response = {}, name = null) {
+  const error = new Error(message);
+  error.name = name || "Exception";
+  error.response = response;
+  if (checkEmpty(response)) {
+    error.response = {};
+  }
+  return error;
+}
+export function time() {
+  return Math.floor(Date.now() / 1000);
+}
+export function sleepMs(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+export function sleep(seconds) {
+  return sleepMs(seconds * 1000);
+}
+export function promiseTimeout(milliseconds, promise) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Promise timed out after ${milliseconds}ms`)), milliseconds);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+export function promiseSilent(promise) {
+  return promise.then(() => {}).catch(() => {});
+}
+export async function forever(delayMs, task, onError = null, onFinally = null) {
+  if (!isPositiveNumber(delayMs)) throw new Error("delayMs must be a positive number");
+  const maybeUpdate = value => {
+    if (isPositiveNumber(value)) delayMs = value;
+  };
+  while (true) {
+    try {
+      maybeUpdate(await task());
+    } catch (error) {
+      if (onError) maybeUpdate(await onError(error));
+    } finally {
+      if (onFinally) {
+        try {
+          maybeUpdate(await onFinally());
+        } catch {}
+      }
+      await sleepMs(delayMs);
+    }
+  }
+}
+export async function retry(callFn, maxAttempts, errorFn = null, {
+  delayMs = 0,
+  backoffFactor = 1
+} = {}) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await callFn();
+    } catch (error) {
+      if (errorFn) await errorFn(attempt, error);
+      if (attempt >= maxAttempts) throw error;
+      if (delayMs > 0) await sleepMs(delayMs * backoffFactor ** (attempt - 1));
+    }
+  }
+}
+export function isValidURL(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function splitTrim(string, separator = null) {
+  return string.split(separator ?? /\r?\n/).map(item => item.trim()).filter(Boolean);
+}
+export function checkEmpty(value) {
+  if (typeof value === "number") return value === 0;
+  return isEmpty(value);
+}
+export function pascalCase(string) {
+  return upperFirst(camelCase(string));
+}
+export function titleCase(string, separator = " ") {
+  return (string || "").split(separator).map(upperFirst).join(separator);
+}
+export function isInt32(value) {
+  return Number.isInteger(value) && value >= CONSTANTS.INT32_MIN && value <= CONSTANTS.INT32_MAX;
+}
+export function isPositiveNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+export function coerceObjectNumbers(object) {
+  for (const key of Object.keys(object)) {
+    const value = object[key];
+    if (typeof value === 'string' && NUMBER_PATTERN.test(value)) {
+      object[key] = parseFloat(value);
+    }
+  }
+  return object;
+}
+export function coerceObjectIntegers(object) {
+  for (const key of Object.keys(object)) {
+    const value = object[key];
+    if (typeof value === 'string' && INTEGER_PATTERN.test(value)) {
+      object[key] = parseInt(value);
+    }
+  }
+  return object;
+}
+export function findNodeByKey(key, node, pair = null) {
+  if (node && typeof node === 'object') {
+    if (Object.hasOwn(node, key) && (pair === null || node[key] === pair)) {
+      return node;
+    }
+    for (const childKey of Object.keys(node)) {
+      const result = findNodeByKey(key, node[childKey], pair);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+export function waitForProperty(object, property, timeout = 5000, interval = 100) {
+  return new Promise((resolve, reject) => {
+    if (Object.hasOwn(object, property)) {
+      resolve(object[property]);
+      return;
+    }
+    const startTime = Date.now();
+    const checkProperty = setInterval(() => {
+      if (Object.hasOwn(object, property)) {
+        clearInterval(checkProperty);
+        resolve(object[property]);
+      } else if (Date.now() - startTime >= timeout) {
+        clearInterval(checkProperty);
+        reject(new Error(`Property "${property}" did not appear within ${timeout} milliseconds`));
+      }
+    }, interval);
+  });
+}
+export function shuffleObject(object) {
+  return Object.fromEntries(shuffle(Object.entries(object)));
+}
+export function objectStringify(object) {
+  for (const key of Object.keys(object)) {
+    const value = object[key];
+    if (value !== null && typeof value === 'object') {
+      objectStringify(value);
+    } else {
+      object[key] = String(value);
+    }
+  }
+  return object;
+}
+export function limitString(string, limit = 35, omission = "...") {
+  string = string || "";
+  if (string.length <= limit) return string;
+  return string.slice(0, limit - omission.length) + omission;
+}
+export function safeString(string) {
+  return xss(string || "", {
+    whiteList: {},
+    stripIgnoreTag: true,
+    stripIgnoreTagBody: ["script", "style", "iframe", "object", "embed", "form"],
+    css: false
+  });
+}
+export function shuffleString(string) {
+  return shuffle(string.split('')).join('');
+}
+export function randomBoolean() {
+  return Math.random() < 0.5;
+}
+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 result = '';
+  for (let i = 0; i < length; i++) {
+    result += characters[Math.random() * characters.length | 0];
+  }
+  return result;
+}
+export function randomHex(length) {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += CONSTANTS.HEXADECIMAL[Math.random() * 16 | 0];
+  }
+  return result;
+}
+export function randomInteger(min, max) {
+  if (typeof max === 'undefined') {
+    max = min;
+    min = 0;
+  }
+  if (typeof min !== 'number' || typeof max !== 'number') {
+    throw new Error('min and max must be numerical values');
+  }
+  if (max <= min) {
+    throw new Error('max must be greater than min');
+  }
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+export function randomUuid(useDashes = true) {
+  const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = Math.random() * 16 | 0;
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+export function randomWeighted(object) {
+  const elements = Object.keys(object);
+  const weights = Object.values(object);
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  const randomNum = Math.random() * totalWeight;
+  let weightSum = 0;
+  for (let i = 0; i < elements.length; i++) {
+    weightSum += weights[i];
+    if (randomNum < weightSum) {
+      return elements[i];
+    }
+  }
+}
+export function randomElement(object) {
+  if (!object) return undefined;
+  const values = Array.isArray(object) ? object : Object.values(object);
+  if (values.length === 0) return undefined;
+  return values[Math.floor(Math.random() * values.length)];
+}
+export function mulberry32(seed) {
+  if (typeof seed === "string") {
+    let h = 0;
+    for (let i = 0; i < seed.length; i++) {
+      h = Math.imul(h ^ seed.charCodeAt(i), 2654435761);
+    }
+    seed = h >>> 0;
+  }
+  return function () {
+    seed = seed + 0x6D2B79F5 | 0;
+    let t = seed;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+export function seedHex(seed, length) {
+  const rng = mulberry32(String(seed));
+  let result = '';
+  while (result.length < length) {
+    result += Math.floor(rng() * 0x100000000).toString(16).padStart(8, '0');
+  }
+  return result.slice(0, length);
+}
+export function cookiesFromResponse(response, decodeValues = false) {
+  const dict = {};
+  const cookies = setCookieParser.parse(response, {
+    decodeValues
+  });
+  for (const cookie of cookies) {
+    dict[cookie.name] = cookie.value;
+  }
+  return dict;
+}
+export function cookiesToHeader(cookies) {
+  if (!cookies) return "";
+  return Object.entries(cookies).filter(([, value]) => value !== null && value !== undefined).map(([key, value]) => `${key}=${value}`).join("; ");
+}
+export function cookiesFromHeader(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  header.split(';').forEach(cookie => {
+    const trimmed = cookie.trim();
+    if (!trimmed.includes('=')) return;
+    const [key, ...valueParts] = trimmed.split('=');
+    const trimmedKey = key.trim();
+    if (trimmedKey) {
+      cookies[trimmedKey] = valueParts.join('=').trim();
+    }
+  });
+  return cookies;
+}
+export function isTransientHttpCode(httpCode) {
+  return !httpCode || isNaN(httpCode) || httpCode === 100 || httpCode === 402 || httpCode === 407 || 460 <= httpCode && httpCode < 470 || 500 <= httpCode;
+}
+export function getResponseError(error, limit = 200) {
+  let response;
+  if (error?.response?.status && error.response.data) {
+    response = `${error.response.status}|${error.response.data}`;
+  } else if (error?.response?.data) {
+    response = error.response.data;
+  }
+  return limitString(response || error.message, limit).trim();
+}