@e-mc/types
Version:
Type definitions for E-mc.
1,217 lines (1,216 loc) • 42.7 kB
JavaScript
"use strict";
exports.IMPORT_MAP = exports.THRESHOLD = exports.READDIR_SORT = exports.WATCH_EVENT = exports.TRANSFER_TYPE = exports.DB_TRANSACTION = exports.DB_TYPE = exports.FETCH_TYPE = exports.DOWNLOAD_TYPE = exports.ERR_CODE = exports.ASSET_FLAG = exports.FILE_TYPE = exports.STATUS_TYPE = exports.LOG_STATE = exports.LOG_TYPE = void 0;
exports.createAbortError = createAbortError;
exports.hasBit = hasBit;
exports.ignoreFlag = ignoreFlag;
exports.cloneFlag = cloneFlag;
exports.usingFlag = usingFlag;
exports.watchFlag = watchFlag;
exports.modifiedFlag = modifiedFlag;
exports.processFlag = processFlag;
exports.mainFlag = mainFlag;
exports.existsFlag = existsFlag;
exports.getLogCurrent = getLogCurrent;
exports.setLogCurrent = setLogCurrent;
exports.getTempDir = getTempDir;
exports.setTempDir = setTempDir;
exports.isArray = isArray;
exports.isPlainObject = isPlainObject;
exports.isObject = isObject;
exports.isString = isString;
exports.isEmpty = isEmpty;
exports.isFunction = isFunction;
exports.parseTime = parseTime;
exports.parseExpires = parseExpires;
exports.formatTime = formatTime;
exports.convertTime = convertTime;
exports.hasGlob = hasGlob;
exports.escapePattern = escapePattern;
exports.renameExt = renameExt;
exports.formatSize = formatSize;
exports.alignSize = alignSize;
exports.cascadeObject = cascadeObject;
exports.cloneObject = cloneObject;
exports.coerceObject = coerceObject;
exports.asFunction = asFunction;
exports.getEncoding = getEncoding;
exports.encryptUTF8 = encryptUTF8;
exports.decryptUTF8 = decryptUTF8;
exports.randomString = randomString;
exports.validateUUID = validateUUID;
exports.sanitizeCmd = sanitizeCmd;
exports.sanitizeArgs = sanitizeArgs;
exports.errorValue = errorValue;
exports.errorMessage = errorMessage;
exports.purgeMemory = purgeMemory;
exports.incrementUUID = incrementUUID;
exports.hashKey = hashKey;
exports.supported = supported;
exports.importESM = importESM;
const path = require("node:path");
const fs = require("node:fs");
const crypto = require("node:crypto");
const bytes = require("bytes");
const node_os_1 = require("node:os");
const node_url_1 = require("node:url");
const PATTERN_CHARS = {
'&': '\\x26',
'!': '\\x21',
'#': '\\x23',
'%': '\\x25',
',': '\\x2c',
':': '\\x3a',
';': '\\x3b',
'<': '\\x3c',
'=': '\\x3d',
'>': '\\x3e',
'@': '\\x40',
'`': '\\x60',
'~': '\\x7e'
};
const [VER_MAJOR, VER_MINOR, VER_PATCH] = process.version.substring(1).split('.').map(value => +value);
const PLATFORM_WIN32 = process.platform === 'win32';
const REGEXP_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
const REGEXP_FUNCTION = /^(async\s+)?(function(?:\b|\s+)[\w_$]*\s*\(([^)]*)\)\s*\{(.*)\})$/s;
const REGEXP_FUNCTION_ARROW = /^(async\s+)?(\(([^)]*)\)\s*=>\s*(?:\{(.*)\}|(?!\s|{)((?:(?<!return\s+)(?:"[^"\n]*"|'[^'\n]*'|`[^`]*`|[^\n;"'`]))*;)))$/s;
const REGEXP_GLOB = /(?<!\\)(?:(?:[^*]|^)\*{1,2}(?:[^*]|$)|\{[^}]+\}|\[[!^][^\]]+\]|[!?*+@]\([^)]+\))/;
const REGEXP_NATIVE = /^new\s+(Date|RegExp|URL|(?:Weak)?(?:Map|Set))\((.*)\)$/s;
const REGEXP_CLIESCAPE = /[^\w+-.,/:@]/g;
const REGEXP_CLIOPTION = /^(-[^\s=]+|--[^-\s=][^\s=]*)(=)?\s*(.*)$/s;
const ASYNC_FUNCTION = Object.getPrototypeOf(async () => { }).constructor;
const RESERVED_SHELL = [
'if',
'then',
'elif',
'else',
'fi',
'time',
'for',
'in',
'until',
'while',
'do',
'done',
'case',
'esac',
'coproc',
'select',
'function'
];
let CACHE_COERCED = new WeakSet();
let LOG_CURRENT = null;
let SUPPORTED_HASHSINGLE = false;
let SUPPORTED_IMPORTATTRIBUTES = false;
let TEMP_DIR = path.join(process.cwd(), "tmp");
let INCREMENT_COUNT = 65536;
let INCREMENT_PREFIX = '';
function fromObject(value, typedArray, structured, shared) {
if (isObject(value)) {
if (typedArray) {
if (value instanceof Buffer) {
return Buffer.from(value);
}
if (value instanceof Int8Array) {
return Int8Array.from(value);
}
if (value instanceof Uint8Array) {
return Uint8Array.from(value);
}
if (value instanceof Uint8ClampedArray) {
return Uint8ClampedArray.from(value);
}
if (value instanceof Int16Array) {
return Int16Array.from(value);
}
if (value instanceof Uint16Array) {
return Uint16Array.from(value);
}
if (value instanceof Int32Array) {
return Int32Array.from(value);
}
if (value instanceof Uint32Array) {
return Uint32Array.from(value);
}
if (value instanceof Float32Array) {
return Float32Array.from(value);
}
if (value instanceof Float64Array) {
return Float64Array.from(value);
}
if (value instanceof BigInt64Array) {
return BigInt64Array.from(value);
}
if (value instanceof BigUint64Array) {
return BigUint64Array.from(value);
}
}
if (structured) {
try {
return structuredClone(value);
}
catch {
}
}
if (value instanceof Map) {
return new Map(value);
}
if (value instanceof Set) {
return new Set(value);
}
if (value instanceof Date) {
return new Date(value);
}
if (value instanceof RegExp) {
return new RegExp(value);
}
if (value instanceof URL) {
return new URL(value);
}
if (shared === false) {
return;
}
}
return value;
}
function trimQuote(value) {
value = value.trim();
const first = value[0];
const last = value[value.length - 1];
return first === last && (first === '"' || first === "'" || first === "`") ? value.substring(1, value.length - 1) : value;
}
function checkCipherType(value) {
switch (value) {
case 'aes-128-gcm':
case 'aes-192-gcm':
case 'aes-256-gcm':
return value;
}
}
function recurseObject(data, parseString, completed, cache) {
if (isPlainObject(data) && !completed.has(data) && (!cache || !CACHE_COERCED.has(data))) {
for (const attr in data) {
const value = data[attr];
switch (typeof value) {
case 'string': {
const result = parseString(value);
if (result !== null) {
data[attr] = result;
}
break;
}
case 'object':
if (value === null || completed.has(value)) {
continue;
}
completed.add(value);
if (Array.isArray(value)) {
(function iterate(items) {
for (let i = 0, length = items.length; i < length; ++i) {
const item = items[i];
switch (typeof item) {
case 'string': {
const result = parseString(item);
if (result !== null) {
items[i] = result;
}
break;
}
case 'object':
if (Array.isArray(item)) {
iterate(item);
}
else if (item) {
recurseObject(item, parseString, completed);
}
break;
}
}
})(value);
}
else {
recurseObject(value, parseString, completed);
}
break;
}
}
if (cache) {
CACHE_COERCED.add(data);
}
completed.add(data);
}
return data;
}
function mergedArray(target, attr, data, type) {
const prop = target[attr];
if (type && Array.isArray(prop) && Array.isArray(data)) {
let arg1, arg2;
if (Array.isArray(type)) {
[type, arg1, arg2] = type;
}
switch (type) {
case 'concat':
target[attr] = prop.concat(data);
break;
case 'concat-pre':
target[attr] = data.concat(prop);
break;
case 'push':
case 'unshift':
case 'includes':
for (let i = 0, length = data.length; i < length; ++i) {
if (type !== 'includes' || !prop.includes(data[i])) {
prop[type](data[i]);
}
}
break;
case 'flat':
target[attr] = data.flat(arg1);
case 'join':
target[attr] = data.join(arg1);
break;
case 'slice':
target[attr] = data.slice(arg1, arg2);
break;
case 'reverse':
target[attr] = data.slice(0).reverse();
break;
default:
return false;
}
return true;
}
return false;
}
function getProperties(obj, inherited, nonenumerable, symbol) {
let attrs;
if (inherited === false) {
attrs = nonenumerable ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
}
else {
attrs = [];
for (const attr in obj) {
attrs.push(attr);
}
if (nonenumerable) {
attrs = Array.from(new Set(attrs.concat(Object.getOwnPropertyNames(obj))));
}
}
return symbol ? attrs.concat(Object.getOwnPropertySymbols(obj)) : attrs;
}
function parseStringDefault(value) {
if (value.length <= 8) {
return null;
}
switch (value.substring(0, 3)) {
case 'new': {
const match = REGEXP_NATIVE.exec(value.trimEnd());
if (match) {
try {
const out = eval(match[0]);
if (isObject(out)) {
return out;
}
}
catch {
}
try {
let text = match[2].trim();
switch (match[1]) {
case 'Date':
return (text = trimQuote(text)) ? new Date(text) : new Date();
case 'URL':
case 'RegExp': {
const pattern = /^("[^"]+"|'[^']+'|[^\s,]+)(?:\s*,\s*("[^"]+"|'[^']+'|\S+))?$/.exec(text);
if (pattern) {
return new (match[1] === 'URL' ? URL : RegExp)(trimQuote(pattern[1]), pattern[2] ? trimQuote(pattern[2]) : '');
}
throw errorValue("Invalid parameters", text);
}
default: {
let values = [];
if (text.startsWith('[') && text.endsWith(']')) {
values = JSON.parse(text);
}
else if (text) {
throw errorValue("Invalid parameters", text);
}
switch (match[1]) {
case 'Map':
return new Map(values);
case 'WeakMap':
return new WeakMap(values);
case 'Set':
return new Set(values);
case 'WeakSet':
return new WeakSet(values);
}
}
}
}
catch {
return undefined;
}
}
break;
}
case 'asy':
case 'fun':
return asFunction(value);
case 'Num':
switch (value) {
case 'Number.EPSILON':
return Number.EPSILON;
case 'Number.MAX_SAFE_INTEGER':
return Number.MAX_SAFE_INTEGER;
case 'Number.MAX_VALUE':
return Number.MAX_VALUE;
case 'Number.MIN_SAFE_INTEGER':
return Number.MIN_SAFE_INTEGER;
case 'Number.MIN_VALUE':
return Number.MIN_VALUE;
case 'Number.NaN':
return Number.NaN;
case 'Number.NEGATIVE_INFINITY':
return Number.NEGATIVE_INFINITY;
case 'Number.POSITIVE_INFINITY':
return Number.POSITIVE_INFINITY;
}
break;
}
return null;
}
function checkFlags(value, flags) {
if (isObject(value)) {
value = value.flags;
}
return typeof value === 'number' && (value & flags) === flags;
}
const padStart = (value, char) => value > 9 ? value.toString() : char + value;
const wrapQuote = (value) => '"' + value.replaceAll('"', '\\"') + '"';
var LOG_TYPE;
(function (LOG_TYPE) {
LOG_TYPE[LOG_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
LOG_TYPE[LOG_TYPE["SYSTEM"] = 1] = "SYSTEM";
LOG_TYPE[LOG_TYPE["NODE"] = 2] = "NODE";
LOG_TYPE[LOG_TYPE["PROCESS"] = 4] = "PROCESS";
LOG_TYPE[LOG_TYPE["COMPRESS"] = 8] = "COMPRESS";
LOG_TYPE[LOG_TYPE["WATCH"] = 16] = "WATCH";
LOG_TYPE[LOG_TYPE["FILE"] = 32] = "FILE";
LOG_TYPE[LOG_TYPE["CLOUD"] = 64] = "CLOUD";
LOG_TYPE[LOG_TYPE["TIME_ELAPSED"] = 128] = "TIME_ELAPSED";
LOG_TYPE[LOG_TYPE["TIME_PROCESS"] = 256] = "TIME_PROCESS";
LOG_TYPE[LOG_TYPE["FAIL"] = 512] = "FAIL";
LOG_TYPE[LOG_TYPE["HTTP"] = 1024] = "HTTP";
LOG_TYPE[LOG_TYPE["IMAGE"] = 2048] = "IMAGE";
LOG_TYPE[LOG_TYPE["EXEC"] = 4096] = "EXEC";
LOG_TYPE[LOG_TYPE["PERMISSION"] = 8192] = "PERMISSION";
LOG_TYPE[LOG_TYPE["TIMEOUT"] = 16384] = "TIMEOUT";
LOG_TYPE[LOG_TYPE["STDOUT"] = 32768] = "STDOUT";
LOG_TYPE[LOG_TYPE["DB"] = 65536] = "DB";
})(LOG_TYPE || (exports.LOG_TYPE = LOG_TYPE = {}));
var LOG_STATE;
(function (LOG_STATE) {
LOG_STATE[LOG_STATE["STDIN"] = 0] = "STDIN";
LOG_STATE[LOG_STATE["STDOUT"] = 1] = "STDOUT";
LOG_STATE[LOG_STATE["STDERR"] = 2] = "STDERR";
})(LOG_STATE || (exports.LOG_STATE = LOG_STATE = {}));
var STATUS_TYPE;
(function (STATUS_TYPE) {
STATUS_TYPE[STATUS_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
STATUS_TYPE[STATUS_TYPE["FATAL"] = 1] = "FATAL";
STATUS_TYPE[STATUS_TYPE["ERROR"] = 2] = "ERROR";
STATUS_TYPE[STATUS_TYPE["WARN"] = 3] = "WARN";
STATUS_TYPE[STATUS_TYPE["INFO"] = 4] = "INFO";
STATUS_TYPE[STATUS_TYPE["DEBUG"] = 5] = "DEBUG";
STATUS_TYPE[STATUS_TYPE["ASSERT"] = 6] = "ASSERT";
STATUS_TYPE[STATUS_TYPE["TRACE"] = 7] = "TRACE";
})(STATUS_TYPE || (exports.STATUS_TYPE = STATUS_TYPE = {}));
var FILE_TYPE;
(function (FILE_TYPE) {
FILE_TYPE[FILE_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
FILE_TYPE[FILE_TYPE["ASSET"] = 1] = "ASSET";
FILE_TYPE[FILE_TYPE["TRANSFORM"] = 2] = "TRANSFORM";
FILE_TYPE[FILE_TYPE["COMPRESSED"] = 4] = "COMPRESSED";
FILE_TYPE[FILE_TYPE["SOURCEMAP"] = 8] = "SOURCEMAP";
FILE_TYPE[FILE_TYPE["TORRENT"] = 16] = "TORRENT";
})(FILE_TYPE || (exports.FILE_TYPE = FILE_TYPE = {}));
var ASSET_FLAG;
(function (ASSET_FLAG) {
ASSET_FLAG[ASSET_FLAG["NONE"] = 0] = "NONE";
ASSET_FLAG[ASSET_FLAG["IGNORE"] = 1] = "IGNORE";
ASSET_FLAG[ASSET_FLAG["CLONE"] = 2] = "CLONE";
ASSET_FLAG[ASSET_FLAG["USING"] = 4] = "USING";
ASSET_FLAG[ASSET_FLAG["WATCH"] = 8] = "WATCH";
ASSET_FLAG[ASSET_FLAG["MODIFIED"] = 16] = "MODIFIED";
ASSET_FLAG[ASSET_FLAG["PROCESS"] = 32] = "PROCESS";
ASSET_FLAG[ASSET_FLAG["MAIN"] = 64] = "MAIN";
ASSET_FLAG[ASSET_FLAG["EXISTS"] = 128] = "EXISTS";
})(ASSET_FLAG || (exports.ASSET_FLAG = ASSET_FLAG = {}));
var ERR_CODE;
(function (ERR_CODE) {
ERR_CODE["MODULE_NOT_FOUND"] = "MODULE_NOT_FOUND";
ERR_CODE["ERR_MODULE_NOT_FOUND"] = "ERR_MODULE_NOT_FOUND";
})(ERR_CODE || (exports.ERR_CODE = ERR_CODE = {}));
var DOWNLOAD_TYPE;
(function (DOWNLOAD_TYPE) {
DOWNLOAD_TYPE[DOWNLOAD_TYPE["HTTP"] = 0] = "HTTP";
DOWNLOAD_TYPE[DOWNLOAD_TYPE["DISK"] = 1] = "DISK";
DOWNLOAD_TYPE[DOWNLOAD_TYPE["CACHE"] = 2] = "CACHE";
})(DOWNLOAD_TYPE || (exports.DOWNLOAD_TYPE = DOWNLOAD_TYPE = {}));
var FETCH_TYPE;
(function (FETCH_TYPE) {
FETCH_TYPE[FETCH_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
FETCH_TYPE[FETCH_TYPE["HTTP"] = 1] = "HTTP";
FETCH_TYPE[FETCH_TYPE["UNIX_SOCKET"] = 2] = "UNIX_SOCKET";
FETCH_TYPE[FETCH_TYPE["FTP"] = 3] = "FTP";
FETCH_TYPE[FETCH_TYPE["TORRENT"] = 4] = "TORRENT";
})(FETCH_TYPE || (exports.FETCH_TYPE = FETCH_TYPE = {}));
var DB_TYPE;
(function (DB_TYPE) {
DB_TYPE[DB_TYPE["SQL"] = 1] = "SQL";
DB_TYPE[DB_TYPE["NOSQL"] = 2] = "NOSQL";
DB_TYPE[DB_TYPE["DOCUMENT"] = 4] = "DOCUMENT";
DB_TYPE[DB_TYPE["KEYVALUE"] = 8] = "KEYVALUE";
})(DB_TYPE || (exports.DB_TYPE = DB_TYPE = {}));
var DB_TRANSACTION;
(function (DB_TRANSACTION) {
DB_TRANSACTION[DB_TRANSACTION["ACTIVE"] = 1] = "ACTIVE";
DB_TRANSACTION[DB_TRANSACTION["PARTIAL"] = 2] = "PARTIAL";
DB_TRANSACTION[DB_TRANSACTION["COMMIT"] = 4] = "COMMIT";
DB_TRANSACTION[DB_TRANSACTION["TERMINATE"] = 8] = "TERMINATE";
DB_TRANSACTION[DB_TRANSACTION["ABORT"] = 16] = "ABORT";
DB_TRANSACTION[DB_TRANSACTION["FAIL"] = 32] = "FAIL";
DB_TRANSACTION[DB_TRANSACTION["AUTH"] = 64] = "AUTH";
DB_TRANSACTION[DB_TRANSACTION["CACHE"] = 128] = "CACHE";
})(DB_TRANSACTION || (exports.DB_TRANSACTION = DB_TRANSACTION = {}));
var TRANSFER_TYPE;
(function (TRANSFER_TYPE) {
TRANSFER_TYPE[TRANSFER_TYPE["DISK"] = 1] = "DISK";
TRANSFER_TYPE[TRANSFER_TYPE["STREAM"] = 2] = "STREAM";
TRANSFER_TYPE[TRANSFER_TYPE["CHUNK"] = 4] = "CHUNK";
})(TRANSFER_TYPE || (exports.TRANSFER_TYPE = TRANSFER_TYPE = {}));
var WATCH_EVENT;
(function (WATCH_EVENT) {
WATCH_EVENT["MODIFIED"] = "modified";
WATCH_EVENT["BROADCAST"] = "broadcast";
WATCH_EVENT["CLOSE"] = "close";
WATCH_EVENT["ERROR"] = "error";
})(WATCH_EVENT || (exports.WATCH_EVENT = WATCH_EVENT = {}));
var READDIR_SORT;
(function (READDIR_SORT) {
READDIR_SORT[READDIR_SORT["FILE"] = 0] = "FILE";
READDIR_SORT[READDIR_SORT["DIRECTORY"] = 1] = "DIRECTORY";
READDIR_SORT[READDIR_SORT["DESCENDING"] = 2] = "DESCENDING";
})(READDIR_SORT || (exports.READDIR_SORT = READDIR_SORT = {}));
var THRESHOLD;
(function (THRESHOLD) {
THRESHOLD[THRESHOLD["FILEMANAGER_INTERVAL"] = 100] = "FILEMANAGER_INTERVAL";
THRESHOLD[THRESHOLD["WATCH_INTERVAL"] = 500] = "WATCH_INTERVAL";
THRESHOLD[THRESHOLD["WATCH_CHANGE"] = 100] = "WATCH_CHANGE";
THRESHOLD[THRESHOLD["WATCH_RECURSIVE_CHANGE"] = 500] = "WATCH_RECURSIVE_CHANGE";
THRESHOLD[THRESHOLD["LOGGER_METER_INCREMENT"] = 250] = "LOGGER_METER_INCREMENT";
})(THRESHOLD || (exports.THRESHOLD = THRESHOLD = {}));
exports.IMPORT_MAP = {
"atlas": "@pi-r/atlas",
"aws": "@pi-r/aws",
"aws-v3": "@pi-r/aws-v3",
"az": "@pi-r/azure",
"azure": "@pi-r/azure",
"gcloud": "@pi-r/gcp",
"gcp": "@pi-r/gcp",
"oci": "@pi-r/oci",
"tinify": "@pi-r/tinify",
"mariadb": "@pi-r/mariadb",
"mongodb": "@pi-r/mongodb",
"mssql": "@pi-r/mssql",
"mysql": "@pi-r/mysql",
"oracle": "@pi-r/oracle",
"postgres": "@pi-r/postgres",
"redis": "@pi-r/redis",
"@babel/core": "@pi-r/babel",
"eslint": "@pi-r/eslint",
"html-validate": "@pi-r/html-validate",
"postcss": "@pi-r/postcss",
"posthtml": "@pi-r/posthtml",
"prettier": "@pi-r/prettier",
"rollup": "@pi-r/rollup",
"sass": "@pi-r/sass",
"stylelint": "@pi-r/stylelint",
"terser": "@pi-r/terser",
"ibm": "@pi-r2/ibm",
"minio": "@pi-r2/minio",
"imagemin": "@pi-r2/imagemin",
"clean-css": "@pi-r2/clean-css",
"csso": "@pi-r2/csso",
"html-minifier": "@pi-r2/html-minifier",
"html-minifier-terser": "@pi-r2/html-minifier-terser",
"svgo": "@pi-r2/svgo",
"uglify-js": "@pi-r2/uglify-js"
};
function createAbortError(reject) {
const result = new DOMException("This operation was aborted", 'AbortError');
return (reject ? Promise.reject(result) : result);
}
function hasBit(value, flags) {
return typeof value === 'number' && (value & flags) > 0;
}
function ignoreFlag(value) {
return checkFlags(value, 1);
}
function cloneFlag(value) {
return checkFlags(value, 2);
}
function usingFlag(value) {
return checkFlags(value, 4);
}
function watchFlag(value) {
return checkFlags(value, 8);
}
function modifiedFlag(value) {
return checkFlags(value, 16);
}
function processFlag(value) {
return checkFlags(value, 32);
}
function mainFlag(value) {
return checkFlags(value, 64);
}
function existsFlag(value) {
return checkFlags(value, 128);
}
function getLogCurrent() {
return LOG_CURRENT;
}
function setLogCurrent(value) {
LOG_CURRENT = value;
}
function getTempDir(...values) {
if (values.length === 0) {
return TEMP_DIR;
}
if (typeof values[0] === 'boolean' && values.shift()) {
return fs.mkdtempSync(isString(values[0]) ? path.join((0, node_os_1.tmpdir)(), values[0]) : (0, node_os_1.tmpdir)() + path.sep);
}
return path.join(TEMP_DIR, ...values);
}
function setTempDir(value) {
try {
if (path.isAbsolute(value = path.normalize(value)) && fs.statSync(value).isDirectory()) {
TEMP_DIR = value;
return true;
}
}
catch {
}
return false;
}
function isArray(value) {
return Array.isArray(value) && value.length > 0;
}
function isPlainObject(value) {
return typeof value === 'object' && value !== null && (value.constructor === Object || Object.getPrototypeOf(value) === null);
}
function isObject(value) {
return typeof value === 'object' && value !== null;
}
function isString(value) {
return typeof value === 'string' && value.length > 0;
}
function isEmpty(value) {
return value === undefined || value === null || value === '' || Array.isArray(value) && value.length === 0;
}
function isFunction(value, cjs = false) {
return typeof value === 'function' && (!cjs || Object.hasOwn(value, "__cjs__"));
}
function parseTime(value, start = 0) {
const seconds = +value;
if (isNaN(seconds) && isString(value)) {
let result = 0;
for (const match of value.toLowerCase().matchAll(/\b([\d.]+)\s*(y|M|w|d|h|ms?|s)\b/g)) {
const n = +match[1];
if (isNaN(n)) {
continue;
}
switch (match[2]) {
case 'y':
result += n * 31449600000;
break;
case 'M':
result += n * 2592000000;
break;
case 'w':
result += n * 604800000;
break;
case 'd':
result += n * 86400000;
break;
case 'h':
result += n * 3600000;
break;
case 'm':
result += n * 60000;
break;
case 's':
result += n * 1000;
break;
case 'ms':
result += Math.ceil(n);
break;
}
}
if (result > 0) {
return Math.ceil(result) + start;
}
}
else if (seconds > 0) {
return Math.ceil(seconds * 1000) + start;
}
return 0;
}
function parseExpires(value, start = 0) {
if (+value < 0 || value === 'never') {
return Infinity;
}
return parseTime(value, start);
}
function formatTime(value, elapsed, char = ' ') {
if (elapsed === true) {
value = Date.now() - value;
}
else if (isString(elapsed)) {
char = elapsed;
}
if (char === ':') {
let result = '';
if (value >= 3600000) {
const h = Math.floor(value / 3600000);
value -= h * 3600000;
result = h + ':';
}
if (value >= 60000) {
const m = Math.floor(value / 60000);
value -= m * 60000;
result += padStart(m, result ? '0' : ' ') + ':';
}
else {
result += '0:';
}
if (value >= 1000) {
const s = Math.floor(value / 1000);
result += padStart(s, '0');
}
else {
result += '00';
}
return result;
}
const result = [];
if (value < 1000) {
return value + 'ms';
}
if (value >= 3600000) {
const h = Math.floor(value / 3600000);
value -= h * 3600000;
result.push(h + 'h');
}
if (value >= 60000) {
const m = Math.floor(value / 60000);
value -= m * 60000;
result.push(m + 'm');
}
if (value > 0) {
result.push(value < 100 ? value + 'ms' : (value / 1000).toPrecision(value <= 9950 ? 2 : 3).replace(/\.?0+$/, '') + 's');
}
return result.join(char);
}
function convertTime(value, format) {
let result = 0;
if (Array.isArray(value)) {
result = Math.ceil((value[0] * 1000000000 + value[1]) / 1000000);
}
else if (typeof value === 'bigint') {
result = Number(value / BigInt(1000000));
}
else {
return parseTime(value);
}
return format ? formatTime(result) : result;
}
function hasGlob(value) {
return REGEXP_GLOB.test(value);
}
function escapePattern(value, symbols) {
switch (typeof value) {
case 'string': {
let result = '', j = 0;
for (let i = 0, length = value.length, ch; i < length; ++i) {
switch (ch = value[i]) {
case '-':
ch = '\\x2d';
break;
case '.':
case '+':
case '*':
case '?':
case '|':
case '\\':
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '^':
case '$':
ch = '\\' + ch;
break;
default:
if (!(symbols && (ch = PATTERN_CHARS[ch]))) {
continue;
}
break;
}
result += value.substring(j, i) + ch;
j = i + 1;
}
return j > 0 ? result + value.substring(j) : value;
}
case 'number':
return value.toString();
default:
return '';
}
}
function renameExt(value, ext, when) {
if (!ext.startsWith('.')) {
ext = '.' + ext;
}
if (when && !when.startsWith('.')) {
when = '.' + when;
}
const index = value.lastIndexOf('.');
if (index !== -1) {
const current = value.substring(index);
if (current === ext) {
return value;
}
if (!when || current === when) {
return value.substring(0, index) + ext;
}
}
return value + ext;
}
function formatSize(value, options) {
let result;
if (typeof value === 'number') {
result = bytes(value, options) || ('0' + (options?.unitSeparator || '') + 'B');
}
else {
result = bytes(value) || 0;
}
return result;
}
function alignSize(value, kb = 0, factor = 0) {
if (value === undefined) {
return NaN;
}
let result = 0;
switch (typeof value) {
case 'number':
if (value < 0) {
return NaN;
}
result = Math.ceil(factor > 0 ? value * Math.pow(1024, factor) : value);
break;
case 'string':
result = formatSize(value);
if (result < 0) {
return NaN;
}
break;
default:
return NaN;
}
if (kb > 0) {
kb = Math.ceil(kb) * 1024;
return Math.ceil(Math.max(result, 1) / kb) * kb;
}
return result;
}
function cascadeObject(data, query, fallback) {
if (isObject(data)) {
const names = query.trim().split(/(?<!\\)\./).map(item => item.includes('.') ? item.replace(/\\(?=\.)/g, '') : item);
for (let i = 0, length = names.length, match, current = data; i < length; ++i) {
if (!(match = /^(.+?)(?:\[(.+)\])?$/.exec(names[i]))) {
break;
}
let index = match[2];
if (index !== undefined && isNaN(index = +index)) {
index = trimQuote(match[2]);
}
let target = current[trimQuote(match[1])];
if (target === undefined) {
break;
}
if (i === length - 1) {
return (index !== undefined ? target[index] : target);
}
if (index !== undefined && !isObject(target = target[index])) {
break;
}
current = target;
}
}
return fallback;
}
function cloneObject(data, options) {
let freezeDepth = -1, mergeDepth = Infinity, target, deep, deepIgnore, mergeArray, typedArray, structured, shared, inherited, nonenumerable, symbol, preserve;
if (options === true) {
deep = true;
}
else if (options instanceof WeakSet) {
deep = true;
structured = true;
deepIgnore = options;
}
else if (options) {
({ target, deep, deepIgnore, mergeArray, typedArray, structured, inherited, nonenumerable, symbol, preserve } = options);
if (typeof options.freezeDepth === 'number') {
freezeDepth = options.freezeDepth - 1;
}
else if (options.freezeDepth) {
freezeDepth = Infinity;
}
if (options.mergeDepth !== undefined) {
mergeDepth = options.mergeDepth - 1;
}
}
let nested;
if (deep || freezeDepth > 0) {
deepIgnore ||= new WeakSet();
nested = { deep, deepIgnore, freezeDepth, mergeArray, mergeDepth, typedArray, structured, preserve };
}
if (Array.isArray(data)) {
deepIgnore?.add(data);
const length = data.length;
if (Array.isArray(target)) {
if (mergeArray && mergeDepth >= 0 && !(mergeArray === 'join' || Array.isArray(mergeArray) && mergeArray[0] === 'join')) {
const out = { target };
if (mergedArray(out, 'target', data, mergeArray)) {
return out.target;
}
}
target.length = 0;
}
else {
target = new Array(length);
}
for (let i = 0; i < length; ++i) {
const value = data[i];
if (deepIgnore) {
target[i] = (Array.isArray(value) || isPlainObject(value)) && !deepIgnore.has(value) ? cloneObject(value, nested) : fromObject(value, typedArray, structured, shared);
}
else {
target[i] = Array.isArray(value) ? value.slice(0) : value;
}
}
}
else if (isObject(data)) {
deepIgnore?.add(data);
if (!isObject(target)) {
target = {};
}
for (const attr of getProperties(data, inherited, nonenumerable, symbol)) {
const value = data[attr];
let merge;
if (deepIgnore) {
merge = (Array.isArray(value) || isPlainObject(value)) && !deepIgnore.has(value) ? cloneObject(value, nested) : fromObject(value, typedArray, structured, shared);
}
else {
merge = Array.isArray(value) ? value.slice(0) : value;
}
const prop = target[attr];
if (preserve && isPlainObject(prop) && isPlainObject(merge)) {
(function recurse(current, next, depth) {
for (const item of getProperties(next, inherited, nonenumerable, symbol)) {
const b = next[item];
if (item in current) {
const a = current[item];
if (isPlainObject(a) && isPlainObject(b)) {
recurse(a, b, depth - 1);
}
}
else if (!(mergeArray && mergeDepth >= 0 && mergedArray(current, item, b, mergeArray))) {
current[item] = b;
}
}
if (depth >= 0) {
Object.freeze(current);
}
})(prop, merge, freezeDepth - 1);
}
else if (!(mergeArray && mergeDepth >= 0 && mergedArray(target, attr, merge, mergeArray))) {
target[attr] = merge;
}
}
}
else {
return deep ? fromObject(data, typedArray, structured, false) : data;
}
if (freezeDepth >= 0) {
Object.freeze(target);
}
return target;
}
function coerceObject(data, parseString, cache) {
if (typeof parseString === 'boolean') {
cache = parseString;
parseString = undefined;
}
else if (parseString && typeof parseString !== 'function') {
return data;
}
parseString ||= parseStringDefault;
if (Array.isArray(data)) {
for (let i = 0, length = data.length; i < length; ++i) {
data[i] = recurseObject(data[i], parseString, new WeakSet(), cache);
}
return data;
}
return recurseObject(data, parseString, new WeakSet(), cache);
}
function asFunction(value, sync = true) {
if (typeof value === 'function') {
return value;
}
let match;
if (isString(value) && (match = REGEXP_FUNCTION.exec(value = value.trim()) || REGEXP_FUNCTION_ARROW.exec(value))) {
if (!sync || match[1]) {
const args = match[3].trim().split(/\s*,\s*/);
args.push(match[4] || (match[5] &&= 'return ' + match[5]));
return new ASYNC_FUNCTION(...args);
}
try {
const result = (0, eval)(`(${match[2]})`);
if (typeof result === 'function') {
return result;
}
}
catch {
}
}
return null;
}
function getEncoding(value, fallback) {
if (typeof value === 'string') {
switch (value = value.trim().toLowerCase()) {
case 'utf8':
case 'utf-8':
return 'utf8';
case 'utf16le':
case 'utf-16le':
case 'utf16':
case 'utf-16':
return 'utf16le';
}
if (Buffer.isEncoding(value)) {
return value;
}
}
return fallback || 'utf8';
}
function encryptUTF8(algorithm, key, iv, data, encoding = 'hex') {
if (checkCipherType(algorithm) && isString(data)) {
let result;
try {
const gcm = crypto.createCipheriv(algorithm, crypto.scryptSync(key, iv, 32), iv);
result = gcm.update(data, 'utf8', encoding);
result += gcm.final(encoding);
}
catch {
}
return result;
}
}
function decryptUTF8(algorithm, key, iv, data, encoding = 'hex') {
if (checkCipherType(algorithm) && isString(data)) {
let result;
try {
const gcm = crypto.createDecipheriv(algorithm, crypto.scryptSync(key, iv, 32), iv);
result = gcm.update(data, encoding, 'utf8');
result += gcm.final('utf8');
}
catch {
}
return result;
}
}
function randomString(format, dictionary) {
if (format !== '8-4-4-4-12' || dictionary) {
const match = format.match(/(\d+|[^\d]+)/g);
if (match) {
dictionary ||= '0123456789abcdef';
const result = format.match(/(\d+|[^\d[]+|\[[^\]]+\]|\[)/g)?.reduce((a, b) => {
let length = 0, available;
if (b.startsWith('[') && b.endsWith(']')) {
length = 1;
available = b.substring(1, b.length - 1);
}
else {
if (isNaN(length = +b)) {
return a + b;
}
available = dictionary;
}
const upperBound = available.length;
if (length > 1 && length <= 65536) {
const items = crypto.getRandomValues(new Uint32Array(length));
for (let i = 0; i < length; i++) {
a += available[items[i] % upperBound];
}
}
else {
for (let i = 0; i < length; ++i) {
a += available[Math.floor(Math.random() * upperBound)];
}
}
return a;
}, '');
if (result) {
return result;
}
}
}
return crypto.randomUUID();
}
function validateUUID(value) {
return typeof value === 'string' && value.length === 36 && REGEXP_UUID.test(value);
}
function sanitizeCmd(value, ...args) {
if (value.includes(' ')) {
value = PLATFORM_WIN32 ? wrapQuote(value) : value.replaceAll(' ', '\\ ');
}
if (args.length === 0) {
return value;
}
return [value].concat(args.flat().filter(arg => isString(arg))).join(' ');
}
function sanitizeArgs(values, doubleQuote) {
const result = typeof values === 'string' ? [values] : values;
for (let i = 0; i < result.length; ++i) {
let value = result[i].trim(), leading = '';
if (value !== '--') {
const opt = REGEXP_CLIOPTION.exec(value);
if (opt) {
if (!opt[2] && !opt[3]) {
result[i] = opt[1];
continue;
}
leading = opt[1] + (opt[2] || ' ');
value = opt[3];
}
if (value) {
const quoted = /^(["'])(.*)\1$/s.exec(value);
if (PLATFORM_WIN32) {
if (quoted) {
if (quoted[1] === '"') {
result[i] = leading + value;
continue;
}
value = quoted[2];
}
if (value.includes(' ')) {
value = wrapQuote(value);
}
}
else if (!quoted) {
if (REGEXP_CLIESCAPE.test(value)) {
value = doubleQuote ? `"${value.replace(/(?<!\\)"/g, '\\"')}"` : `'${value.replaceAll("'", "'\\''")}'`;
}
else if (RESERVED_SHELL.includes(value)) {
value = `'${value}'`;
}
}
}
else if (opt) {
leading = leading.trim();
if (!PLATFORM_WIN32 && leading.length > 2 && leading[1] !== '-') {
leading = leading.replace(REGEXP_CLIESCAPE, capture => '\\' + capture);
}
}
}
result[i] = leading + value;
}
return (typeof values === 'string' ? result[0] : result);
}
function errorValue(value, hint) {
return new Error(value + (hint ? ` (${hint})` : ''));
}
function errorMessage(title, value, hint) {
return new Error((isString(title) || typeof title === 'number' ? title + ': ' : '') + value + (hint ? ` (${hint})` : ''));
}
function purgeMemory(percent) {
CACHE_COERCED = new WeakSet();
INCREMENT_COUNT = 65536;
LOG_CURRENT = null;
}
function incrementUUID(restart) {
if (restart || INCREMENT_COUNT === 65536) {
INCREMENT_COUNT = 0;
INCREMENT_PREFIX = crypto.randomUUID().substring(0, 33);
}
return INCREMENT_PREFIX + (INCREMENT_COUNT++).toString(16).padStart(4, '0');
}
function hashKey(data, algorithm = 'md5', encoding = 'base64') {
try {
return SUPPORTED_HASHSINGLE ? crypto.hash(algorithm, data, encoding) : crypto.createHash(algorithm).update(data).digest(encoding);
}
catch {
return crypto.randomUUID();
}
}
function supported(major, minor = 0, patch = 0, lts = false) {
if (VER_MAJOR < major) {
return false;
}
if (typeof patch === 'boolean') {
lts = patch;
patch = 0;
}
if (VER_MAJOR === major) {
if (VER_MINOR < minor) {
return false;
}
if (VER_MINOR === minor) {
return VER_PATCH >= patch;
}
return true;
}
return !lts;
}
async function importESM(name, isDefault, fromPath) {
let options;
if (name instanceof URL) {
name = (0, node_url_1.fileURLToPath)(name);
}
else if (fromPath && path.isAbsolute(name)) {
name = (0, node_url_1.pathToFileURL)(name).toString();
}
if (isObject(isDefault)) {
options = isDefault;
if (!SUPPORTED_IMPORTATTRIBUTES && options.with?.type === 'json') {
return JSON.parse(fs.readFileSync(name, 'utf8'));
}
isDefault = true;
}
const result = import(name, options);
if (isDefault) {
const out = await result;
if (isObject(out) && 'default' in out) {
return out.default;
}
}
return result;
}
SUPPORTED_HASHSINGLE = supported(20, 12, true) || supported(21, 7);
SUPPORTED_IMPORTATTRIBUTES = supported(18, 20, 5, true) || supported(20, 18, 3, true) || supported(22, 12, true) || supported(23, 1);