melperjs 17.1.1 → 17.2.1

package/README.md

@@ -14,6 +14,11 @@ npm i melperjs
 
 See the [docs folder](docs/README.md) for the full API reference.
 
+## Support
+
+If this project helps you, please consider giving it a [Star ⭐️](https://github.com/mahelbir/melperjs) on GitHub.
+This will encourage us to continue developing and maintaining this project.
+
 ## License
 
 The MIT License (MIT). Please see [License File](LICENSE) for more information.

package/dist/general.cjs

@@ -1,44 +1,426 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_general = require("./general-C6nIgKnW.cjs");
-exports.CONSTANTS = require_general.CONSTANTS;
-exports.Exception = require_general.Exception;
-exports.checkEmpty = require_general.checkEmpty;
-exports.coerceObjectIntegers = require_general.coerceObjectIntegers;
-exports.coerceObjectNumbers = require_general.coerceObjectNumbers;
-exports.cookiesFromHeader = require_general.cookiesFromHeader;
-exports.cookiesFromResponse = require_general.cookiesFromResponse;
-exports.cookiesToHeader = require_general.cookiesToHeader;
-exports.findNodeByKey = require_general.findNodeByKey;
-exports.forever = require_general.forever;
-exports.getResponseError = require_general.getResponseError;
-exports.isInt32 = require_general.isInt32;
-exports.isPositiveNumber = require_general.isPositiveNumber;
-exports.isTransientHttpCode = require_general.isTransientHttpCode;
-exports.isValidURL = require_general.isValidURL;
-exports.limitString = require_general.limitString;
-exports.mulberry32 = require_general.mulberry32;
-exports.normalizeProxy = require_general.normalizeProxy;
-exports.objectStringify = require_general.objectStringify;
-exports.parseProxy = require_general.parseProxy;
-exports.pascalCase = require_general.pascalCase;
-exports.promiseSilent = require_general.promiseSilent;
-exports.promiseTimeout = require_general.promiseTimeout;
-exports.proxyValue = require_general.proxyValue;
-exports.randomBoolean = require_general.randomBoolean;
-exports.randomElement = require_general.randomElement;
-exports.randomHex = require_general.randomHex;
-exports.randomInteger = require_general.randomInteger;
-exports.randomString = require_general.randomString;
-exports.randomUuid = require_general.randomUuid;
-exports.randomWeighted = require_general.randomWeighted;
-exports.retry = require_general.retry;
-exports.safeString = require_general.safeString;
-exports.seedHex = require_general.seedHex;
-exports.shuffleObject = require_general.shuffleObject;
-exports.shuffleString = require_general.shuffleString;
-exports.sleep = require_general.sleep;
-exports.sleepMs = require_general.sleepMs;
-exports.splitTrim = require_general.splitTrim;
-exports.time = require_general.time;
-exports.titleCase = require_general.titleCase;
-exports.waitForProperty = require_general.waitForProperty;
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+let xss = require("xss");
+xss = require_rolldown_runtime.__toESM(xss, 1);
+let set_cookie_parser = require("set-cookie-parser");
+set_cookie_parser = require_rolldown_runtime.__toESM(set_cookie_parser, 1);
+let es_toolkit_string = require("es-toolkit/string");
+let es_toolkit_array = require("es-toolkit/array");
+let es_toolkit_compat_isEmpty = require("es-toolkit/compat/isEmpty");
+es_toolkit_compat_isEmpty = require_rolldown_runtime.__toESM(es_toolkit_compat_isEmpty, 1);
+//#region src/general.js
+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+$/;
+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;
+}
+function time() {
+	return Math.floor(Date.now() / 1e3);
+}
+function sleepMs(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function sleep(seconds) {
+	return sleepMs(seconds * 1e3);
+}
+function promiseTimeout(milliseconds, promise) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Promise timed out after ${milliseconds}ms`)), milliseconds);
+	});
+	return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function promiseSilent(promise) {
+	return promise?.then(() => {})?.catch(() => {});
+}
+async function forever(delayMs, task, onError = null, onFinally = null) {
+	if (!isPositiveNumber(delayMs)) throw new Error("delayMs must be a positive number");
+	const update = (value) => {
+		if (isPositiveNumber(value)) delayMs = value;
+	};
+	while (true) try {
+		update(await task());
+	} catch (error) {
+		if (onError) update(await onError(error));
+	} finally {
+		if (onFinally) try {
+			update(await onFinally());
+		} catch {}
+		await sleepMs(delayMs);
+	}
+}
+async function retry(task, maxAttempts = 1, onError = null, { delayMs = 0, backoffFactor = 1 } = {}) {
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+		return await task();
+	} catch (error) {
+		if (onError) await onError(error, attempt);
+		if (attempt >= maxAttempts) throw error;
+		if (delayMs > 0) await sleepMs(delayMs * backoffFactor ** (attempt - 1));
+	}
+}
+function isValidURL(url) {
+	try {
+		new URL(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function splitTrim(string, separator = null) {
+	return string.split(separator ?? /\r?\n/).map((item) => item.trim()).filter(Boolean);
+}
+function pascalCase(string) {
+	return (0, es_toolkit_string.upperFirst)((0, es_toolkit_string.camelCase)(string));
+}
+function titleCase(string, separator = " ") {
+	return (string || "").split(separator).map(es_toolkit_string.upperFirst).join(separator);
+}
+function castString(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch {
+		return "{}";
+	}
+	return String(value);
+}
+function limitString(string, limit = 35, omission = "...") {
+	string = string || "";
+	if (string.length <= limit) return string;
+	return string.slice(0, limit - omission.length) + omission;
+}
+function safeString(string) {
+	return (0, xss.default)(string || "", {
+		whiteList: {},
+		stripIgnoreTag: true,
+		stripIgnoreTagBody: [
+			"script",
+			"style",
+			"iframe",
+			"object",
+			"embed",
+			"form"
+		],
+		css: false
+	});
+}
+function shuffleString(string) {
+	return (0, es_toolkit_array.shuffle)(string.split("")).join("");
+}
+function randomBoolean() {
+	return Math.random() < .5;
+}
+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;
+}
+function randomHex(length) {
+	let result = "";
+	for (let i = 0; i < length; i++) result += CONSTANTS.HEXADECIMAL[Math.random() * 16 | 0];
+	return result;
+}
+function randomInteger(min, max = void 0) {
+	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;
+}
+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 & 3 | 8).toString(16);
+	});
+	return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+function randomWeighted(object) {
+	if (checkEmpty(object)) return void 0;
+	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];
+	}
+}
+function randomElement(object) {
+	if (checkEmpty(object)) return void 0;
+	const values = Array.isArray(object) ? object : Object.values(object);
+	if (values.length === 0) return void 0;
+	return values[Math.floor(Math.random() * values.length)];
+}
+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 + 1831565813 | 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;
+	};
+}
+function seedHex(seed, length) {
+	const rng = mulberry32(String(seed));
+	let result = "";
+	while (result.length < length) result += Math.floor(rng() * 4294967296).toString(16).padStart(8, "0");
+	return result.slice(0, length);
+}
+function checkEmpty(value) {
+	if (typeof value === "number") return value === 0;
+	return (0, es_toolkit_compat_isEmpty.default)(value);
+}
+function isInt32(value) {
+	return Number.isInteger(value) && value >= CONSTANTS.INT32_MIN && value <= CONSTANTS.INT32_MAX;
+}
+function isPositiveNumber(value) {
+	return Number.isFinite(value) && value > 0;
+}
+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;
+}
+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;
+}
+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;
+}
+function waitForProperty(object, property, timeoutMs, 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 >= timeoutMs) {
+				clearInterval(checkProperty);
+				reject(/* @__PURE__ */ new Error(`Property "${property}" did not appear within ${timeoutMs}ms`));
+			}
+		}, interval);
+	});
+}
+function shuffleObject(object) {
+	return Object.fromEntries((0, es_toolkit_array.shuffle)(Object.entries(object)));
+}
+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;
+}
+function cookiesFromResponse(response, decodeValues = false) {
+	const obj = {};
+	const cookies = set_cookie_parser.default.parse(response, { decodeValues });
+	for (const cookie of cookies) obj[cookie.name] = cookie.value;
+	return obj;
+}
+function cookiesToHeader(cookies) {
+	if (!cookies) return "";
+	return Object.entries(cookies).filter(([, value]) => value !== null && value !== void 0).map(([key, value]) => `${key}=${value}`).join("; ");
+}
+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;
+}
+function isTransientHttpCode(httpCode) {
+	return !httpCode || isNaN(httpCode) || httpCode === 100 || httpCode === 402 || httpCode === 407 || 460 <= httpCode && httpCode < 470 || 500 <= httpCode;
+}
+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();
+}
+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) {
+		const parts = body.split(":");
+		const isPort = (s) => /^\d+$/.test(s) && +s >= 1 && +s <= 65535;
+		const isHost = (s) => s.includes(".") || /[a-z]/i.test(s);
+		if (parts.length === 4) if (isPort(parts[3]) && !isPort(parts[1])) {
+			auth = `${parts[0]}:${parts[1]}@`;
+			body = `${parts[2]}:${parts[3]}`;
+		} else if (isPort(parts[1]) && !isPort(parts[3])) {
+			auth = `${parts[2]}:${parts[3]}@`;
+			body = `${parts[0]}:${parts[1]}`;
+		} else if (isHost(parts[2]) && !isHost(parts[0])) {
+			auth = `${parts[0]}:${parts[1]}@`;
+			body = `${parts[2]}:${parts[3]}`;
+		} else {
+			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])) {
+			auth = `${parts[0]}:${parts[1]}@`;
+			body = `${parts[2]}:${parts[3]}:${parts[4]}`;
+		} else if (isPort(parts[1]) && isPort(parts[2]) && !isPort(parts[3])) {
+			auth = `${parts[3]}:${parts[4]}@`;
+			body = `${parts[0]}:${parts[1]}:${parts[2]}`;
+		} else if (isHost(parts[2]) && !isHost(parts[0])) {
+			auth = `${parts[0]}:${parts[1]}@`;
+			body = `${parts[2]}:${parts[3]}:${parts[4]}`;
+		} else {
+			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]}:${randomInteger(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 [host, port] = (atIdx === -1 ? rest : rest.slice(atIdx + 1)).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 = splitTrim(rawProxy || "");
+	if (list.length === 0) return null;
+	const picked = list[randomInteger(0, list.length)];
+	let result = normalizeProxy(picked);
+	if (!result) return null;
+	if (result.includes("{")) {
+		const { SESSION, ...rest } = replacements;
+		let sessionValue;
+		if (!SESSION && SESSION !== 0) sessionValue = randomHex(8);
+		else if (typeof SESSION === "function") sessionValue = SESSION();
+		else sessionValue = seedHex(String(SESSION), 8);
+		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;
+}
+//#endregion
+exports.CONSTANTS = CONSTANTS;
+exports.Exception = Exception;
+exports.castString = castString;
+exports.checkEmpty = checkEmpty;
+exports.coerceObjectIntegers = coerceObjectIntegers;
+exports.coerceObjectNumbers = coerceObjectNumbers;
+exports.cookiesFromHeader = cookiesFromHeader;
+exports.cookiesFromResponse = cookiesFromResponse;
+exports.cookiesToHeader = cookiesToHeader;
+exports.findNodeByKey = findNodeByKey;
+exports.forever = forever;
+exports.getResponseError = getResponseError;
+exports.isInt32 = isInt32;
+exports.isPositiveNumber = isPositiveNumber;
+exports.isTransientHttpCode = isTransientHttpCode;
+exports.isValidURL = isValidURL;
+exports.limitString = limitString;
+exports.mulberry32 = mulberry32;
+exports.normalizeProxy = normalizeProxy;
+exports.objectStringify = objectStringify;
+exports.parseProxy = parseProxy;
+exports.pascalCase = pascalCase;
+exports.promiseSilent = promiseSilent;
+exports.promiseTimeout = promiseTimeout;
+exports.proxyValue = proxyValue;
+exports.randomBoolean = randomBoolean;
+exports.randomElement = randomElement;
+exports.randomHex = randomHex;
+exports.randomInteger = randomInteger;
+exports.randomString = randomString;
+exports.randomUuid = randomUuid;
+exports.randomWeighted = randomWeighted;
+exports.retry = retry;
+exports.safeString = safeString;
+exports.seedHex = seedHex;
+exports.shuffleObject = shuffleObject;
+exports.shuffleString = shuffleString;
+exports.sleep = sleep;
+exports.sleepMs = sleepMs;
+exports.splitTrim = splitTrim;
+exports.time = time;
+exports.titleCase = titleCase;
+exports.waitForProperty = waitForProperty;

package/dist/general.mjs

@@ -76,74 +76,21 @@ function isValidURL(url) {
 function splitTrim(string, separator = null) {
 	return string.split(separator ?? /\r?\n/).map((item) => item.trim()).filter(Boolean);
 }
-function checkEmpty(value) {
-	if (typeof value === "number") return value === 0;
-	return isEmpty(value);
-}
 function pascalCase(string) {
 	return upperFirst(camelCase(string));
 }
 function titleCase(string, separator = " ") {
 	return (string || "").split(separator).map(upperFirst).join(separator);
 }
-function isInt32(value) {
-	return Number.isInteger(value) && value >= CONSTANTS.INT32_MIN && value <= CONSTANTS.INT32_MAX;
-}
-function isPositiveNumber(value) {
-	return Number.isFinite(value) && value > 0;
-}
-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;
-}
-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;
-}
-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;
-}
-function waitForProperty(object, property, timeoutMs, 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 >= timeoutMs) {
-				clearInterval(checkProperty);
-				reject(/* @__PURE__ */ new Error(`Property "${property}" did not appear within ${timeoutMs}ms`));
-			}
-		}, interval);
-	});
-}
-function shuffleObject(object) {
-	return Object.fromEntries(shuffle(Object.entries(object)));
-}
-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);
+function castString(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch {
+		return "{}";
 	}
-	return object;
+	return String(value);
 }
 function limitString(string, limit = 35, omission = "...") {
 	string = string || "";
@@ -238,6 +185,69 @@ function seedHex(seed, length) {
 	while (result.length < length) result += Math.floor(rng() * 4294967296).toString(16).padStart(8, "0");
 	return result.slice(0, length);
 }
+function checkEmpty(value) {
+	if (typeof value === "number") return value === 0;
+	return isEmpty(value);
+}
+function isInt32(value) {
+	return Number.isInteger(value) && value >= CONSTANTS.INT32_MIN && value <= CONSTANTS.INT32_MAX;
+}
+function isPositiveNumber(value) {
+	return Number.isFinite(value) && value > 0;
+}
+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;
+}
+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;
+}
+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;
+}
+function waitForProperty(object, property, timeoutMs, 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 >= timeoutMs) {
+				clearInterval(checkProperty);
+				reject(/* @__PURE__ */ new Error(`Property "${property}" did not appear within ${timeoutMs}ms`));
+			}
+		}, interval);
+	});
+}
+function shuffleObject(object) {
+	return Object.fromEntries(shuffle(Object.entries(object)));
+}
+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;
+}
 function cookiesFromResponse(response, decodeValues = false) {
 	const obj = {};
 	const cookies = setCookieParser.parse(response, { decodeValues });
@@ -366,4 +376,4 @@ function proxyValue(rawProxy, replacements = {}) {
 	return result;
 }
 //#endregion
-export { CONSTANTS, Exception, checkEmpty, coerceObjectIntegers, coerceObjectNumbers, cookiesFromHeader, cookiesFromResponse, cookiesToHeader, findNodeByKey, forever, getResponseError, isInt32, isPositiveNumber, isTransientHttpCode, isValidURL, limitString, mulberry32, normalizeProxy, objectStringify, parseProxy, pascalCase, promiseSilent, promiseTimeout, proxyValue, randomBoolean, randomElement, randomHex, randomInteger, randomString, randomUuid, randomWeighted, retry, safeString, seedHex, shuffleObject, shuffleString, sleep, sleepMs, splitTrim, time, titleCase, waitForProperty };
+export { CONSTANTS, Exception, castString, checkEmpty, coerceObjectIntegers, coerceObjectNumbers, cookiesFromHeader, cookiesFromResponse, cookiesToHeader, findNodeByKey, forever, getResponseError, isInt32, isPositiveNumber, isTransientHttpCode, isValidURL, limitString, mulberry32, normalizeProxy, objectStringify, parseProxy, pascalCase, promiseSilent, promiseTimeout, proxyValue, randomBoolean, randomElement, randomHex, randomInteger, randomString, randomUuid, randomWeighted, retry, safeString, seedHex, shuffleObject, shuffleString, sleep, sleepMs, splitTrim, time, titleCase, waitForProperty };

package/dist/node.cjs

@@ -1,16 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_general = require("./general-C6nIgKnW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+const require_general = require("./general.cjs");
 let fs = require("fs");
-fs = require_general.__toESM(fs, 1);
+fs = require_rolldown_runtime.__toESM(fs, 1);
 let path = require("path");
-path = require_general.__toESM(path, 1);
+path = require_rolldown_runtime.__toESM(path, 1);
 let crypto = require("crypto");
-crypto = require_general.__toESM(crypto, 1);
+crypto = require_rolldown_runtime.__toESM(crypto, 1);
 let os = require("os");
 let child_process = require("child_process");
 let util = require("util");
 let bcryptjs = require("bcryptjs");
-bcryptjs = require_general.__toESM(bcryptjs, 1);
+bcryptjs = require_rolldown_runtime.__toESM(bcryptjs, 1);
 //#region src/node.js
 const execAsync = (0, util.promisify)(child_process.exec);
 function secureRandomBoolean() {
@@ -108,6 +109,10 @@ function writeJsonFileSync(filePath, data) {
 	const jsonData = JSON.stringify(data);
 	return fs.default.writeFileSync(filePath, jsonData, "utf8");
 }
+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 clearDirectory(directoryPath, keepDir = true) {
 	await fs.promises.rm(directoryPath, {
 		recursive: true,
@@ -115,10 +120,6 @@ async function clearDirectory(directoryPath, keepDir = 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();