@e-mc/types 0.8.13 → 0.8.14

package/index.js

@@ -0,0 +1,966 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUUID = exports.randomString = exports.decryptUTF8 = exports.encryptUTF8 = exports.getEncoding = exports.asFunction = exports.coerceObject = exports.cloneObject = exports.cascadeObject = exports.alignSize = exports.formatSize = exports.renameExt = exports.escapePattern = exports.hasGlob = exports.convertTime = exports.formatTime = exports.parseExpires = exports.parseTime = exports.isEmpty = exports.isString = exports.isObject = exports.isPlainObject = exports.isArray = exports.setTempDir = exports.getTempDir = exports.setLogCurrent = exports.getLogCurrent = exports.existsFlag = exports.mainFlag = exports.processFlag = exports.modifiedFlag = exports.watchFlag = exports.usingFlag = exports.cloneFlag = exports.ignoreFlag = exports.hasBit = exports.createAbortError = exports.IMPORT_MAP = exports.THRESHOLD = exports.READDIR_SORT = exports.WATCH_EVENT = 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_TYPE = void 0;
+exports.generateUUID = exports.incrementUUID = exports.purgeMemory = exports.errorMessage = exports.errorValue = void 0;
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const bytes = require("bytes");
+class AbortError extends Error {
+    constructor() {
+        super("The operation was aborted");
+        this.code = 'ABORT_ERR';
+        this.name = 'AbortError';
+    }
+}
+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\s]*)\})$/;
+const REGEXP_FUNCTION_ARROW = /^(async\s+)?(\s*\(([^)]*)\)\s*=>\s*(?:\{([\S\s]*)\}|(?!\s|{)((?:(?<!return\s+)(?:"[^"\n]*"|'[^'\n]*'|`[^`]*`|[^\n;"'`]))*;)))$/;
+const ASYNC_FUNCTION = Object.getPrototypeOf(async () => { }).constructor;
+let CACHE_COERCED = new WeakSet();
+let LOG_CURRENT = null;
+let TEMP_DIR = path.join(process.cwd(), "tmp");
+let INCREMENT_COUNT = 65536;
+let INCREMENT_PREFIX = '';
+function fromObject(value, typedArray) {
+    if (isObject(value)) {
+        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 (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);
+            }
+        }
+    }
+    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;
+}
+const convertScrypt = (key, iv, data) => crypto.scryptSync(key, iv, Math.ceil(data.length / 16) * 16);
+const isFunction = (value) => typeof value === 'function';
+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 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 || (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 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 || (exports.THRESHOLD = THRESHOLD = {}));
+var IMPORT_MAP;
+(function (IMPORT_MAP) {
+    IMPORT_MAP["@squared-functions/cloud"] = "@e-mc/cloud";
+    IMPORT_MAP["@squared-functions/cloud/util"] = "@e-mc/cloud/util";
+    IMPORT_MAP["@squared-functions/compress-v3"] = "@e-mc/compress";
+    IMPORT_MAP["@squared-functions/core"] = "@e-mc/core";
+    IMPORT_MAP["@squared-functions/db"] = "@e-mc/db";
+    IMPORT_MAP["@squared-functions/db/pool"] = "@e-mc/db/pool";
+    IMPORT_MAP["@squared-functions/db/util"] = "@e-mc/db/util";
+    IMPORT_MAP["@squared-functions/document"] = "@e-mc/document";
+    IMPORT_MAP["@squared-functions/document/parse"] = "@e-mc/document/parse";
+    IMPORT_MAP["@squared-functions/document/parse/dom"] = "@e-mc/document/parse/dom";
+    IMPORT_MAP["@squared-functions/document/transform"] = "@e-mc/document/transform";
+    IMPORT_MAP["@squared-functions/document/asset"] = "@e-mc/document/asset";
+    IMPORT_MAP["@squared-functions/document/util"] = "@e-mc/document/util";
+    IMPORT_MAP["@squared-functions/file-manager"] = "@e-mc/file-manager";
+    IMPORT_MAP["@squared-functions/file-manager/http/host"] = "@e-mc/request/http/host";
+    IMPORT_MAP["@squared-functions/image-v3"] = "@e-mc/image";
+    IMPORT_MAP["@squared-functions/module"] = "@e-mc/module";
+    IMPORT_MAP["@squared-functions/task"] = "@e-mc/task";
+    IMPORT_MAP["@squared-functions/types"] = "@e-mc/types";
+    IMPORT_MAP["@squared-functions/watch"] = "@e-mc/watch";
+    IMPORT_MAP["@squared-functions/watch/filegroup"] = "@e-mc/watch/filegroup";
+    IMPORT_MAP["@squared-functions/document/android"] = "@pi-r/android";
+    IMPORT_MAP["@squared-functions/document/android/extensions/app/manifest"] = "@pi-r/android/extensions/app/manifest";
+    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/dependencies"] = "@pi-r/android/extensions/gradle/dependencies";
+    IMPORT_MAP["@squared-functions/document/android/extensions/gradle/settings"] = "@pi-r/android/extensions/gradle/settings";
+    IMPORT_MAP["@squared-functions/document/android/extensions/task"] = "@pi-r/android/extensions/task";
+    IMPORT_MAP["@squared-functions/document/chrome"] = "@pi-r/chrome";
+    IMPORT_MAP["@squared-functions/image/jimp"] = "@pi-r/jimp";
+    IMPORT_MAP["@squared-functions/image/jimp/util"] = "@pi-r/jimp/util";
+    IMPORT_MAP["@squared-functions/image-v3/jimp"] = "@pi-r/jimp";
+    IMPORT_MAP["@squared-functions/task/gulp"] = "@pi-r/gulp";
+    IMPORT_MAP["@squared-functions/cloud/atlas"] = "@pi-r/atlas";
+    IMPORT_MAP["@squared-functions/cloud/aws"] = "@pi-r/aws";
+    IMPORT_MAP["@squared-functions/cloud/aws/download"] = "@pi-r/aws/download";
+    IMPORT_MAP["@squared-functions/cloud/aws/upload"] = "@pi-r/aws/upload";
+    IMPORT_MAP["@squared-functions/cloud/aws-v3"] = "@pi-r/aws-v3";
+    IMPORT_MAP["@squared-functions/cloud/aws-v3/download"] = "@pi-r/aws-v3/download";
+    IMPORT_MAP["@squared-functions/cloud/aws-v3/upload"] = "@pi-r/aws-v3/upload";
+    IMPORT_MAP["@squared-functions/cloud/azure"] = "@pi-r/azure";
+    IMPORT_MAP["@squared-functions/cloud/azure/download"] = "@pi-r/azure/download";
+    IMPORT_MAP["@squared-functions/cloud/azure/upload"] = "@pi-r/azure/upload";
+    IMPORT_MAP["@squared-functions/cloud/gcp"] = "@pi-r/gcp";
+    IMPORT_MAP["@squared-functions/cloud/gcp/download"] = "@pi-r/gcp/download";
+    IMPORT_MAP["@squared-functions/cloud/gcp/upload"] = "@pi-r/gcp/upload";
+    IMPORT_MAP["@squared-functions/cloud/ibm"] = "@pi-r/ibm";
+    IMPORT_MAP["@squared-functions/cloud/ibm/download"] = "@pi-r/ibm/download";
+    IMPORT_MAP["@squared-functions/cloud/ibm/upload"] = "@pi-r/ibm/upload";
+    IMPORT_MAP["@squared-functions/cloud/ibm-v1"] = "@pi-r/ibm";
+    IMPORT_MAP["@squared-functions/cloud/ibm-v1/download"] = "@pi-r/ibm/download";
+    IMPORT_MAP["@squared-functions/cloud/ibm-v1/upload"] = "@pi-r/ibm/upload";
+    IMPORT_MAP["@squared-functions/cloud/minio"] = "@pi-r/minio";
+    IMPORT_MAP["@squared-functions/cloud/minio/download"] = "@pi-r/minio/download";
+    IMPORT_MAP["@squared-functions/cloud/minio/upload"] = "@pi-r/minio/upload";
+    IMPORT_MAP["@squared-functions/cloud/oci"] = "@pi-r/oci";
+    IMPORT_MAP["@squared-functions/cloud/oci/download"] = "@pi-r/oci/download";
+    IMPORT_MAP["@squared-functions/cloud/oci/upload"] = "@pi-r/oci/upload";
+    IMPORT_MAP["@squared-functions/db/mongodb"] = "@pi-r/mongodb";
+    IMPORT_MAP["@squared-functions/db/mssql"] = "@pi-r/mssql";
+    IMPORT_MAP["@squared-functions/db/mysql"] = "@pi-r/mysql";
+    IMPORT_MAP["@squared-functions/db/oracle"] = "@pi-r/oracle";
+    IMPORT_MAP["@squared-functions/db/postgres"] = "@pi-r/postgres";
+    IMPORT_MAP["@squared-functions/db/redis"] = "@pi-r/redis";
+    IMPORT_MAP["@squared-functions/document/packages/@babel/core"] = "@pi-r/babel";
+    IMPORT_MAP["@squared-functions/document/packages/clean-css"] = "@pi-r/clean-css";
+    IMPORT_MAP["@squared-functions/document/packages/eslint"] = "@pi-r/eslint";
+    IMPORT_MAP["@squared-functions/document/packages/html-minifier"] = "@pi-r/html-minifier";
+    IMPORT_MAP["@squared-functions/document/packages/html-minifier-terser"] = "@pi-r/html-minifier-terser";
+    IMPORT_MAP["@squared-functions/document/packages/html-validate"] = "@pi-r/html-validate";
+    IMPORT_MAP["@squared-functions/document/packages/postcss"] = "@pi-r/postcss";
+    IMPORT_MAP["@squared-functions/document/packages/posthtml"] = "@pi-r/posthtml";
+    IMPORT_MAP["@squared-functions/document/packages/prettier"] = "@pi-r/prettier";
+    IMPORT_MAP["@squared-functions/document/packages/rollup"] = "@pi-r/rollup";
+    IMPORT_MAP["@squared-functions/document/packages/sass"] = "@pi-r/sass";
+    IMPORT_MAP["@squared-functions/document/packages/stylelint"] = "@pi-r/stylelint";
+    IMPORT_MAP["@squared-functions/document/packages/svgo"] = "@pi-r/svgo";
+    IMPORT_MAP["@squared-functions/document/packages/terser"] = "@pi-r/terser";
+    IMPORT_MAP["@squared-functions/document/packages/uglify-js"] = "@pi-r/uglify-js";
+})(IMPORT_MAP || (exports.IMPORT_MAP = IMPORT_MAP = {}));
+function createAbortError() {
+    return new AbortError();
+}
+exports.createAbortError = createAbortError;
+function hasBit(value, flags) {
+    return typeof value === 'number' && (value & flags) > 0;
+}
+exports.hasBit = hasBit;
+function ignoreFlag(value) {
+    return typeof value === 'number' && (value & 1) === 1;
+}
+exports.ignoreFlag = ignoreFlag;
+function cloneFlag(value) {
+    return typeof value === 'number' && (value & 2) === 2;
+}
+exports.cloneFlag = cloneFlag;
+function usingFlag(value) {
+    return typeof value === 'number' && (value & 4) === 4;
+}
+exports.usingFlag = usingFlag;
+function watchFlag(value) {
+    return typeof value === 'number' && (value & 8) === 8;
+}
+exports.watchFlag = watchFlag;
+function modifiedFlag(value) {
+    return typeof value === 'number' && (value & 16) === 16;
+}
+exports.modifiedFlag = modifiedFlag;
+function processFlag(value) {
+    return typeof value === 'number' && (value & 32) === 32;
+}
+exports.processFlag = processFlag;
+function mainFlag(value) {
+    return typeof value === 'number' && (value & 64) === 64;
+}
+exports.mainFlag = mainFlag;
+function existsFlag(value) {
+    return typeof value === 'number' && (value & 128) === 128;
+}
+exports.existsFlag = existsFlag;
+function getLogCurrent() {
+    return LOG_CURRENT;
+}
+exports.getLogCurrent = getLogCurrent;
+function setLogCurrent(value) {
+    LOG_CURRENT = value;
+}
+exports.setLogCurrent = setLogCurrent;
+function getTempDir() {
+    return TEMP_DIR;
+}
+exports.getTempDir = getTempDir;
+function setTempDir(value) {
+    try {
+        if (path.isAbsolute(value) && fs.statSync(value).isDirectory()) {
+            TEMP_DIR = value;
+            return true;
+        }
+    }
+    catch {
+    }
+    return false;
+}
+exports.setTempDir = setTempDir;
+function isArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+exports.isArray = isArray;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && (value.constructor === Object || Object.getPrototypeOf(value) === null);
+}
+exports.isPlainObject = isPlainObject;
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+exports.isObject = isObject;
+function isString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+exports.isString = isString;
+function isEmpty(value) {
+    return value === undefined || value === null || value === '' || Array.isArray(value) && value.length === 0;
+}
+exports.isEmpty = isEmpty;
+function parseTime(value, start = 0) {
+    const seconds = +value;
+    if (isNaN(seconds) && isString(value)) {
+        const pattern = /\b([\d.]+)\s*(y|M|w|d|h|ms?|s)\b/g;
+        let result = 0, match = null;
+        while (match = pattern.exec(value.toLowerCase())) {
+            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;
+}
+exports.parseTime = parseTime;
+function parseExpires(value, start = 0) {
+    if (+value < 0 || value === 'never') {
+        return Infinity;
+    }
+    return parseTime(value, start);
+}
+exports.parseExpires = parseExpires;
+function formatTime(value, elapsed, char = ' ') {
+    const result = [];
+    if (elapsed === true) {
+        value = Date.now() - value;
+    }
+    else if (isString(elapsed)) {
+        char = elapsed;
+    }
+    if (value < 1000) {
+        return value + 'ms';
+    }
+    const h = Math.floor(value / 3600000);
+    if (h > 0) {
+        value -= h * 3600000;
+        result.push(h + 'h');
+    }
+    const m = Math.floor(value / 60000);
+    if (m > 0) {
+        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);
+}
+exports.formatTime = formatTime;
+function convertTime(value, format) {
+    if (Array.isArray(value)) {
+        const result = Math.ceil((value[0] * 1000000000 + value[1]) / 1000000);
+        return format ? formatTime(result) : result;
+    }
+    return parseTime(value);
+}
+exports.convertTime = convertTime;
+function hasGlob(value) {
+    return /(?<!\\)(?:(?:[^*]|^)\*{1,2}(?:[^*]|$)|\{[^}]+\}|\[[!^][^\]]+\]|[!?*+@]\([^)]+\))/.test(value);
+}
+exports.hasGlob = hasGlob;
+function escapePattern(value, lookBehind) {
+    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 '-':
+                    case '.':
+                    case '+':
+                    case '*':
+                    case '?':
+                    case '|':
+                    case '\\':
+                    case '(':
+                    case ')':
+                    case '[':
+                    case ']':
+                    case '{':
+                    case '}':
+                    case '^':
+                    case '$':
+                        if (lookBehind && value[i - 1] === '\\') {
+                            break;
+                        }
+                        result += value.substring(j, i) + (ch === '-' ? '\\x2d' : '\\' + ch);
+                        j = i + 1;
+                        break;
+                }
+            }
+            return j > 0 ? result + value.substring(j) : value;
+        }
+        case 'number':
+            return value.toString();
+        default:
+            return '';
+    }
+}
+exports.escapePattern = escapePattern;
+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;
+}
+exports.renameExt = renameExt;
+function formatSize(value, options) {
+    if (typeof value === 'number') {
+        return (bytes(value, options) || ('0' + ((options === null || options === void 0 ? void 0 : options.unitSeparator) || '') + 'B'));
+    }
+    return (bytes(value) || 0);
+}
+exports.formatSize = formatSize;
+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(result / kb) * kb;
+    }
+    return result;
+}
+exports.alignSize = alignSize;
+function cascadeObject(data, query, fallback) {
+    if (isObject(data) && isString(query)) {
+        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;
+}
+exports.cascadeObject = cascadeObject;
+function cloneObject(data, options) {
+    let target, deep, deepIgnore, typedArray, inherited, nonenumerable, symbol, preserve;
+    if (options === true) {
+        deep = true;
+    }
+    else if (options instanceof WeakSet) {
+        deep = true;
+        deepIgnore = options;
+    }
+    else if (options) {
+        ({ target, deep, deepIgnore, typedArray, inherited, nonenumerable, symbol, preserve } = options);
+    }
+    let nested;
+    if (deep) {
+        deepIgnore || (deepIgnore = new WeakSet());
+        nested = { deep, deepIgnore, typedArray, preserve };
+    }
+    if (Array.isArray(data)) {
+        if (deepIgnore) {
+            deepIgnore.add(data);
+        }
+        const length = data.length;
+        if (!target || !Array.isArray(target)) {
+            target = new Array(length);
+        }
+        else {
+            target.length = 0;
+        }
+        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);
+            }
+            else {
+                target[i] = Array.isArray(value) ? value.slice(0) : value;
+            }
+        }
+    }
+    else if (isObject(data)) {
+        if (deepIgnore) {
+            deepIgnore.add(data);
+        }
+        if (!target || !isObject(target)) {
+            target = {};
+        }
+        const getProperties = (obj) => {
+            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;
+        };
+        for (const attr of getProperties(data)) {
+            const value = data[attr];
+            let merge;
+            if (deepIgnore) {
+                merge = (Array.isArray(value) || isPlainObject(value)) && !deepIgnore.has(value) ? cloneObject(value, nested) : fromObject(value, typedArray);
+            }
+            else {
+                merge = Array.isArray(value) ? value.slice(0) : value;
+            }
+            if (preserve && isPlainObject(target[attr]) && isPlainObject(merge)) {
+                (function recurse(current, next) {
+                    for (const item of getProperties(next)) {
+                        const b = next[item];
+                        if (!(item in current)) {
+                            current[item] = b;
+                        }
+                        else {
+                            const a = current[item];
+                            if (isPlainObject(a) && isPlainObject(b)) {
+                                recurse(a, b);
+                            }
+                        }
+                    }
+                })(target[attr], merge);
+            }
+            else {
+                target[attr] = merge;
+            }
+        }
+    }
+    else {
+        return deep ? fromObject(data, typedArray) : data;
+    }
+    return target;
+}
+exports.cloneObject = cloneObject;
+function coerceObject(data, parseString, cache) {
+    if (typeof parseString === 'boolean') {
+        cache = parseString;
+        parseString = undefined;
+    }
+    else if (parseString && typeof parseString !== 'function') {
+        return data;
+    }
+    if (!parseString) {
+        parseString = (value) => {
+            if (value.length > 8) {
+                switch (value.substring(0, 3)) {
+                    case 'new': {
+                        const match = /^new\s+(Date|RegExp|URL|Map|WeakMap|Set|WeakSet)\(([\S\s]*)\)$/.exec(value.trimEnd());
+                        if (!match) {
+                            break;
+                        }
+                        try {
+                            const removeQuotes = (content) => content.trim().replace(/^["']/g, '').replace(/["']$/g, '').trim();
+                            const errorCreate = () => errorValue('Invalid parameters', match[2].trim());
+                            switch (match[1]) {
+                                case 'Date':
+                                    return new Date(match[2].replace(/["']/g, '').trim());
+                                case 'URL':
+                                case 'RegExp': {
+                                    const pattern = /^("[^"]+"|'[^']+'|[^\s,]+)(?:\s*,\s*("[^"]+"|'[^']+'|\S+))?$/.exec(match[2].trim());
+                                    if (pattern) {
+                                        return new (match[1] === 'URL' ? URL : RegExp)(removeQuotes(pattern[1]), pattern[2] ? removeQuotes(pattern[2]) : '');
+                                    }
+                                    throw errorCreate();
+                                }
+                                default: {
+                                    const text = match[2].trim();
+                                    let values = [];
+                                    if (text.startsWith('[') && text.endsWith(']')) {
+                                        values = JSON.parse(text);
+                                    }
+                                    else if (text) {
+                                        throw errorCreate();
+                                    }
+                                    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':
+                        if (value.substring(3, 5) === 'nc') {
+                            return asFunction(value);
+                        }
+                        break;
+                    case 'fun':
+                        if (value.substring(3, 8) === 'ction') {
+                            return asFunction(value);
+                        }
+                        break;
+                    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;
+        };
+    }
+    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);
+}
+exports.coerceObject = coerceObject;
+function asFunction(value, sync = true) {
+    if (isFunction(value)) {
+        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] && (match[5] = 'return ' + match[5])));
+            return new ASYNC_FUNCTION(...args);
+        }
+        try {
+            const result = (0, eval)(`(${match[2]})`);
+            if (isFunction(result)) {
+                return result;
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+exports.asFunction = asFunction;
+function getEncoding(value, fallback = 'utf-8') {
+    if (typeof value === 'string') {
+        switch (value = value.trim().toLowerCase()) {
+            case 'utf8':
+            case 'utf-8':
+            case 'utf16le':
+                return value;
+            case 'utf-16le':
+            case 'utf16':
+            case 'utf-16':
+                return 'utf16le';
+        }
+        if (Buffer.isEncoding(value)) {
+            return value;
+        }
+    }
+    return fallback;
+}
+exports.getEncoding = getEncoding;
+function encryptUTF8(algorithm, key, iv, data, encoding = 'hex') {
+    if (checkCipherType(algorithm) && isString(data)) {
+        try {
+            const gcm = crypto.createCipheriv(algorithm, convertScrypt(key, iv, data), iv);
+            return gcm.update(data, 'utf-8', encoding) + gcm.final(encoding);
+        }
+        catch {
+        }
+    }
+}
+exports.encryptUTF8 = encryptUTF8;
+function decryptUTF8(algorithm, key, iv, data, encoding = 'hex') {
+    if (checkCipherType(algorithm) && isString(data)) {
+        try {
+            const gcm = crypto.createDecipheriv(algorithm, convertScrypt(key, iv, data), iv);
+            return gcm.update(data, encoding, 'utf-8') + gcm.final('utf-8');
+        }
+        catch {
+        }
+    }
+}
+exports.decryptUTF8 = decryptUTF8;
+function randomString(format, dictionary) {
+    if (format !== '8-4-4-4-12' || dictionary) {
+        const match = format.match(/(\d+|[^\d]+)/g);
+        if (match) {
+            try {
+                dictionary || (dictionary = '0123456789abcdef');
+                const result = format.match(/(\d+|[^\d[]+|\[[^\]]+\]|\[)/g).reduce((a, b) => {
+                    let length, available;
+                    if (b.startsWith('[') && b.endsWith(']')) {
+                        length = 1;
+                        available = b.substring(1, b.length - 1);
+                    }
+                    else {
+                        length = +b;
+                        available = dictionary;
+                    }
+                    if (!isNaN(length)) {
+                        const j = available.length;
+                        if (isFunction(crypto.getRandomValues) && length > 1) {
+                            const items = crypto.getRandomValues(new Uint32Array(length));
+                            for (let i = 0; i < length; i++) {
+                                a += available[items[i] % j];
+                            }
+                        }
+                        else {
+                            for (let i = 0; i < length; ++i) {
+                                a += available[Math.floor(Math.random() * j)];
+                            }
+                        }
+                        return a;
+                    }
+                    return a + b;
+                }, '');
+                if (result) {
+                    return result;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return (0, exports.generateUUID)();
+}
+exports.randomString = randomString;
+function validateUUID(value) {
+    return typeof value === 'string' && value.length === 36 && REGEXP_UUID.test(value);
+}
+exports.validateUUID = validateUUID;
+function errorValue(value, hint) {
+    return new Error(value + (hint ? ` (${hint})` : ''));
+}
+exports.errorValue = errorValue;
+function errorMessage(title, value, hint) {
+    return new Error((title !== '' ? title + ': ' : '') + value + (hint ? ` (${hint})` : ''));
+}
+exports.errorMessage = errorMessage;
+function purgeMemory(percent) {
+    CACHE_COERCED = new WeakSet();
+}
+exports.purgeMemory = purgeMemory;
+function incrementUUID(restart) {
+    if (restart || INCREMENT_COUNT === 65536) {
+        INCREMENT_COUNT = 0;
+        INCREMENT_PREFIX = (0, exports.generateUUID)().substring(0, 33);
+    }
+    return INCREMENT_PREFIX + (INCREMENT_COUNT++).toString(16).padStart(4, '0');
+}
+exports.incrementUUID = incrementUUID;
+exports.generateUUID = typeof crypto.randomUUID === 'function' ? crypto.randomUUID.bind(crypto) : require('uuid').v4;