melperjs 17.0.0 → 17.1.0

package/dist/general.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_general = require("./general-CAhFOkv8.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;

package/dist/general.mjs

@@ -0,0 +1,370 @@
+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";
+//#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 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);
+	}
+	return object;
+}
+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 xss(string || "", {
+		whiteList: {},
+		stripIgnoreTag: true,
+		stripIgnoreTagBody: [
+			"script",
+			"style",
+			"iframe",
+			"object",
+			"embed",
+			"form"
+		],
+		css: false
+	});
+}
+function shuffleString(string) {
+	return 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 cookiesFromResponse(response, decodeValues = false) {
+	const obj = {};
+	const cookies = setCookieParser.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
+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 };

package/dist/node.cjs

@@ -0,0 +1,170 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_general = require("./general-CAhFOkv8.cjs");
+let fs = require("fs");
+fs = require_general.__toESM(fs, 1);
+let path = require("path");
+path = require_general.__toESM(path, 1);
+let crypto = require("crypto");
+crypto = require_general.__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);
+//#region src/node.js
+const execAsync = (0, util.promisify)(child_process.exec);
+function secureRandomBoolean() {
+	return secureRandomInteger(2) === 1;
+}
+function secureRandomString(length, useNumbers = true, useUppercase = false) {
+	let characters = require_general.CONSTANTS.LOWER_CASE;
+	if (useUppercase) characters += require_general.CONSTANTS.UPPER_CASE;
+	if (useNumbers) characters += require_general.CONSTANTS.NUMBERS;
+	let result = "";
+	for (let i = 0; i < length; i++) result += characters[secureRandomInteger(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 = void 0) {
+	return crypto.default.randomInt(min, max);
+}
+function secureRandomUuid(useDashes = true) {
+	const uuid = crypto.default.randomUUID();
+	return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+function secureRandomWeighted(object) {
+	if (require_general.checkEmpty(object)) return void 0;
+	const elements = Object.keys(object);
+	const weights = Object.values(object);
+	const randomNum = secureRandomInteger(0, weights.reduce((sum, weight) => sum + weight, 0));
+	let weightSum = 0;
+	for (let i = 0; i < elements.length; i++) {
+		weightSum += weights[i];
+		if (randomNum < weightSum) return elements[i];
+	}
+}
+function secureRandomElement(object) {
+	if (require_general.checkEmpty(object)) return void 0;
+	const values = Array.isArray(object) ? object : Object.values(object);
+	if (values.length === 0) return void 0;
+	return values[secureRandomInteger(0, values.length)];
+}
+function uuidFromSeed(seed, useDashes = true) {
+	const hash = crypto.default.createHash("md5").update(seed).digest();
+	hash[6] = hash[6] & 15 | 48;
+	hash[8] = hash[8] & 63 | 128;
+	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);
+}
+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 = (/* @__PURE__ */ new Date(timestamp * 1e3)).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";
+	}
+}
+//#endregion
+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.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;