@e-mc/module 0.0.1

package/index.js

@@ -0,0 +1,3326 @@
+"use strict";
+/* eslint no-global-assign: "off" */
+var _a, _b, _c, _d, _e, _f, _g;
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const crypto = require("crypto");
+const url = require("url");
+const filetype = require("file-type");
+const mime = require("mime-types");
+const chalk = require("chalk");
+const stripansi = require("strip-ansi");
+const EventEmitter = require("events");
+const types_1 = require("../types");
+const kSessionId = Symbol('sessionId');
+const kBroadcastId = Symbol('broadcastId');
+const kTempDir = Symbol('tempDir');
+const kPermission = Symbol('permission');
+const kSupports = Symbol('supports');
+const kAbortHandler = Symbol('abortHandler');
+const kAbortEvent = Symbol('abortEvent');
+const PROCESS_CWD = process.cwd();
+const PROCESS_STDOUT = process.stdout;
+const PLATFORM_WIN32 = process.platform === 'win32';
+const OS_HOMEDIR = os.homedir();
+const MEM_TOTAL = os.totalmem();
+const CPU_CORETOTAL = os.cpus().length;
+const [VER_MAJOR, VER_MINOR, VER_PATCH] = process.version.substring(1).split('.').map(value => +value);
+const CACHE_READTEXT = new Map();
+const CACHE_READBUFFER = new Map();
+const CACHE_READCJS = new Map();
+let CACHE_EXEC = new WeakMap();
+let CACHE_CPU = new WeakMap();
+let CACHE_CPUHOST = new WeakMap();
+let CACHE_TOTAL = 0;
+const SETTINGS = {
+    enabled: true,
+    production: undefined,
+    format: {
+        title: {
+            width: 6,
+            justify: 'right'
+        },
+        value: {
+            width: 71,
+            justify: 'left'
+        },
+        hint: {
+            width: 32,
+            unit: 'auto'
+        },
+        meter: {
+            width: Infinity,
+            bgColor: 'bgCyan',
+            bgAltColor: 'bgYellow'
+        },
+        session_id: {},
+        message: {}
+    },
+    meter: {
+        http: 100,
+        process: 250
+    },
+    status: {
+        fatal: true,
+        error: true,
+        warn: true,
+        info: true,
+        debug: true,
+        trace: true
+    },
+    color: true,
+    session_id: 0,
+    message: true,
+    stack_trace: false,
+    unknown: true,
+    system: true,
+    node: true,
+    process: {
+        cpu: true,
+        cpu_bar: true,
+        cpu_single_core: true,
+        mem: true,
+        mem_format: '%'
+    },
+    image: true,
+    compress: true,
+    watch: true,
+    file: true,
+    cloud: true,
+    db: true,
+    time_elapsed: true,
+    time_process: true,
+    exec: true,
+    http: false,
+    stdout: true
+};
+const VALUES = {
+    ["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */]: 'cjs',
+    ["node.require.npm" /* KEY_NAME.NODE_REQUIRE_NPM */]: true,
+    ["node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */]: true,
+    ["node.process.cpu_usage" /* KEY_NAME.NODE_PROCESS_CPUUSAGE */]: true,
+    ["node.process.memory_usage" /* KEY_NAME.NODE_PROCESS_MEMORYUSAGE */]: true,
+    ["node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */]: true,
+    ["temp.dir" /* KEY_NAME.TEMP_DIR */]: "tmp" /* INTERNAL.TEMP_DIR */,
+    ["temp.write" /* KEY_NAME.TEMP_WRITE */]: false,
+    ["process.password" /* KEY_NAME.PROCESS_PASSWORD */]: '',
+    ["process.cipher.algorithm" /* KEY_NAME.PROCESS_CIPHER_ALGORITHM */]: '',
+    ["process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */]: false,
+    ["permission.process_exec" /* KEY_NAME.PERMISSION_PROCESS_EXEC */]: [],
+    ["permission.home_read" /* KEY_NAME.PERMISSION_HOMEREAD */]: false,
+    ["permission.home_write" /* KEY_NAME.PERMISSION_HOMEWRITE */]: false,
+    ["memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */]: false,
+    ["error.out" /* KEY_NAME.ERROR_OUT */]: null,
+    ["error.fatal" /* KEY_NAME.ERROR_FATAL */]: false,
+    ["broadcast.out" /* KEY_NAME.BROADCAST_OUT */]: null,
+    ["logger.level" /* KEY_NAME.LOGGER_LEVEL */]: -1
+};
+const REGEXP_SHELLOPT = /^(-[^\s=]+|--[^-\s=][^\s=]*)(=)?\s*(.*)$/;
+const REGEXP_SHELLVAL = /[^0-9a-z%+-./:=@_]/gi;
+const REGEXP_TORRENT = /^(?:magnet:\?xt=|(?:https?|s?ftp):\/\/[^/][^\n]*?\.(?:torrent|metalink|meta4)(?:\?[^\n]*)?$)/i;
+let LOG_NEWLINE = true;
+let LOG_EMPTYLINE = false;
+let TEMP_DIR = path.join(PROCESS_CWD, "tmp" /* INTERNAL.TEMP_DIR */);
+const PNPM_VER = (function () {
+    try {
+        const pathname = path.resolve('./node_modules/.modules.yaml');
+        if (fs.existsSync(pathname)) {
+            return fs.readFileSync(pathname, 'utf-8');
+        }
+    }
+    catch {
+    }
+    return '';
+})();
+const YARN_VER = (function () {
+    try {
+        const pathname = path.resolve('./.pnp.cjs');
+        if (fs.existsSync(pathname)) {
+            return require(pathname);
+        }
+    }
+    catch {
+    }
+    return null;
+})();
+function applyStyle(options, style) {
+    var _h;
+    for (const attr in style) {
+        (_h = options)[attr] ?? (_h[attr] = style[attr]);
+    }
+    return options;
+}
+function checkColorOptions(type, settings, options) {
+    if (typeof settings !== 'object') {
+        return false;
+    }
+    let result = false;
+    if (settings.valueColor) {
+        options.valueColor || (options.valueColor = settings.valueColor);
+        result = true;
+    }
+    if (settings.valueBgColor) {
+        options.valueBgColor || (options.valueBgColor = settings.valueBgColor);
+        result = true;
+    }
+    if (typeof settings.valueBold === 'boolean') {
+        options.valueBold ?? (options.valueBold = settings.valueBold);
+    }
+    if (settings.hintColor) {
+        options.hintColor || (options.hintColor = settings.hintColor);
+        result = true;
+    }
+    if (settings.hintBgColor) {
+        options.hintBgColor || (options.hintBgColor = settings.hintBgColor);
+        result = true;
+    }
+    if (typeof settings.hintBold === 'boolean') {
+        options.hintBold ?? (options.hintBold = settings.hintBold);
+    }
+    if (type & types_1.LOG_TYPE.FAIL) {
+        return result;
+    }
+    if (settings.titleColor) {
+        options.titleColor || (options.titleColor = settings.titleColor);
+        result = true;
+    }
+    if (settings.titleBgColor) {
+        options.titleBgColor || (options.titleBgColor = settings.titleBgColor);
+        result = true;
+    }
+    if (typeof settings.titleBold === 'boolean') {
+        options.titleBold ?? (options.titleBold = settings.titleBold);
+    }
+    if (settings.messageColor) {
+        options.messageColor || (options.messageColor = settings.messageColor);
+        result = true;
+    }
+    if (settings.messageBgColor) {
+        options.messageBgColor || (options.messageBgColor = settings.messageBgColor);
+        result = true;
+    }
+    if (typeof settings.messageBold === 'boolean') {
+        options.messageBold ?? (options.messageBold = settings.messageBold);
+    }
+    return result;
+}
+function tryCreateDir(value) {
+    try {
+        if (fs.mkdirSync(value, { recursive: true }) && fs.statSync(value).isDirectory()) {
+            return true;
+        }
+    }
+    catch {
+    }
+    for (let i = value.length - 1, pathname = '', subDir = []; i >= 0; --i) {
+        const ch = value[i];
+        if (ch !== path.sep) {
+            pathname = ch + pathname;
+        }
+        else if (pathname) {
+            let dir = value.substring(0, i + 1);
+            subDir.push(pathname);
+            if (fs.existsSync(dir)) {
+                if (!fs.statSync(dir).isDirectory()) {
+                    throw errorDirectory(dir);
+                }
+                for (let j = subDir.length - 1; j >= 0; --j) {
+                    dir += subDir[j];
+                    if (!fs.existsSync(dir)) {
+                        fs.mkdirSync(dir);
+                    }
+                    else if (!fs.statSync(dir).isDirectory()) {
+                        throw errorDirectory(dir);
+                    }
+                    dir += path.sep;
+                }
+                return true;
+            }
+            pathname = '';
+        }
+    }
+    return false;
+}
+function tryRemoveDir(value, empty, recursive) {
+    const temp = typeof empty === 'number';
+    let options;
+    if (!temp) {
+        if (Module.supported(14, 14)) {
+            fs.rmSync(value, { recursive, force: true });
+            if (empty) {
+                fs.mkdirSync(value);
+            }
+            return [];
+        }
+        options = { recursive };
+    }
+    value = Module.normalizePath(value, 1);
+    const failed = [];
+    const nameMap = new WeakMap();
+    let files;
+    if (temp) {
+        files = [];
+        fs.readdirSync(value).forEach(name => {
+            try {
+                const stat = fs.statSync(value + name);
+                nameMap.set(stat, name);
+                files.push(stat);
+            }
+            catch {
+                failed.push(value + name);
+            }
+        });
+    }
+    else {
+        files = fs.readdirSync(value, { withFileTypes: true });
+    }
+    const current = Date.now();
+    for (let i = 0, length = files.length; i < length; ++i) {
+        const file = files[i];
+        const pathname = value + (file.name || nameMap.get(file));
+        try {
+            if (file.isDirectory()) {
+                if (recursive) {
+                    if (options) {
+                        fs.rmdirSync(pathname, options);
+                    }
+                    else if (!Module.removeDir(pathname, typeof empty === 'number' ? empty : true)) {
+                        failed.push(pathname);
+                    }
+                }
+            }
+            else if (!temp || file.ctimeMs + empty <= current) {
+                fs.unlinkSync(pathname);
+            }
+        }
+        catch {
+            failed.push(pathname);
+        }
+    }
+    if (!empty && failed.length === 0) {
+        fs.rmdirSync(value);
+    }
+    return failed;
+}
+function errorObject(message) {
+    switch (typeof message) {
+        case 'string':
+            return new Error(message);
+        case 'number':
+            return (0, types_1.errorMessage)("Error code" /* ERR_MESSAGE.ERROR_CODE */, message.toString());
+        default:
+            return message instanceof Error ? message : new Error(Module.asString(message) || "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+    }
+}
+function isFailed(options) {
+    if (options.failed) {
+        if (!options.titleColor && !options.titleBgColor) {
+            Object.assign(options, Module.LOG_STYLE_NOTICE);
+        }
+        return true;
+    }
+    return false;
+}
+function getErrorMessage(err) {
+    return SETTINGS.stack_trace && err.stack || err.message || err.toString() || "Unknown" /* ERR_MESSAGE.UNKNOWN */;
+}
+function writeLine(value) {
+    PROCESS_STDOUT.write((!LOG_NEWLINE ? '\n' : '') + value + '\n');
+    LOG_NEWLINE = true;
+    LOG_EMPTYLINE = false;
+}
+function errorPermission(value) {
+    return (0, types_1.errorValue)("Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */, value);
+}
+function parseFileArgs(options = {}, callback) {
+    let promises;
+    if (typeof options === 'boolean') {
+        promises = options;
+        options = {};
+    }
+    else if (isFunction(options)) {
+        callback = options;
+        options = {};
+    }
+    if (typeof callback === 'boolean') {
+        promises = callback;
+        callback = undefined;
+    }
+    return [options, promises, callback];
+}
+function formatTimeHint(value) {
+    switch (SETTINGS.format.hint.unit) {
+        case 'ms':
+            return value + 'ms';
+        case 's':
+            return (value / 1000) + 's';
+        default:
+            return (0, types_1.formatTime)(value);
+    }
+}
+function getTimeOffset(time, current) {
+    if (!time) {
+        return 0;
+    }
+    if (Array.isArray(time)) {
+        return (0, types_1.convertTime)(process.hrtime(time));
+    }
+    return (current || Date.now()) - (time instanceof Date ? time.getTime() : time);
+}
+function getTimeStamp(options, include) {
+    const timeStamp = options.timeStamp;
+    if (timeStamp instanceof Date) {
+        return timeStamp.getTime();
+    }
+    if (include) {
+        return Date.now();
+    }
+}
+function getCacheItem(map, key) {
+    const item = map.get(key);
+    if (item) {
+        item[0] = Date.now();
+        return item[1];
+    }
+}
+function addCacheItem(map, key, data) {
+    if (!map.has(key)) {
+        ++CACHE_TOTAL;
+    }
+    map.set(key, [Date.now(), data]);
+}
+function checkFunction(value) {
+    if (typeof value === 'function') {
+        Object.defineProperty(value, "__cjs__" /* INTERNAL.CJS */, { value: true });
+        return value;
+    }
+    return null;
+}
+function encryptMessage(data, cipher, algorithm) {
+    var _h;
+    if (cipher?.key && cipher.iv) {
+        if (!algorithm) {
+            algorithm = cipher.algorithm || 'aes-256-gcm';
+        }
+        const result = (0, types_1.encryptUTF8)(algorithm, cipher.key, cipher.iv, data);
+        if (result) {
+            VALUES[_h = "process.cipher.algorithm" /* KEY_NAME.PROCESS_CIPHER_ALGORITHM */] || (VALUES[_h] = algorithm);
+            return result;
+        }
+    }
+    return data;
+}
+function setCpuAndMem(options) {
+    let host, usage;
+    if (!options.messageUnit && (usage = ('startCPU' in this) && this.startCPU || CACHE_CPUHOST.get(this) || (host = this.host) && CACHE_CPUHOST.get(host))) {
+        options.messageUnit = Module.formatCpuMem(usage);
+    }
+}
+function hasFileSystem(type, value, options, ignoreExists, overwrite) {
+    let result;
+    if (path.isAbsolute(value)) {
+        if (options.absolutePath === false) {
+            if (options.throwsPermission) {
+                throw errorPermission(value);
+            }
+            return '';
+        }
+        result = path.normalize(value);
+    }
+    else if (!(result = Module.fromLocalPath(value))) {
+        if (options.throwsDoesNotExist) {
+            throw (0, types_1.errorValue)("File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, value);
+        }
+        return '';
+    }
+    if (overwrite === false && Module.isPath(result)) {
+        if (options.throwsPermission) {
+            throw errorPermission(value);
+        }
+        return '';
+    }
+    if (!ignoreExists && !Module.isPath(result)) {
+        if (options.throwsDoesNotExist) {
+            throw (0, types_1.errorValue)("File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, value);
+        }
+        return '';
+    }
+    if (options.ignorePermission) {
+        return result;
+    }
+    const method = type === 1 /* FILE_SYSTEM.WRITE */ ? 'canWrite' : 'canRead';
+    if (options.ownPermissionOnly) {
+        if (this.hasOwnPermission() && !this[method](result)) {
+            if (options.throwsPermission) {
+                throw errorPermission(result);
+            }
+            return '';
+        }
+    }
+    else if (options.hostPermissionOnly) {
+        const host = this.host;
+        if (host?.permission && !host[method](result)) {
+            if (options.throwsPermission) {
+                throw errorPermission(result);
+            }
+            return '';
+        }
+    }
+    else if (this.permission && !this[method](result)) {
+        if (options.throwsPermission) {
+            throw errorPermission(result);
+        }
+        return '';
+    }
+    return result;
+}
+function applyLogId(options) {
+    if (options.sessionId === undefined) {
+        options.sessionId = this.sessionId;
+    }
+    let value = options.broadcastId;
+    if (value === undefined) {
+        if (value = this.broadcastId) {
+            options.broadcastId = this.supports('stripAnsi') ? value : { value, stripAnsi: false };
+        }
+    }
+    else if (!this.supports('stripAnsi')) {
+        if ((0, types_1.isPlainObject)(value)) {
+            value.stripAnsi = false;
+        }
+        else {
+            options.broadcastId = { value, stripAnsi: false };
+        }
+    }
+    return options;
+}
+function withinDir(value, base) {
+    value = path.normalize(value);
+    return (PLATFORM_WIN32 ? value.toLowerCase() : value).startsWith(ensureDir(PLATFORM_WIN32 ? base.toLowerCase() : base));
+}
+function formatPercent(value, precision = 3) {
+    if (value <= 0) {
+        return '0%';
+    }
+    if (value === Math.floor(value)) {
+        return value + '00%';
+    }
+    return (value * 100).toPrecision(precision) + '%';
+}
+function tryIncrementDir(value, increment) {
+    const baseDir = trimDir(value);
+    let i = 0, outErr;
+    do {
+        try {
+            if (tryCreateDir(value)) {
+                return [value, i];
+            }
+        }
+        catch (err) {
+            if (increment === 0) {
+                outErr = err;
+            }
+        }
+        value = baseDir + '_' + ++i;
+    } while (increment-- > 0);
+    return [outErr, -1];
+}
+const asFile = (value) => value instanceof URL ? value.protocol === 'file:' ? url.fileURLToPath(value) : '' : value;
+const wrapQuote = (value) => '"' + value.replace(/"/g, '\\"') + '"';
+const isFunction = (value) => typeof value === 'function';
+const isFileURL = (value) => /^file:\/\//i.test(value);
+const errorDirectory = (value) => (0, types_1.errorValue)("Path is not a directory" /* ERR_MESSAGE.NOT_DIRECTORY */, value);
+const sanitizePath = (value) => (0, types_1.isString)(value) ? path.resolve(value.trim()) : '';
+const ensureDir = (value) => value[value.length - 1] !== path.sep ? value + path.sep : value;
+const trimDir = (value) => value[value.length - 1] === path.sep ? value.substring(0, value.length - 1) : value;
+const getExtension = (value) => path.extname(value).toLowerCase().substring(1);
+const hasString = (item, value) => (0, types_1.isString)(value) && (item === value || Array.isArray(item) && item.includes(value));
+const getCpuTimes = () => os.cpus().reduce((a, b) => a + b.times.user + b.times.sys, 0) * 1000 /* TIME.S */;
+class Module extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.status = [];
+        this.errors = [];
+        this._moduleName = 'unknown';
+        this._host = null;
+        this._abortable = false;
+        this._threadable = false;
+        this._logEnabled = true;
+        this._logFlushed = false;
+        this._logLevel = VALUES["logger.level" /* KEY_NAME.LOGGER_LEVEL */];
+        this._hostEvents = ['abort'];
+        this._logQueued = [];
+        this[_a] = '';
+        this[_b] = VALUES["temp.dir" /* KEY_NAME.TEMP_DIR */];
+        this[_c] = '';
+        this[_d] = null;
+        this[_e] = { stripAnsi: { value: true, modified: false } };
+        this[_f] = new AbortController();
+        this[_g] = null;
+    }
+    static get VERSION() { return "5.0.0" /* INTERNAL.VERSION */; }
+    static get LOG_TYPE() { return types_1.LOG_TYPE; }
+    static get STATUS_TYPE() { return types_1.STATUS_TYPE; }
+    static get MAX_TIMEOUT() { return 2147483647; }
+    static supported(major, minor = 0, patch = 0, lts) {
+        if (VER_MAJOR < major) {
+            return false;
+        }
+        if (VER_MAJOR === major) {
+            if (VER_MINOR < minor) {
+                return false;
+            }
+            if (VER_MINOR === minor) {
+                return VER_PATCH >= patch;
+            }
+            return true;
+        }
+        return !lts;
+    }
+    static enabled(key, username) {
+        switch (key) {
+            case "memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */: {
+                const users = VALUES[key];
+                return users === false || !!username && (users === true || users.includes(username));
+            }
+            case "temp.dir" /* KEY_NAME.TEMP_DIR */:
+                return VALUES[key] !== "tmp" /* INTERNAL.TEMP_DIR */;
+            case "node.require.npm" /* KEY_NAME.NODE_REQUIRE_NPM */:
+            case "node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */:
+            case "node.process.cpu_usage" /* KEY_NAME.NODE_PROCESS_CPUUSAGE */:
+            case "node.process.memory_usage" /* KEY_NAME.NODE_PROCESS_MEMORYUSAGE */:
+            case "node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */:
+            case "temp.write" /* KEY_NAME.TEMP_WRITE */:
+            case "permission.home_read" /* KEY_NAME.PERMISSION_HOMEREAD */:
+            case "permission.home_write" /* KEY_NAME.PERMISSION_HOMEWRITE */:
+            case "process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */:
+            case "error.fatal" /* KEY_NAME.ERROR_FATAL */:
+                return VALUES[key];
+            case "node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */:
+            case "process.password" /* KEY_NAME.PROCESS_PASSWORD */:
+            case "process.cipher.algorithm" /* KEY_NAME.PROCESS_CIPHER_ALGORITHM */:
+                return VALUES[key] !== '';
+            case "permission.process_exec" /* KEY_NAME.PERMISSION_PROCESS_EXEC */:
+                return VALUES[key].length > 0;
+            case "error.out" /* KEY_NAME.ERROR_OUT */:
+            case "broadcast.out" /* KEY_NAME.BROADCAST_OUT */:
+                return VALUES[key] !== null;
+            case "logger.level" /* KEY_NAME.LOGGER_LEVEL */:
+                return VALUES[key] >= 0;
+            default:
+                return false;
+        }
+    }
+    static hasLogType(value) {
+        if (value === 0) {
+            if (SETTINGS.unknown === false) {
+                return false;
+            }
+        }
+        else if ((value & 1 /* LOG_VALUE.SYSTEM */) && SETTINGS.system === false ||
+            (value & 2 /* LOG_VALUE.NODE */) && SETTINGS.node === false ||
+            (value & 4 /* LOG_VALUE.PROCESS */) && SETTINGS.process === false ||
+            (value & 8 /* LOG_VALUE.COMPRESS */) && SETTINGS.compress === false ||
+            (value & 16 /* LOG_VALUE.WATCH */) && SETTINGS.watch === false ||
+            (value & 32 /* LOG_VALUE.FILE */) && SETTINGS.file === false ||
+            (value & 64 /* LOG_VALUE.CLOUD */) && SETTINGS.cloud === false ||
+            (value & 128 /* LOG_VALUE.TIME_ELAPSED */) && SETTINGS.time_elapsed === false ||
+            (value & 256 /* LOG_VALUE.TIME_PROCESS */) && SETTINGS.time_process === false ||
+            (value & 1024 /* LOG_VALUE.HTTP */) && SETTINGS.http === false ||
+            (value & 2048 /* LOG_VALUE.IMAGE */) && SETTINGS.image === false ||
+            (value & 4096 /* LOG_VALUE.EXEC */) && SETTINGS.exec === false ||
+            (value & 32768 /* LOG_VALUE.STDOUT */) && SETTINGS.stdout === false ||
+            (value & 65536 /* LOG_VALUE.DB */) && SETTINGS.db === false) {
+            return false;
+        }
+        return true;
+    }
+    static formatMessage(type, title, value, message, options = {}) {
+        if (options.type) {
+            type |= options.type;
+        }
+        const BROADCAST_OUT = VALUES["broadcast.out" /* KEY_NAME.BROADCAST_OUT */];
+        const sessionId = options.sessionId;
+        let broadcastId = options.broadcastId;
+        if ((type & 512 /* LOG_VALUE.FAIL */) === 512 /* LOG_VALUE.FAIL */ && VALUES["error.out" /* KEY_NAME.ERROR_OUT */]) {
+            try {
+                const ERROR_OUT = VALUES["error.out" /* KEY_NAME.ERROR_OUT */];
+                const errorOptions = { type: type & ~512 /* LOG_VALUE.FAIL */, value, timeStamp: getTimeStamp(options, true), sessionId };
+                // @ts-ignore
+                if (ERROR_OUT["__cjs__" /* INTERNAL.CJS */]) {
+                    ERROR_OUT(errorObject(message), errorOptions);
+                }
+                else {
+                    ERROR_OUT.apply(VALUES["node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */] ? process : null, VALUES["node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */] ? [errorObject(message), errorOptions, require] : [errorObject(message), errorOptions]);
+                }
+            }
+            catch {
+            }
+        }
+        if (broadcastId && !BROADCAST_OUT || (!SETTINGS.enabled || !this.hasLogType(type) && !options.alwaysVisible) && !(broadcastId && BROADCAST_OUT)) {
+            return;
+        }
+        let messageUnitIndent = options.messageUnitIndent, coloring;
+        if (!broadcastId) {
+            (0, types_1.setLogCurrent)({ type, title, value, message });
+            coloring = !(options.useColor === false || SETTINGS.color === false);
+        }
+        else if ((0, types_1.isPlainObject)(broadcastId)) {
+            coloring = broadcastId.stripAnsi === false;
+            broadcastId = broadcastId.value;
+        }
+        const format = SETTINGS.format;
+        const formatTitle = format.title;
+        const formatValue = format.value;
+        const id = sessionId && SETTINGS.session_id ? ' ' + sessionId.padStart(SETTINGS.session_id, '0') + ' ' : '';
+        const titleIndent = options.titleIndent ? typeof options.titleIndent === 'number' ? Math.max(options.titleIndent, 0) : 0 : -1;
+        let output, error, hint, valueWidth = Math.max(formatValue.width - (id ? SETTINGS.session_id + 1 : 0), 1), titleJustify = options.titleJustify || ((type & 512 /* LOG_VALUE.FAIL */) || options.failed ? 'center' : formatTitle.justify);
+        if (Array.isArray(value)) {
+            hint = value[1] ?? '';
+            value = value[0];
+        }
+        if (message && message instanceof Error) {
+            message = getErrorMessage(message);
+            error = true;
+        }
+        if (messageUnitIndent) {
+            let indentChar;
+            if (Array.isArray(messageUnitIndent)) {
+                [messageUnitIndent, indentChar] = messageUnitIndent;
+            }
+            if (messageUnitIndent > 0) {
+                message = (indentChar || ' ').repeat(messageUnitIndent) + this.asString(message);
+            }
+        }
+        const truncateStart = (content, length = 0) => length > 3 && content.length > length ? content.substring(0, length - 3) + '...' : content;
+        const truncateEnd = (content, length) => content.length > length ? '...' + content.substring(content.length - length + 3) : content;
+        const getValue = () => alignColumn(truncateEnd(value, valueWidth - (titleIndent > 0 ? titleIndent - formatTitle.width : !title && message ? -(formatTitle.width + 3) : 0) - 1), valueWidth, formatValue.justify);
+        const alignColumn = (content, width, justify, padding = 0) => {
+            const offset = width - content.length;
+            const spacing = padding === 1 ? ' ' : padding > 0 ? ' '.repeat(padding) : '';
+            if (offset <= 0) {
+                return offset === 0 && padding > 0 ? justify === 'left' ? spacing + content : content + spacing : content;
+            }
+            switch (justify) {
+                case 'right':
+                    return content.padStart(width) + spacing;
+                case 'center':
+                    return content.padStart(content.length + Math.ceil((offset + padding) / 2)).padEnd(width + padding);
+                default:
+                    return spacing + content.padEnd(width);
+            }
+        };
+        const formatColumn = (content, color, bgColor, bold, bgAltColor, maxLength = 0) => {
+            if (content === undefined || content === null) {
+                return '';
+            }
+            let indent = '';
+            if (typeof content === 'string') {
+                let modified;
+                if (bgAltColor !== undefined) {
+                    const match = /^([ -]+)([\S\s]*)$/.exec(content);
+                    if (match) {
+                        indent = match[1];
+                        if (bgAltColor) {
+                            try {
+                                indent = (bgAltColor[0] === '#' ? chalk.bgHex(bgAltColor) : chalk[bgAltColor])(indent);
+                            }
+                            catch {
+                            }
+                        }
+                        content = match[2];
+                        modified = true;
+                    }
+                }
+                if (!modified && !content.trim()) {
+                    return content;
+                }
+            }
+            else {
+                content = this.asString(content);
+            }
+            if (maxLength > 0) {
+                content = truncateStart(content, maxLength);
+            }
+            if (color || bgColor) {
+                try {
+                    let current = bold ? chalk.bold : chalk;
+                    if (typeof color === 'string' && color.length > 1) {
+                        current = color[0] === '#' ? current.hex(color) : current[color];
+                    }
+                    if (typeof bgColor === 'string' && bgColor.length > 1) {
+                        current = bgColor[0] === '#' ? current.bgHex(bgColor) : current[bgColor];
+                    }
+                    return indent + current(content);
+                }
+                catch {
+                }
+            }
+            return indent + (bold ? chalk.bold(content) : content);
+        };
+        if (type === 0 /* LOG_VALUE.UNKNOWN */) {
+            checkColorOptions(type, SETTINGS.unknown, options);
+        }
+        else {
+            if (type & 4096 /* LOG_VALUE.EXEC */) {
+                checkColorOptions(type, SETTINGS.exec, options);
+            }
+            else if (type & 32 /* LOG_VALUE.FILE */) {
+                checkColorOptions(type, SETTINGS.file, options);
+            }
+            else if (type & 2 /* LOG_VALUE.NODE */) {
+                if (!checkColorOptions(type, SETTINGS.node, options)) {
+                    applyStyle(options, this.LOG_STYLE_REVERSE);
+                    options.hintColor || (options.hintColor = 'yellow');
+                }
+                titleJustify = 'center';
+            }
+            else if (type & 1 /* LOG_VALUE.SYSTEM */) {
+                checkColorOptions(type, SETTINGS.system, options);
+                if (options.titleBgColor) {
+                    titleJustify = 'center';
+                }
+            }
+            if (type & 1024 /* LOG_VALUE.HTTP */) {
+                checkColorOptions(type, SETTINGS.http, options);
+            }
+            else if (type & 64 /* LOG_VALUE.CLOUD */) {
+                checkColorOptions(type, SETTINGS.cloud, options);
+            }
+            else if (type & 65536 /* LOG_VALUE.DB */) {
+                checkColorOptions(type, SETTINGS.db, options);
+            }
+            else if (type & 16 /* LOG_VALUE.WATCH */) {
+                checkColorOptions(type, SETTINGS.watch, options);
+                titleJustify = 'center';
+            }
+            else if (type & 2048 /* LOG_VALUE.IMAGE */) {
+                checkColorOptions(type, SETTINGS.image, options);
+            }
+            else if (type & 8 /* LOG_VALUE.COMPRESS */) {
+                checkColorOptions(type, SETTINGS.compress, options);
+            }
+            else if ((type & 4 /* LOG_VALUE.PROCESS */) && !options.titleColor && !checkColorOptions(type, SETTINGS.process, options)) {
+                options.titleColor = 'magenta';
+            }
+            if (type & 128 /* LOG_VALUE.TIME_ELAPSED */) {
+                if (!checkColorOptions(type, SETTINGS.time_elapsed, options)) {
+                    options.hintColor || (options.hintColor = 'yellow');
+                }
+                if (options.titleBgColor) {
+                    titleJustify = 'center';
+                }
+            }
+            else if (type & 256 /* LOG_VALUE.TIME_PROCESS */) {
+                if (options.failed) {
+                    options.messageBgColor || (options.messageBgColor = 'bgGrey');
+                }
+                else {
+                    const { color, bgColor, bold } = format.meter;
+                    if (!options.messageBgColor && !options.messageColor) {
+                        if (color) {
+                            options.messageColor = color;
+                        }
+                        if (bgColor) {
+                            options.messageBgColor = bgColor;
+                        }
+                    }
+                    if (bold) {
+                        options.messageBold ?? (options.messageBold = true);
+                    }
+                }
+            }
+        }
+        title = titleIndent !== -1 ? ' '.repeat(titleIndent || (formatTitle.width + 3)) : (0, types_1.isString)(title) ? alignColumn(title.toUpperCase(), formatTitle.width, titleJustify, 1) : '';
+        if (hint) {
+            const formatHint = format.hint;
+            let { hintColor, hintBgColor, hintBold } = options, hintWidth = formatHint.width;
+            valueWidth -= Math.min(hint.length, hintWidth) + 2;
+            if (hint.length > hintWidth && value.length + 1 < valueWidth) {
+                const offset = Math.min(valueWidth - (value.length + 1), hint.length - hintWidth);
+                hintWidth += offset;
+                valueWidth -= offset;
+            }
+            if (!hintColor && !hintBgColor) {
+                ({ color: hintColor, bgColor: hintBgColor } = formatHint);
+                hintBold ?? (hintBold = formatHint.bold);
+            }
+            value = getValue() + (coloring ? chalk.blackBright('[') + formatColumn(truncateEnd(hint, hintWidth), hintColor, hintBgColor, hintBold) + chalk.blackBright(']') : `[${truncateEnd(hint, hintWidth)}]`);
+        }
+        else if (title) {
+            value = getValue();
+        }
+        const unit = options.messageUnit ? type & 256 /* LOG_VALUE.TIME_PROCESS */ ? options.messageUnit.padStart(options.messageUnitMinWidth || 0) : options.messageUnit : '';
+        const getMessage = (m, u) => type & 256 /* LOG_VALUE.TIME_PROCESS */ && messageUnitIndent === undefined ? (u + m).trimEnd() : u ? (m + (messageUnitIndent === undefined ? ' ' : '') + u).trimStart() : m;
+        if (coloring) {
+            let { titleColor, titleBgColor, valueColor, valueBgColor, valueBold, messageWidth, messageColor, messageBgColor, messageBold } = options;
+            if (!titleColor && !titleBgColor) {
+                ({ color: titleColor, bgColor: titleBgColor } = formatTitle);
+            }
+            if (!valueColor && !valueBgColor) {
+                ({ color: valueColor, bgColor: valueBgColor } = formatValue);
+                valueBold ?? (valueBold = formatValue.bold);
+            }
+            try {
+                let v = value, i = id, m = message;
+                if (i) {
+                    const { color: sessionIdColor, bgColor: sessionIdBgColor, bold: sessionIdBold } = format.session_id;
+                    i = sessionIdColor || sessionIdBgColor || sessionIdBold ? formatColumn(i, sessionIdColor, sessionIdBgColor, sessionIdBold) : chalk.grey(i);
+                }
+                if ((m || unit) && SETTINGS.message !== false) {
+                    if (error) {
+                        m && (m = chalk.redBright('{') + chalk.bgWhite.blackBright(m) + chalk.redBright('}'));
+                    }
+                    else {
+                        const formatMessage = format.message;
+                        if (!messageColor && !messageBgColor) {
+                            ({ color: messageColor, bgColor: messageBgColor, bold: messageBold } = formatMessage);
+                            messageBold ?? (messageBold = formatMessage.bold);
+                        }
+                        messageWidth ?? (messageWidth = formatMessage.width);
+                        let u = unit;
+                        if (u) {
+                            if ((0, types_1.isObject)(SETTINGS.time_process)) {
+                                const time_process = SETTINGS.time_process;
+                                u = formatColumn(u, time_process.messageColor || 'grey', time_process.messageBgColor, time_process.messageBold);
+                            }
+                            else {
+                                u = formatColumn(u, 'grey');
+                            }
+                        }
+                        m = formatColumn(m, messageColor, messageBgColor, messageBold, messageUnitIndent !== undefined ? format.meter.bgAltColor : undefined, messageWidth);
+                        m = chalk.blackBright('(') + getMessage(m, u) + chalk.blackBright(')');
+                    }
+                }
+                else {
+                    if (!i) {
+                        v = v.trim();
+                    }
+                    m = '';
+                }
+                output = (titleIndent !== -1 ? title : title ? formatColumn(title, titleColor || 'green', titleBgColor, (options.titleBold || formatTitle.bold) ?? false) + chalk.blackBright(':') + ' ' : '') + formatColumn(v, valueColor, valueBgColor, valueBold) + (i ? i : ' ') + m;
+            }
+            catch {
+            }
+        }
+        if (!output) {
+            const m = truncateStart(this.asString(message), options.messageWidth ?? format.message.width);
+            output = (titleIndent !== -1 ? title : title ? title + ': ' : '') + value + (id ? id : ' ') + (m && SETTINGS.message !== false ? (error ? '{' : '(') + getMessage(m, unit) + (error ? '}' : ')') : '');
+        }
+        if (broadcastId) {
+            if (BROADCAST_OUT) {
+                try {
+                    options = { ...options, broadcastId, timeStamp: getTimeStamp(options, false) };
+                    // @ts-ignore
+                    if (BROADCAST_OUT["__cjs__" /* INTERNAL.CJS */]) {
+                        BROADCAST_OUT(output, options);
+                    }
+                    else {
+                        BROADCAST_OUT.apply(VALUES["node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */] ? process : null, VALUES["node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */] ? [output, options, require] : [output, options]);
+                    }
+                }
+                catch {
+                }
+            }
+            return;
+        }
+        const newline = options.newline;
+        if (!newline) {
+            LOG_EMPTYLINE = false;
+        }
+        else {
+            const lines = (newline === true ? 1 : Math.abs(newline)) - (LOG_EMPTYLINE ? 1 : 0);
+            if (lines > 0) {
+                PROCESS_STDOUT.write(lines === 1 ? '\n' : '\n'.repeat(lines));
+                LOG_EMPTYLINE = true;
+            }
+        }
+        if (type & 512 /* LOG_VALUE.FAIL */) {
+            process.stderr.write((!LOG_NEWLINE ? '\n' : '') + output + '\n');
+        }
+        else if (typeof options.progressBar === 'boolean' && typeof PROCESS_STDOUT.clearLine === 'function') {
+            if (!LOG_NEWLINE && !options.progressBar) {
+                PROCESS_STDOUT.write('\n' + output);
+            }
+            else {
+                PROCESS_STDOUT.clearLine(0);
+                PROCESS_STDOUT.cursorTo(0);
+                PROCESS_STDOUT.write(output);
+            }
+            LOG_NEWLINE = false;
+        }
+        else {
+            writeLine(output);
+        }
+        if (typeof newline === 'number' && newline < 0) {
+            PROCESS_STDOUT.write('\n'.repeat(Math.abs(newline)));
+            LOG_EMPTYLINE = true;
+        }
+    }
+    static writeFail(value, message, options) {
+        let type;
+        if ((0, types_1.isObject)(options)) {
+            ({ type } = options);
+        }
+        else {
+            if (typeof options === 'number') {
+                type = options;
+            }
+            options = {};
+        }
+        this.formatMessage(((type || 1 /* LOG_VALUE.SYSTEM */) | 512 /* LOG_VALUE.FAIL */), "FAIL!" /* ERR_MESSAGE.FAIL */, value, message, applyStyle(options, this.LOG_STYLE_FAIL));
+    }
+    static parseFunction(value, absolute, sync = true) {
+        let context, requireExt, external;
+        if ((0, types_1.isObject)(absolute)) {
+            ({ context, requireExt, external, absolute, sync = true } = absolute);
+        }
+        if (requireExt === undefined || requireExt === true) {
+            requireExt = VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */];
+        }
+        let result = (0, types_1.asFunction)(value, sync);
+        if (!result && (0, types_1.isString)(value)) {
+            let location = value.trim(), pathname;
+            if (location.startsWith('npm:')) {
+                location = location.substring(4);
+            }
+            else if (pathname = absolute && path.isAbsolute(location) ? location : this.fromLocalPath(location)) {
+                if (requireExt && VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] && hasString(requireExt, getExtension(pathname))) {
+                    try {
+                        result = checkFunction(require(pathname));
+                    }
+                    catch {
+                    }
+                }
+                if (!result) {
+                    try {
+                        result = (0, types_1.asFunction)(fs.readFileSync(pathname, 'utf-8'), sync);
+                    }
+                    catch (err) {
+                        this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, value], err, 32 /* LOG_VALUE.FILE */);
+                    }
+                }
+            }
+            if (external && !pathname && VALUES["node.require.npm" /* KEY_NAME.NODE_REQUIRE_NPM */] && location.length <= 214 && /^(?:@(?:[a-z\d-][a-z\d-._]*\/)+)?[a-z\d-][a-z\d-._]*$/.test(location)) {
+                try {
+                    // @ts-ignore
+                    result = checkFunction(require(types_1.IMPORT_MAP[location] || location));
+                }
+                catch {
+                }
+            }
+        }
+        if (result) {
+            if (context !== undefined) {
+                result.bind(context);
+            }
+            return result;
+        }
+        return null;
+    }
+    static asString(value, cacheKey) {
+        if ((0, types_1.isEmpty)(value)) {
+            return '';
+        }
+        switch (typeof value) {
+            case 'string':
+                return value;
+            case 'object':
+                if (value.constructor === Object || Object.getPrototypeOf(value) === null) {
+                    if (Object.keys(value).length === 0) {
+                        return '';
+                    }
+                }
+                else if (!Array.isArray(value)) {
+                    if (value instanceof Error) {
+                        return value.message;
+                    }
+                    if (value instanceof Date) {
+                        return value.toJSON();
+                    }
+                    if (Buffer.isBuffer(value) || value instanceof URL) {
+                        return value.toString();
+                    }
+                }
+                try {
+                    const content = JSON.stringify(value);
+                    if (content && content !== '{}') {
+                        return content;
+                    }
+                }
+                catch {
+                }
+                if (cacheKey) {
+                    break;
+                }
+            default:
+                try {
+                    return value.toString();
+                }
+                catch {
+                }
+                break;
+        }
+        if (cacheKey === 'throws') {
+            throw new Error("Not able to cache" /* ERR_MESSAGE.NOT_CACHEABLE */);
+        }
+        return cacheKey ? (0, types_1.generateUUID)() : '';
+    }
+    static asHash(data, algorithm, minLength = 0) {
+        let options;
+        if (typeof minLength !== 'number') {
+            options = minLength;
+            minLength = 0;
+        }
+        if (typeof algorithm === 'number') {
+            minLength = algorithm;
+            algorithm = '';
+        }
+        else if ((0, types_1.isObject)(algorithm)) {
+            options = algorithm;
+            algorithm = '';
+        }
+        let digest;
+        if (options) {
+            options = { ...options };
+            if ('minLength' in options) {
+                minLength = options.minLength;
+                delete options.minLength;
+            }
+            if ('algorithm' in options) {
+                algorithm = options.algorithm;
+                delete options.algorithm;
+            }
+            if ('digest' in options) {
+                digest = options.digest;
+                delete options.digest;
+            }
+        }
+        if (minLength > 0 && typeof data === 'string' && data.length > minLength) {
+            return data;
+        }
+        try {
+            return crypto.createHash(algorithm || 'sha256', options).update(data).digest(digest || 'hex');
+        }
+        catch {
+            return '';
+        }
+    }
+    static toPosix(value, filename, normalize) {
+        if (typeof filename === 'boolean') {
+            normalize = filename;
+            filename = undefined;
+        }
+        if (typeof value === 'string') {
+            let pathname = value.trim(), convert = true;
+            if (normalize) {
+                pathname = path.normalize(pathname);
+                convert = PLATFORM_WIN32;
+            }
+            if (convert) {
+                pathname = pathname.replace(/(?:^\\|\\+)/g, '/');
+            }
+            if (pathname = pathname.replace(/\/+$/, '')) {
+                if (normalize && PLATFORM_WIN32) {
+                    const match = /^([A-Z]):\//.exec(pathname);
+                    if (match) {
+                        pathname = match[1].toLowerCase() + pathname.substring(1);
+                    }
+                }
+                return pathname + (filename ? '/' + filename : '');
+            }
+        }
+        return filename || '';
+    }
+    static isURL(value, ...exclude) {
+        const match = /^([a-z][a-z\d+-.]*):\/\//i.exec(value);
+        return !!match && (exclude.length === 0 || !exclude.includes(match[1].toLowerCase()));
+    }
+    static isFile(value, type) {
+        if (!type) {
+            value = asFile(value);
+            return !!value && this.isPath(value, true);
+        }
+        if (typeof value === 'string') {
+            switch (type) {
+                case 'http':
+                    return /^http:\/\/[^/]/i.test(value);
+                case 'https':
+                    return /^https:\/\/[^/]/i.test(value);
+                case 'http/s':
+                    return /^https?:\/\/[^/]/i.test(value);
+                case 'unc':
+                    return /^(?:\\\\|\/\/)[\w.-]+[\\/][\w-]+\$?[\\/][^\n]*?[^\\/]$/.test(value);
+                case 'ftp':
+                    return /^ftp:\/\/[^/]/i.test(value);
+                case 'sftp':
+                    return /^sftp:\/\/[^/]/i.test(value);
+                case 's/ftp':
+                    return /^s?ftp:\/\/[^/]/i.test(value);
+                case 'torrent':
+                    return REGEXP_TORRENT.test(value);
+            }
+        }
+        else if (value instanceof URL) {
+            switch (type) {
+                case 'http':
+                    return value.protocol === 'http:';
+                case 'https':
+                    return value.protocol === 'https:';
+                case 'http/s':
+                    return value.protocol === 'http:' || value.protocol === 'https:';
+                case 'unc':
+                    return /^(?:\\\\|\/\/)[\w.-]+[\\/][\w-]+\$?[\\/][^\n]*?[^\\/]$/.test(value.toString());
+                case 'ftp':
+                    return value.protocol === 'ftp:';
+                case 'sftp':
+                    return value.protocol === 'sftp:';
+                case 's/ftp':
+                    return value.protocol === 'ftp:' || value.protocol === 'sftp:';
+                case 'torrent':
+                    return REGEXP_TORRENT.test(value.toString());
+            }
+        }
+        return false;
+    }
+    static isDir(value) {
+        try {
+            return fs.statSync(value).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    static isPath(value, type) {
+        try {
+            if (!type) {
+                return fs.existsSync(value);
+            }
+            switch (type) {
+                case true:
+                    return fs.statSync(value).isFile();
+                case 'unc-exists':
+                    if (!fs.existsSync(value)) {
+                        return false;
+                    }
+                case 'unc':
+                    return /^(?:\\\\|\/\/)[\w.-]+[\\/][\w-]+\$?(?:[\\/]?|[\\/][^\n]+)$/.test(asFile(value));
+            }
+        }
+        catch (err) {
+            return !type && this.isErrorCode(err, 'EBUSY', 'EPERM');
+        }
+    }
+    static isErrorCode(err, ...code) {
+        if (err instanceof Error) {
+            const value = err.code;
+            return typeof value === 'string' && code.includes(value);
+        }
+        return false;
+    }
+    static resolveFile(value) {
+        if (isFileURL(value = value instanceof URL ? value.toString() : value.trim())) {
+            try {
+                return url.fileURLToPath(value);
+            }
+            catch {
+            }
+            return '';
+        }
+        if (/^\\\\\?\\[A-Za-z]:\\/.test(value)) {
+            return process.platform === 'win32' && !/\\\\|\\\.+\\|\\[^\n]+?\.+\\/.test(value = value.substring(4)) ? value : '';
+        }
+        return this.fromLocalPath(value) || value;
+    }
+    static resolvePath(value, base) {
+        try {
+            if (this.isURL(value = value.trim())) {
+                return isFileURL(value) ? url.fileURLToPath(value) : new URL(value).href;
+            }
+            if (base instanceof URL || this.isURL(base)) {
+                return new URL(value, base).href;
+            }
+            if (typeof base === 'string' && path.isAbsolute(base)) {
+                return path.resolve(base, value);
+            }
+        }
+        catch {
+        }
+        return '';
+    }
+    static joinPath(...values) {
+        let normalize;
+        if (typeof values[values.length - 1] === 'boolean') {
+            normalize = values.pop();
+        }
+        const paths = values.map(item => typeof item === 'string' ? item.trim() : '').filter(item => item).map(value => this.toPosix(value, normalize));
+        let result = paths[0] || '';
+        for (let i = 1; i < paths.length; ++i) {
+            const trailing = paths[i];
+            result += (trailing[0] !== '/' && result[result.length - 1] !== '/' ? '/' : '') + trailing;
+        }
+        return result;
+    }
+    static normalizePath(value, flags = 0) {
+        if (typeof value === 'string') {
+            if (typeof flags === 'boolean') {
+                flags = flags ? 2 : 0;
+            }
+            let result = value.trim();
+            result = flags & 1 ? path.resolve(result) : path.normalize(result);
+            if ((flags & 3) && result.length) {
+                result = ensureDir(result);
+            }
+            return (flags & 4) && PLATFORM_WIN32 ? this.toPosix(result) : result;
+        }
+        return '';
+    }
+    static fromLocalPath(value) {
+        const ch = value[0];
+        if (ch === '.' && /^\.{1,2}[\\/][^\\/]/.test(value)) {
+            return path.join(PROCESS_CWD, value);
+        }
+        if (ch === '~' && value[1] === '/') {
+            return VALUES["permission.home_read" /* KEY_NAME.PERMISSION_HOMEREAD */] ? path.join(OS_HOMEDIR, value.substring(2)) : '';
+        }
+        try {
+            if (fs.existsSync(value = path.join(PROCESS_CWD, value))) {
+                return value;
+            }
+        }
+        catch {
+        }
+        return '';
+    }
+    static createDir(value, overwrite) {
+        const outDir = sanitizePath(value = asFile(value));
+        if (outDir) {
+            try {
+                const stat = fs.statSync(outDir);
+                if (stat.isDirectory()) {
+                    return true;
+                }
+                if (overwrite && (stat.isFile() || stat.isSymbolicLink())) {
+                    try {
+                        fs.unlinkSync(outDir);
+                    }
+                    catch {
+                        this.formatMessage(32 /* LOG_VALUE.FILE */, 'WARN', "Unable to overwrite file" /* ERR_MESSAGE.OVERWRITE_FILE */, value, { ...this.LOG_STYLE_WARN });
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (err) {
+                if (this.isErrorCode(err, 'EBUSY', 'EPERM')) {
+                    return false;
+                }
+            }
+            try {
+                return tryCreateDir(outDir);
+            }
+            catch (err) {
+                this.writeFail(["Unable to create directory" /* ERR_MESSAGE.CREATE_DIRECTORY */, value], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        return false;
+    }
+    static removeDir(value, empty = false, recursive = true) {
+        if (value = asFile(value)) {
+            try {
+                if (typeof empty === 'number' && empty <= 0) {
+                    empty = true;
+                }
+                if (this.isDir(value)) {
+                    return tryRemoveDir(value, empty, !!recursive).length === 0;
+                }
+                if (!fs.existsSync(value)) {
+                    if (empty && typeof empty !== 'number') {
+                        this.createDir(value);
+                    }
+                    return true;
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to remove directory" /* ERR_MESSAGE.REMOVE_DIRECTORY */, value], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        return false;
+    }
+    static copyDir(src, dest, move, recursive = true) {
+        const srcOut = sanitizePath(asFile(src));
+        if (!srcOut || !this.isDir(srcOut)) {
+            return Promise.reject(errorDirectory(asFile(src) || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+        }
+        const destOut = sanitizePath(asFile(dest));
+        if (!destOut || !this.createDir(destOut)) {
+            return Promise.reject(errorDirectory(asFile(dest) || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+        }
+        let symFile, symDir, ignoreFile, ignoreDir, silent, overwrite;
+        if ((0, types_1.isObject)(move)) {
+            ({ move, recursive = true, symFile, symDir, ignoreFile, ignoreDir, silent, overwrite } = move);
+        }
+        return new Promise(resolve => {
+            const tasks = [];
+            const success = [];
+            const failed = [];
+            const ignored = [];
+            const methodName = move ? 'rename' : 'copyFile';
+            const srcFound = [];
+            const symFound = [];
+            (function recurse(paths, depth) {
+                const srcDir = path.join(srcOut, ...paths);
+                const destDir = path.join(destOut, ...paths);
+                srcFound.push(srcDir);
+                if (this.createDir(destDir)) {
+                    try {
+                        fs.readdirSync(srcDir, { withFileTypes: true }).forEach(file => {
+                            const name = file.name;
+                            const destPath = path.join(destDir, name);
+                            let srcPath = path.join(srcDir, name), isDir = false, isFile = file.isFile() ? 1 : 0;
+                            const ignore = () => !ignored.includes(srcPath) && ignored.push(srcPath);
+                            if (file.isSymbolicLink()) {
+                                const previous = symFound.includes(srcPath);
+                                symFound.push(srcPath);
+                                try {
+                                    const realPath = fs.realpathSync(srcPath);
+                                    const stat = fs.statSync(realPath);
+                                    if (stat.isFile()) {
+                                        if (symFile === false || !(fs.existsSync(destPath) && !fs.statSync(destPath).isFile())) {
+                                            return ignore();
+                                        }
+                                        srcPath = realPath;
+                                        isFile = 2;
+                                    }
+                                    else {
+                                        if (symDir !== true || previous || !stat.isDirectory()) {
+                                            return ignore();
+                                        }
+                                        isFile = 0;
+                                        isDir = true;
+                                    }
+                                }
+                                catch {
+                                    return ignore();
+                                }
+                            }
+                            if (isFile) {
+                                if (ignoreFile?.test(name)) {
+                                    return ignore();
+                                }
+                                if (overwrite === false) {
+                                    try {
+                                        if (fs.existsSync(destPath)) {
+                                            return ignore();
+                                        }
+                                    }
+                                    catch {
+                                        return ignore();
+                                    }
+                                }
+                                tasks.push(fs.promises[isFile === 2 ? 'copyFile' : methodName](srcPath, destPath)
+                                    .then(() => {
+                                    success.push(destPath);
+                                })
+                                    .catch(err => {
+                                    failed.push(srcPath);
+                                    if (!silent) {
+                                        this.writeFail([move ? "Unable to move file" /* ERR_MESSAGE.MOVE_FILE */ : "Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, path.basename(srcPath)], err, 32 /* LOG_VALUE.FILE */);
+                                    }
+                                }));
+                            }
+                            else if (depth > 0 && (isDir || file.isDirectory())) {
+                                if (ignoreDir?.test(name)) {
+                                    return ignore();
+                                }
+                                recurse.call(this, paths.concat(name), depth - 1);
+                            }
+                        });
+                    }
+                    catch (err) {
+                        failed.push(srcDir);
+                        if (!silent) {
+                            this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, path.basename(srcDir)], err, 32 /* LOG_VALUE.FILE */);
+                        }
+                    }
+                }
+                else {
+                    failed.push(srcDir);
+                }
+            }).call(this, [], !recursive ? 0 : typeof recursive === 'number' ? recursive : Infinity);
+            Promise.all(tasks).then(() => {
+                if (move) {
+                    const remaining = failed.slice(0);
+                    for (const sym of symFound) {
+                        try {
+                            fs.realpathSync(sym);
+                        }
+                        catch {
+                            fs.unlinkSync(sym);
+                        }
+                    }
+                    for (const srcDir of srcFound.reverse()) {
+                        const dirName = ensureDir(srcDir);
+                        if (!remaining.includes(srcDir) && !remaining.some(file => file.startsWith(dirName))) {
+                            try {
+                                fs.rmdirSync(srcDir);
+                            }
+                            catch {
+                                failed.push(srcDir);
+                                remaining.push(srcDir);
+                            }
+                        }
+                    }
+                }
+                resolve({ success, failed, ignored });
+            });
+        });
+    }
+    static renameFile(src, dest, throws = true) {
+        try {
+            fs.renameSync(src, dest);
+            return true;
+        }
+        catch (err) {
+            if (this.isErrorCode(err, 'EXDEV')) {
+                let copied = false;
+                try {
+                    fs.copyFileSync(src, dest);
+                    copied = true;
+                    fs.unlinkSync(src);
+                    return true;
+                }
+                catch (error) {
+                    if (copied) {
+                        this.formatMessage(32 /* LOG_VALUE.FILE */, 'WARN', ["Unable to delete file" /* ERR_MESSAGE.DELETE_FILE */, path.basename(src instanceof URL ? url.fileURLToPath(src) : src)], error, { ...this.LOG_STYLE_WARN });
+                        throws = false;
+                    }
+                }
+            }
+            if (throws) {
+                throw err;
+            }
+        }
+        return false;
+    }
+    static readText(value, encoding, cache) {
+        if (typeof encoding === 'boolean') {
+            cache = encoding;
+            encoding = undefined;
+        }
+        const src = sanitizePath(asFile(value));
+        if (src && this.isPath(src, true)) {
+            let result;
+            if (cache && (result = getCacheItem(CACHE_READTEXT, src))) {
+                return result;
+            }
+            try {
+                result = fs.readFileSync(value, (0, types_1.getEncoding)(encoding));
+                if (cache && result) {
+                    addCacheItem(CACHE_READTEXT, src, result);
+                }
+                return result;
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(src)], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        return '';
+    }
+    static readBuffer(value, cache) {
+        const src = sanitizePath(asFile(value));
+        if (src && this.isPath(src, true)) {
+            let result;
+            if (cache && (result = getCacheItem(CACHE_READBUFFER, src))) {
+                return result;
+            }
+            try {
+                result = fs.readFileSync(value);
+                if (cache && result) {
+                    addCacheItem(CACHE_READBUFFER, src, result);
+                }
+                return result;
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(src)], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        return null;
+    }
+    static resolveMime(data) {
+        return typeof data === 'string' ? filetype.fromFile(data) : filetype.fromBuffer(data);
+    }
+    static lookupMime(value, extension) {
+        return (extension ? mime.extension(value) : mime.lookup(value)) || '';
+    }
+    static initCpuUsage(instance) {
+        if (!VALUES["node.process.cpu_usage" /* KEY_NAME.NODE_PROCESS_CPUUSAGE */]) {
+            return { user: 0, system: 0 };
+        }
+        const result = process.cpuUsage();
+        CACHE_CPU.set(result, getCpuTimes());
+        if (instance) {
+            CACHE_CPUHOST.set(instance, result);
+        }
+        return result;
+    }
+    static getCpuUsage(start, format) {
+        if (VALUES["node.process.cpu_usage" /* KEY_NAME.NODE_PROCESS_CPUUSAGE */]) {
+            let value = CACHE_CPU.get(start);
+            if (value === undefined) {
+                CACHE_CPU.set(start, getCpuTimes());
+            }
+            else if ((value = getCpuTimes() - value) >= 0) {
+                let result = 0;
+                if (value > 0) {
+                    const { user, system } = process.cpuUsage(start);
+                    const usage = user + system;
+                    result = usage > 0 ? Math.min(usage / value, 1) * (typeof SETTINGS.process === 'object' && SETTINGS.process.cpu_single_core ? 1 : CPU_CORETOTAL) : 0;
+                }
+                return format ? formatPercent(result) : result;
+            }
+        }
+        return format ? '' : 0;
+    }
+    static getMemUsage(format) {
+        if (!VALUES["node.process.memory_usage" /* KEY_NAME.NODE_PROCESS_MEMORYUSAGE */]) {
+            return format ? '' : 0;
+        }
+        const usage = process.memoryUsage();
+        let result = 0;
+        for (const name in usage) {
+            if (name !== 'heapUsed') {
+                result += usage[name];
+            }
+        }
+        if (typeof format === 'string') {
+            const unit = format.toUpperCase();
+            switch (unit) {
+                case 'B':
+                case 'KB':
+                    return (0, types_1.formatSize)(result, { unit, decimalPlaces: 0 });
+                case 'MB':
+                    return (0, types_1.formatSize)(result, { unit, decimalPlaces: 1 });
+                case 'GB':
+                case 'TB':
+                case 'PB':
+                    return (0, types_1.formatSize)(result, { unit });
+            }
+        }
+        return format ? formatPercent(result / MEM_TOTAL) : result;
+    }
+    static formatCpuMem(start, all) {
+        let cpu, cpu_bar, cpu_single_core, mem, mem_format;
+        if (typeof SETTINGS.process === 'object') {
+            ({ cpu, cpu_bar, cpu_single_core, mem, mem_format } = SETTINGS.process);
+        }
+        let result = '';
+        if (cpu || all) {
+            let usage = this.getCpuUsage(start, !cpu_bar);
+            if (usage) {
+                if (typeof usage === 'number') {
+                    if (!cpu_single_core) {
+                        usage /= CPU_CORETOTAL;
+                    }
+                    if (usage + 0.005 /* CPU_MEM.BAR_100_OFFSET */ >= 1) {
+                        usage = 1;
+                    }
+                    let bar = 20 /* CPU_MEM.BAR_LENGTH */, red = 0.9 /* CPU_MEM.BAR_RED */, yellow = 0.75 /* CPU_MEM.BAR_YELLOW */;
+                    if (typeof cpu_bar === 'number') {
+                        bar = cpu_bar;
+                    }
+                    else if (Array.isArray(cpu_bar) && cpu_bar[0] >= 10 /* CPU_MEM.BAR_MIN_LENGTH */) {
+                        let r, y;
+                        [bar, r = 0.9 /* CPU_MEM.BAR_RED */, y = 0.75 /* CPU_MEM.BAR_YELLOW */] = cpu_bar;
+                        if (r > 0 && r < 1 && y > 0 && y < 1 && y < r) {
+                            red = r;
+                            yellow = y;
+                        }
+                    }
+                    const unit = Math.max(bar, 10 /* CPU_MEM.BAR_MIN_LENGTH */);
+                    const length = Math.floor(usage * unit);
+                    const hint = usage === 1 ? "MAX" /* CPU_MEM.BAR_100 */ : formatPercent(usage, 2);
+                    result += chalk[usage >= red ? 'bgRed' : usage >= yellow ? 'bgYellow' : 'bgBlue'].white(':'.repeat(length)) + chalk.bgGrey.white(':'.repeat(unit - length)) + (hint ? chalk.bgWhite.grey(` ${hint} `) : '');
+                }
+                else {
+                    result += usage + ' CPU' + (!cpu_single_core ? '/' + CPU_CORETOTAL : '');
+                }
+            }
+        }
+        if (mem || all) {
+            const usage = this.getMemUsage(mem_format || true);
+            if (usage) {
+                result += (result ? ' ' : '') + usage + ' MEM';
+            }
+        }
+        return result;
+    }
+    static getPackageVersion(value, unstable, startDir) {
+        if (typeof unstable === 'string') {
+            startDir = unstable;
+            unstable = false;
+        }
+        let rootPackage;
+        if (Array.isArray(value)) {
+            [rootPackage, value] = value;
+        }
+        const folders = [PROCESS_CWD];
+        if (startDir && withinDir(startDir = path.normalize(startDir), PROCESS_CWD)) {
+            startDir = startDir.replace(/[\\/]+$/, '');
+            let i = -1, j = PROCESS_CWD.length + 1;
+            while ((i = startDir.indexOf(path.sep, j)) !== -1) {
+                const current = startDir.substring(0, i);
+                if (!current.endsWith(path.sep + 'node_modules')) {
+                    folders.push(current);
+                }
+                j = i + 1;
+            }
+            folders.push(startDir);
+            folders.reverse();
+        }
+        for (const folder of folders) {
+            try {
+                const pkg = path.join(folder, `node_modules/${value}/package.json`);
+                if (fs.existsSync(pkg)) {
+                    const { name, version } = JSON.parse(fs.readFileSync(pkg, 'utf-8'));
+                    if (name === value && typeof version === 'string') {
+                        return version.trim();
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        const latest = (result) => {
+            if (result.length > 1) {
+                result.sort((a, b) => {
+                    const c = a.split('.');
+                    const d = b.split('.');
+                    if (!unstable) {
+                        const g = c.some(e => isNaN(+e));
+                        const h = d.some(f => isNaN(+f));
+                        if (g && !h) {
+                            return 1;
+                        }
+                        if (h && !g) {
+                            return -1;
+                        }
+                    }
+                    return (function recurse() {
+                        const e = c.shift();
+                        const f = d.shift();
+                        if (!e || !f) {
+                            return 0;
+                        }
+                        if (e !== f) {
+                            const g = parseInt(f) - parseInt(e);
+                            if (g === 0) {
+                                if (isNaN(+e) && !isNaN(+f)) {
+                                    return 1;
+                                }
+                                if (isNaN(+f) && !isNaN(+e)) {
+                                    return -1;
+                                }
+                                return e < f ? 1 : -1;
+                            }
+                            return g;
+                        }
+                        return recurse();
+                    })();
+                });
+            }
+            return result[0];
+        };
+        if (PNPM_VER) {
+            const result = [];
+            const pattern = new RegExp(`/${(0, types_1.escapePattern)(value)}/([^:]+):`, 'g');
+            let match;
+            while (match = pattern.exec(PNPM_VER)) {
+                result.push(match[1]);
+            }
+            if (result.length) {
+                return latest(result);
+            }
+        }
+        if (YARN_VER) {
+            folders.forEach((folder, index) => {
+                folder = ensureDir(folder).replace(path.sep + 'node_modules' + path.sep, path.sep + 'packages' + path.sep);
+                folders[index] = PLATFORM_WIN32 ? folder.toLowerCase() : folder;
+            });
+            try {
+                const result = [];
+                let treeRoots = YARN_VER.getDependencyTreeRoots(), version;
+                if (rootPackage) {
+                    treeRoots = treeRoots.filter(item => item.name === rootPackage);
+                }
+                const getVersion = (item) => {
+                    const dependency = item.packageDependencies.get(value);
+                    if (typeof dependency === 'string') {
+                        const pkg = dependency.split('npm:');
+                        if (pkg.length > 1) {
+                            return pkg.pop();
+                        }
+                    }
+                };
+                for (const folder of folders) {
+                    for (const locator of treeRoots) {
+                        const item = YARN_VER.getPackageInformation(locator);
+                        if (item && (PLATFORM_WIN32 ? item.packageLocation.toLowerCase() : item.packageLocation) === folder && (version = getVersion(item))) {
+                            return version;
+                        }
+                    }
+                }
+                for (const locator of treeRoots) {
+                    const item = YARN_VER.getPackageInformation(locator);
+                    if (item && (version = getVersion(item))) {
+                        result.push(version);
+                    }
+                }
+                if (result.length) {
+                    return latest(result);
+                }
+            }
+            catch {
+            }
+        }
+        return '0.0.0';
+    }
+    static checkSemVer(name, min = 0, max = Infinity, unstable, startDir) {
+        if ((0, types_1.isObject)(min)) {
+            ({ min = 0, max = Infinity, unstable, startDir } = min);
+        }
+        else if ((0, types_1.isObject)(unstable)) {
+            ({ unstable, startDir } = unstable);
+        }
+        if (typeof min === 'number' && Math.floor(min) !== min) {
+            min = min.toString();
+        }
+        if (typeof max === 'number' && Math.floor(max) !== max) {
+            max = max.toString();
+        }
+        const minVersion = typeof min === 'string' ? min.split('.').map(ver => parseInt(ver)) : [min];
+        let maxVersion, maxRange;
+        if (typeof max === 'string') {
+            maxVersion = max.split('.').map(ver => parseInt(ver));
+        }
+        else if (max === Infinity) {
+            maxVersion = [Infinity];
+        }
+        else {
+            maxVersion = [max - 1];
+            maxRange = true;
+        }
+        let version = this.getPackageVersion(name, unstable, startDir);
+        if (version === '0.0.0') {
+            return false;
+        }
+        version = version.split('.').map(ver => parseInt(ver));
+        for (let i = 0, length = Math.max(version.length, minVersion.length), lower = false, upper = false; i < length; ++i) {
+            const ver = version[i] || 0;
+            min = minVersion[i] || 0;
+            max = maxVersion[i] || (maxRange ? Infinity : 0);
+            if (!lower) {
+                if (ver < min) {
+                    return false;
+                }
+                lower = ver > min;
+            }
+            if (!upper) {
+                if (ver > max) {
+                    return false;
+                }
+                upper = ver < max;
+            }
+        }
+        return true;
+    }
+    static sanitizeCmd(value) {
+        if (value.indexOf(' ') !== -1) {
+            return PLATFORM_WIN32 ? wrapQuote(value) : value.replace(/[ ]/g, '\\ ');
+        }
+        return value;
+    }
+    static sanitizeArgs(values, doubleQuote) {
+        const result = typeof values === 'string' ? [values] : values;
+        const pattern = /^(["'])(.*)\1$/;
+        const sanitize = (value) => value.replace(REGEXP_SHELLVAL, capture => (capture === '$' || capture === '`' ? '\\' : '') + '\\' + capture);
+        for (let i = 0; i < result.length; ++i) {
+            let value = result[i].trim(), leading = '';
+            if (value !== '--') {
+                const opt = REGEXP_SHELLOPT.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 = pattern.exec(value);
+                    if (PLATFORM_WIN32) {
+                        if (quoted) {
+                            if (quoted[1] === '"') {
+                                result[i] = leading + value;
+                                continue;
+                            }
+                            value = quoted[2];
+                        }
+                        if (value.indexOf(' ') !== -1) {
+                            value = wrapQuote(value);
+                        }
+                    }
+                    else {
+                        let type = doubleQuote;
+                        if (quoted) {
+                            if (quoted[1] === "'") {
+                                result[i] = leading + value;
+                                continue;
+                            }
+                            value = quoted[2];
+                            type = true;
+                        }
+                        if (REGEXP_SHELLVAL.test(value)) {
+                            if (type) {
+                                value = '"' + sanitize(value) + '"';
+                            }
+                            else {
+                                value = "'" + value.replace(/'/g, "'\\''") + "'";
+                            }
+                        }
+                    }
+                }
+                else if (opt) {
+                    leading = leading.trim();
+                    if (!PLATFORM_WIN32 && leading.length > 2 && leading[1] !== '-') {
+                        leading = sanitize(leading);
+                    }
+                }
+            }
+            result[i] = leading + value;
+        }
+        return (typeof values === 'string' ? result[0] : result);
+    }
+    static purgeMemory(percent = 1, limit = 0) {
+        if (typeof limit === 'boolean') {
+            limit = 0;
+        }
+        let result = 0;
+        if (limit === 0 || limit >= CACHE_TOTAL) {
+            if (percent >= 1) {
+                result += CACHE_READTEXT.size + CACHE_READBUFFER.size + CACHE_READCJS.size;
+                CACHE_READTEXT.clear();
+                CACHE_READBUFFER.clear();
+                CACHE_READCJS.clear();
+                CACHE_EXEC = new WeakMap();
+                CACHE_CPU = new WeakMap();
+                CACHE_CPUHOST = new WeakMap();
+                (0, types_1.purgeMemory)();
+                CACHE_TOTAL = 0;
+            }
+            else if (percent > 0) {
+                const stored = [];
+                for (const map of [CACHE_READTEXT, CACHE_READBUFFER, CACHE_READCJS]) {
+                    for (const [key, value] of map) {
+                        stored.push([map, key, value[0]]);
+                    }
+                }
+                stored.sort((a, b) => a[2] - b[2]);
+                result = Math.floor(stored.length * percent);
+                for (let i = 0; i < result; ++i) {
+                    const [map, key] = stored[i];
+                    map.delete(key);
+                }
+                CACHE_TOTAL = stored.length - result;
+            }
+        }
+        return Promise.resolve(result);
+    }
+    static canWrite(name) {
+        switch (name) {
+            case 'temp':
+                return VALUES["temp.write" /* KEY_NAME.TEMP_WRITE */];
+            case 'home':
+                return VALUES["permission.home_write" /* KEY_NAME.PERMISSION_HOMEWRITE */];
+            default:
+                return false;
+        }
+    }
+    static loadSettings(settings, password) {
+        var _h;
+        const current = VALUES["process.password" /* KEY_NAME.PROCESS_PASSWORD */];
+        if (current) {
+            const proc = settings.process || {};
+            if (!password && !(password = proc.password)) {
+                return false;
+            }
+            const algorithm = VALUES["process.cipher.algorithm" /* KEY_NAME.PROCESS_CIPHER_ALGORITHM */];
+            if (algorithm) {
+                password = encryptMessage(password, proc.cipher, algorithm);
+            }
+            if (password !== current) {
+                return false;
+            }
+        }
+        else if ((0, types_1.isString)(password)) {
+            VALUES["process.password" /* KEY_NAME.PROCESS_PASSWORD */] = encryptMessage(password, settings.process?.cipher);
+        }
+        const { temp, node, permission, memory, error, logger } = settings;
+        if ((0, types_1.isPlainObject)(node)) {
+            const { process: proc, require: req } = node;
+            if ((0, types_1.isPlainObject)(proc)) {
+                const { cpu_usage, memory_usage, inline } = proc;
+                if (typeof cpu_usage === 'boolean') {
+                    VALUES["node.process.cpu_usage" /* KEY_NAME.NODE_PROCESS_CPUUSAGE */] = cpu_usage;
+                }
+                if (typeof memory_usage === 'boolean') {
+                    VALUES["node.process.memory_usage" /* KEY_NAME.NODE_PROCESS_MEMORYUSAGE */] = memory_usage;
+                }
+                if (typeof inline === 'boolean') {
+                    VALUES["node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */] = inline;
+                }
+            }
+            if ((0, types_1.isPlainObject)(req)) {
+                const { ext, npm, inline } = req;
+                if (!ext) {
+                    VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] = '';
+                }
+                else if (typeof ext === 'string') {
+                    VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] = ext.trim().toLowerCase();
+                }
+                else if (Array.isArray(ext)) {
+                    const items = ext.map(value => (0, types_1.isString)(value) ? value.trim().toLowerCase() : '').filter(value => value);
+                    VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] = items.length ? items : '';
+                }
+                else {
+                    VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] = 'cjs';
+                }
+                if (typeof npm === 'boolean') {
+                    VALUES["node.require.npm" /* KEY_NAME.NODE_REQUIRE_NPM */] = npm;
+                }
+                if (typeof inline === 'boolean') {
+                    VALUES["node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */] = inline;
+                }
+            }
+        }
+        if ((0, types_1.isPlainObject)(settings.process)) {
+            const { env, cipher, password: pwd } = settings.process;
+            if (env && typeof env.apply === 'boolean') {
+                VALUES["process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */] = env.apply;
+            }
+            if ((0, types_1.isString)(pwd)) {
+                VALUES[_h = "process.password" /* KEY_NAME.PROCESS_PASSWORD */] || (VALUES[_h] = encryptMessage(pwd, cipher));
+            }
+        }
+        if (memory && (0, types_1.isPlainObject)(memory.settings)) {
+            const users = memory.settings.users;
+            if (typeof users === 'boolean' || Array.isArray(users)) {
+                VALUES["memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */] = users;
+            }
+        }
+        if ((0, types_1.isPlainObject)(logger)) {
+            const { enabled, level, production, broadcast, stack_trace } = logger;
+            if (typeof enabled === 'boolean') {
+                SETTINGS.enabled = enabled;
+            }
+            if (level !== undefined) {
+                const value = (0, types_1.isString)(level) ? types_1.STATUS_TYPE[level.trim().toUpperCase()] : level;
+                if (value >= -1 && value <= types_1.STATUS_TYPE.TRACE) {
+                    VALUES["logger.level" /* KEY_NAME.LOGGER_LEVEL */] = value;
+                }
+            }
+            if (Array.isArray(production)) {
+                SETTINGS.production = production.slice(0);
+            }
+            for (const attr in logger) {
+                switch (attr) {
+                    case 'format': {
+                        const format = logger.format;
+                        if ((0, types_1.isPlainObject)(format)) {
+                            for (const section in format) {
+                                const stored = SETTINGS.format[section];
+                                const target = format[section];
+                                if (stored && (0, types_1.isPlainObject)(target)) {
+                                    for (let name in target) {
+                                        const value = target[name];
+                                        switch (name) {
+                                            case 'bg_color':
+                                                name = 'bgColor';
+                                                break;
+                                            case 'bg_alt_color':
+                                                name = 'bgAltColor';
+                                                break;
+                                        }
+                                        switch (name) {
+                                            case 'width': {
+                                                const width = parseInt(value);
+                                                if (width > 0) {
+                                                    stored[name] = width;
+                                                }
+                                                break;
+                                            }
+                                            case 'bold':
+                                                if (typeof value === 'boolean') {
+                                                    stored[name] = value;
+                                                }
+                                                break;
+                                            case 'color':
+                                            case 'bgColor':
+                                            case 'bgAltColor':
+                                            case 'justify':
+                                            case 'unit':
+                                                if (typeof value === 'string') {
+                                                    stored[name] = value;
+                                                }
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'meter': {
+                        const meter = logger.meter;
+                        if ((0, types_1.isPlainObject)(meter)) {
+                            for (const name in meter) {
+                                const increment = +meter[name];
+                                if (increment > 0) {
+                                    SETTINGS.meter[name] = increment;
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'status': {
+                        const status = logger.status;
+                        const target = SETTINGS.status;
+                        if (typeof status === 'boolean') {
+                            for (const name in target) {
+                                target[name] = status;
+                            }
+                        }
+                        else if ((0, types_1.isPlainObject)(status)) {
+                            for (const name in status) {
+                                if (name in target) {
+                                    target[name] = !!status[name];
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'session_id': {
+                        let session_id = logger.session_id;
+                        if (session_id !== undefined) {
+                            if (!session_id) {
+                                SETTINGS.session_id = 0;
+                            }
+                            else if (session_id === true) {
+                                SETTINGS.session_id = 3;
+                            }
+                            else if ((session_id = +session_id) > 0) {
+                                SETTINGS.session_id = session_id;
+                            }
+                        }
+                        break;
+                    }
+                    case 'process': {
+                        const process = logger.process;
+                        if (process) {
+                            if (!(0, types_1.isObject)(SETTINGS.process)) {
+                                SETTINGS.process = { cpu: true, cpu_bar: true, cpu_single_core: true, mem: true, mem_format: '%' };
+                            }
+                            if ((0, types_1.isObject)(process)) {
+                                Object.assign(SETTINGS.process, process);
+                            }
+                            else {
+                                Object.assign(SETTINGS.process, { cpu: true, mem: true });
+                            }
+                        }
+                        else if (process !== undefined) {
+                            SETTINGS.process = false;
+                        }
+                        break;
+                    }
+                    default:
+                        if (attr in SETTINGS) {
+                            SETTINGS[attr] = logger[attr];
+                        }
+                        break;
+                }
+            }
+            if (broadcast?.out) {
+                VALUES["broadcast.out" /* KEY_NAME.BROADCAST_OUT */] = this.parseFunction(broadcast.out, { external: true, absolute: true });
+            }
+            if (stack_trace && stack_trace !== true && +stack_trace > 0) {
+                Error.stackTraceLimit = +stack_trace;
+            }
+        }
+        if (error) {
+            if (error.out) {
+                VALUES["error.out" /* KEY_NAME.ERROR_OUT */] = this.parseFunction(error.out, { external: true, absolute: true });
+            }
+            if (typeof error.fatal === 'boolean') {
+                VALUES["error.fatal" /* KEY_NAME.ERROR_FATAL */] = error.fatal;
+            }
+        }
+        if (permission && Array.isArray(permission.process_exec)) {
+            VALUES["permission.process_exec" /* KEY_NAME.PERMISSION_PROCESS_EXEC */] = permission.process_exec.filter(item => typeof item === 'string' || (0, types_1.isObject)(item) && typeof item.command === 'string').map(exec => {
+                if (typeof exec === 'string') {
+                    return exec.trim();
+                }
+                if (typeof exec.warn === 'string') {
+                    exec.warn = [exec.warn];
+                }
+                exec.command = exec.command.trim();
+                return exec;
+            });
+        }
+        {
+            let dir = settings.temp_dir, write;
+            if ((0, types_1.isPlainObject)(temp)) {
+                dir || (dir = temp.dir);
+                write = temp.write;
+            }
+            let modified;
+            if ((0, types_1.isString)(dir) && path.isAbsolute(dir = path.normalize(dir).replace(/[\\/]$/, ''))) {
+                if (withinDir(dir, PROCESS_CWD)) {
+                    dir = dir.substring(ensureDir(PROCESS_CWD).length);
+                }
+                else {
+                    this.formatMessage(1 /* LOG_VALUE.SYSTEM */, 'WARN', 'Temp directory can only be relative', dir, { ...this.LOG_STYLE_WARN, newline: true });
+                    dir = undefined;
+                }
+            }
+            if (!(0, types_1.isString)(dir)) {
+                dir = VALUES["temp.dir" /* KEY_NAME.TEMP_DIR */];
+            }
+            if (typeof write === 'boolean') {
+                modified = VALUES["temp.write" /* KEY_NAME.TEMP_WRITE */] !== write;
+                VALUES["temp.write" /* KEY_NAME.TEMP_WRITE */] = write;
+            }
+            do {
+                const [output, index] = tryIncrementDir(path.join(PROCESS_CWD, dir), 5);
+                if ((0, types_1.isString)(output)) {
+                    if (index > 0) {
+                        dir = trimDir(dir) + '_' + index;
+                    }
+                    if (dir !== VALUES["temp.dir" /* KEY_NAME.TEMP_DIR */]) {
+                        VALUES["temp.dir" /* KEY_NAME.TEMP_DIR */] = dir;
+                        modified = true;
+                    }
+                    (0, types_1.setTempDir)(TEMP_DIR = output);
+                    break;
+                }
+                if (output instanceof Error) {
+                    this.writeFail(["Unable to create temp directory" /* ERR_MESSAGE.TEMP_DIRECTORY */, dir], output, 32 /* LOG_VALUE.FILE */);
+                }
+            } while ((dir !== "tmp" /* INTERNAL.TEMP_DIR */) && (dir = "tmp" /* INTERNAL.TEMP_DIR */));
+            if (modified) {
+                this.formatMessage(1 /* LOG_VALUE.SYSTEM */, 'TEMP', ["Directory was modified" /* VAL_MESSAGE.MODIFIED_DIRECTORY */, dir], TEMP_DIR + (VALUES["temp.write" /* KEY_NAME.TEMP_WRITE */] ? ' - writeable' : ''), { ...this.LOG_STYLE_NOTICE, newline: true });
+            }
+            settings.temp_dir = dir;
+            if ((0, types_1.isPlainObject)(temp)) {
+                temp.dir = dir;
+            }
+        }
+        return true;
+    }
+    supported(major, minor, patch, lts) {
+        return Module.supported(major, minor, patch, lts);
+    }
+    supports(name, value) {
+        if (typeof value === 'boolean') {
+            this[kSupports][name] = { value, modified: true };
+            return value;
+        }
+        const host = this.host;
+        const item = this[kSupports][name];
+        return host && !item?.modified ? host.supports(name) : item?.value === true;
+    }
+    getTempDir(pathname, filename, createDir) {
+        let increment = 0, moduleDir, uuidDir;
+        if ((0, types_1.isPlainObject)(pathname)) {
+            ({ pathname, filename, moduleDir, uuidDir, createDir, increment = 0 } = pathname);
+        }
+        else {
+            if (typeof filename === 'boolean') {
+                createDir = filename;
+                filename = undefined;
+            }
+            if (typeof pathname === 'boolean') {
+                uuidDir = pathname;
+                pathname = undefined;
+            }
+        }
+        const leading = [PROCESS_CWD, this.tempDir];
+        if (moduleDir) {
+            leading.push(this.moduleName);
+        }
+        let result;
+        if ((0, types_1.isString)(pathname)) {
+            leading.push(pathname);
+            createDir ?? (createDir = true);
+        }
+        if (uuidDir) {
+            leading.push((0, types_1.generateUUID)());
+            createDir ?? (createDir = true);
+        }
+        if ((createDir || increment > 0) && !Module.isDir(result = path.join(...leading))) {
+            const [output] = tryIncrementDir(result, increment);
+            if (!(0, types_1.isString)(output)) {
+                if (output instanceof Error) {
+                    this.writeFail(["Unable to create temp directory" /* ERR_MESSAGE.TEMP_DIRECTORY */, result], output, 32 /* LOG_VALUE.FILE */);
+                }
+                return '';
+            }
+            result = output;
+        }
+        if (filename) {
+            const trailing = (filename[0] === '.' ? (0, types_1.generateUUID)() : '') + filename;
+            if (result) {
+                return path.join(result, trailing);
+            }
+            leading.push(trailing);
+        }
+        return result || path.join(...leading);
+    }
+    canRead(uri, options) {
+        let permission = this.permission, ownPermissionOnly = false;
+        if (options) {
+            if (options.hostPermissionOnly) {
+                let host;
+                if (!(permission = (host = this.host) && host.permission)) {
+                    return true;
+                }
+            }
+            else if (options.ownPermissionOnly) {
+                if (!(permission = this[kPermission])) {
+                    return true;
+                }
+                ownPermissionOnly = true;
+            }
+        }
+        if (permission && (Module.isFile(uri, 'unc') ? permission.hasUNCRead(path.normalize(uri)) || ownPermissionOnly && !permission.getUNCRead() : path.isAbsolute(uri = path.resolve(uri)) && (permission.hasDiskRead(uri) || ownPermissionOnly && !permission.getDiskRead()))) {
+            return true;
+        }
+        return VALUES["permission.home_read" /* KEY_NAME.PERMISSION_HOMEREAD */] && withinDir(uri, OS_HOMEDIR);
+    }
+    canWrite(uri, options) {
+        let permission = this.permission, ownPermissionOnly = false;
+        if (options) {
+            if (options.hostPermissionOnly) {
+                let host;
+                if (!(permission = (host = this.host) && host.permission)) {
+                    return true;
+                }
+            }
+            else if (options.ownPermissionOnly) {
+                if (!(permission = this[kPermission])) {
+                    return true;
+                }
+                ownPermissionOnly = true;
+            }
+        }
+        if (permission && (Module.isFile(uri, 'unc') ? permission.hasUNCWrite(path.normalize(uri)) || ownPermissionOnly && !permission.getUNCWrite() : path.isAbsolute(uri = path.resolve(uri)) && (permission.hasDiskWrite(uri) || ownPermissionOnly && !permission.getDiskWrite()))) {
+            return true;
+        }
+        return VALUES["temp.write" /* KEY_NAME.TEMP_WRITE */] && withinDir(uri, TEMP_DIR) || VALUES["permission.home_write" /* KEY_NAME.PERMISSION_HOMEWRITE */] && withinDir(uri, OS_HOMEDIR);
+    }
+    readFile(src, options = {}, callback) {
+        let promises, outSrc;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if (outSrc = hasFileSystem.call(this, 0 /* FILE_SYSTEM.READ */, src, options)) {
+            const { requireExt, cache } = options;
+            const encoding = options.encoding && (0, types_1.getEncoding)(options.encoding);
+            const setCache = (data, cjs) => {
+                if (data) {
+                    if (cache) {
+                        addCacheItem(cjs ? CACHE_READCJS : encoding ? CACHE_READTEXT : CACHE_READBUFFER, outSrc, data);
+                    }
+                    this.emit('file:read', outSrc, data, options);
+                }
+            };
+            let result;
+            if (requireExt && VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] && hasString(requireExt === true ? VALUES["node.require.ext" /* KEY_NAME.NODE_REQUIRE_EXT */] : requireExt, getExtension(src))) {
+                if (cache) {
+                    result = getCacheItem(CACHE_READCJS, outSrc);
+                }
+                if (!result) {
+                    try {
+                        result = require(outSrc);
+                        setCache(result, true);
+                        checkFunction(result);
+                    }
+                    catch {
+                    }
+                }
+            }
+            if (cache) {
+                result || (result = (encoding ? getCacheItem(CACHE_READTEXT, outSrc) : getCacheItem(CACHE_READBUFFER, outSrc)));
+            }
+            if (promises) {
+                if (result) {
+                    return Promise.resolve(result);
+                }
+                return fs.promises.readFile(outSrc, encoding).then(data => {
+                    setCache(data);
+                    return data;
+                });
+            }
+            if (isFunction(callback)) {
+                if (result) {
+                    callback(null, result);
+                }
+                else {
+                    fs.readFile(outSrc, encoding, (err, data) => {
+                        if (!err) {
+                            setCache(data);
+                        }
+                        callback(err, data);
+                    });
+                }
+                return;
+            }
+            try {
+                if (!result) {
+                    setCache(result = fs.readFileSync(outSrc, encoding));
+                }
+                return result;
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(src)], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(src));
+        }
+    }
+    writeFile(src, data, options = {}, callback) {
+        let promises, outSrc;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if (outSrc = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, src, options, true, options.overwrite)) {
+            if (promises) {
+                return fs.promises.writeFile(outSrc, data, options.encoding).then(() => {
+                    this.emit('file:write', outSrc, options);
+                    return true;
+                });
+            }
+            if (isFunction(callback)) {
+                fs.writeFile(outSrc, data, { encoding: options.encoding }, err => {
+                    if (!err) {
+                        this.emit('file:write', outSrc, options);
+                    }
+                    callback(err);
+                });
+                return;
+            }
+            try {
+                fs.writeFileSync(outSrc, data, options.encoding);
+                this.emit('file:write', outSrc, options);
+                return true;
+            }
+            catch (err) {
+                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(src)], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(src));
+            return;
+        }
+        return false;
+    }
+    deleteFile(src, options = {}, callback) {
+        let promises, outSrc;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if (outSrc = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, src, options)) {
+            if (promises) {
+                return fs.promises.unlink(outSrc).then(() => {
+                    this.emit('file:delete', outSrc, options);
+                    return true;
+                });
+            }
+            if (isFunction(callback)) {
+                fs.unlink(outSrc, err => {
+                    if (!err) {
+                        this.emit('file:delete', outSrc, options);
+                    }
+                    callback(err);
+                });
+                return;
+            }
+            try {
+                fs.unlinkSync(outSrc);
+            }
+            catch (err) {
+                if (!Module.isErrorCode(err, 'ENOENT')) {
+                    this.writeFail(["Unable to delete file" /* ERR_MESSAGE.DELETE_FILE */, path.basename(src)], err, 32 /* LOG_VALUE.FILE */);
+                    return false;
+                }
+            }
+            this.emit('file:delete', outSrc, options);
+            return true;
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(src));
+            return;
+        }
+        return false;
+    }
+    copyFile(src, dest, options = {}, callback) {
+        let promises, outSrc, outDest;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if ((outSrc = hasFileSystem.call(this, 0 /* FILE_SYSTEM.READ */, src, options)) && (outDest = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, dest, options, true, options.overwrite))) {
+            const destDir = path.dirname(outDest);
+            if (!Module.isDir(destDir) && (options.createDir === false || !Module.createDir(destDir))) {
+                if (promises) {
+                    return Promise.reject(errorPermission(destDir));
+                }
+                if (isFunction(callback)) {
+                    callback(errorPermission(destDir));
+                    return;
+                }
+                if (options.throwsPermission) {
+                    throw errorPermission(destDir);
+                }
+            }
+            else {
+                options.outSrc = outSrc;
+                if (promises) {
+                    return fs.promises.copyFile(outSrc, outDest).then(() => {
+                        this.emit('file:copy', outDest, options);
+                        return true;
+                    });
+                }
+                if (isFunction(callback)) {
+                    fs.copyFile(outSrc, outDest, err => {
+                        if (!err) {
+                            this.emit('file:copy', outDest, options);
+                        }
+                        callback(err);
+                    });
+                    return;
+                }
+                try {
+                    fs.copyFileSync(outSrc, outDest);
+                    this.emit('file:copy', outDest, options);
+                    return true;
+                }
+                catch (err) {
+                    this.writeFail(["Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, dest], err, 32 /* LOG_VALUE.FILE */);
+                }
+            }
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(!outSrc ? src : dest));
+            return;
+        }
+        return false;
+    }
+    moveFile(src, dest, options = {}, callback) {
+        let promises, outSrc, outDest;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if ((outSrc = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, src, options)) && (outDest = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, dest, options, true, options.overwrite))) {
+            const destDir = path.dirname(outDest);
+            if (!Module.isDir(destDir) && (options.createDir === false || !Module.createDir(destDir))) {
+                if (promises) {
+                    return Promise.reject(errorPermission(destDir));
+                }
+                if (isFunction(callback)) {
+                    callback(errorPermission(destDir));
+                    return;
+                }
+                if (options.throwsPermission) {
+                    throw errorPermission(destDir);
+                }
+            }
+            else {
+                options.outSrc = outSrc;
+                const checkError = (err) => {
+                    if (Module.isErrorCode(err, 'EXDEV')) {
+                        try {
+                            fs.copyFileSync(outSrc, outDest);
+                            fs.unlinkSync(outSrc);
+                            return true;
+                        }
+                        catch {
+                            fs.unlink(outDest, () => { });
+                        }
+                    }
+                    return false;
+                };
+                if (promises) {
+                    return new Promise((resolve, reject) => {
+                        fs.rename(outSrc, outDest, err => {
+                            if (err && checkError(err)) {
+                                err = null;
+                            }
+                            if (!err) {
+                                this.emit('file:move', outDest, options);
+                                resolve(true);
+                            }
+                            else {
+                                reject(err);
+                            }
+                        });
+                    });
+                }
+                if (isFunction(callback)) {
+                    fs.rename(outSrc, outDest, err => {
+                        if (err && checkError(err)) {
+                            err = null;
+                        }
+                        if (!err) {
+                            this.emit('file:move', outDest, options);
+                        }
+                        callback(err);
+                    });
+                    return;
+                }
+                try {
+                    fs.renameSync(outSrc, outDest);
+                    this.emit('file:move', outDest, options);
+                    return true;
+                }
+                catch (err) {
+                    if (checkError(err)) {
+                        this.emit('file:move', outDest, options);
+                        return true;
+                    }
+                    this.writeFail(["Unable to move file" /* ERR_MESSAGE.MOVE_FILE */, dest], err, 32 /* LOG_VALUE.FILE */);
+                }
+            }
+        }
+        else {
+            if (outSrc) {
+                src = dest;
+            }
+            if (promises) {
+                return Promise.reject(errorPermission(src));
+            }
+            if (isFunction(callback)) {
+                callback(errorPermission(src));
+                return;
+            }
+        }
+        return false;
+    }
+    createDir(src, options = {}, callback) {
+        let promises, outSrc;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if (outSrc = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, src, options, true)) {
+            if (Module.isDir(outSrc)) {
+                if (promises) {
+                    return Promise.resolve(true);
+                }
+                if (isFunction(callback)) {
+                    callback(null);
+                    return;
+                }
+                return true;
+            }
+            try {
+                if (fs.existsSync(outSrc)) {
+                    if (promises) {
+                        return Promise.reject(errorDirectory(outSrc));
+                    }
+                    if (isFunction(callback)) {
+                        callback(errorDirectory(outSrc));
+                        return;
+                    }
+                    if (options.throwsPermission) {
+                        throw errorPermission(outSrc);
+                    }
+                }
+                else {
+                    if (promises || isFunction(callback)) {
+                        const result = new Promise(resolve => {
+                            resolve(tryCreateDir(outSrc));
+                        }).then(success => {
+                            this.emit('dir:create', outSrc, options);
+                            if (callback) {
+                                callback(null);
+                            }
+                            return success;
+                        });
+                        if (callback) {
+                            result.catch(err => callback(err));
+                        }
+                        return promises ? result : undefined;
+                    }
+                    if (tryCreateDir(outSrc)) {
+                        this.emit('dir:create', outSrc, options);
+                        return true;
+                    }
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to create directory" /* ERR_MESSAGE.CREATE_DIRECTORY */, src], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(src));
+            return;
+        }
+        return false;
+    }
+    removeDir(src, options = {}, callback) {
+        let promises, outSrc;
+        [options, promises, callback] = parseFileArgs(options, callback);
+        if (outSrc = hasFileSystem.call(this, 1 /* FILE_SYSTEM.WRITE */, src, options, true)) {
+            try {
+                if (Module.isDir(outSrc)) {
+                    const { emptyDir = false, recursive = true } = options;
+                    const errorResponse = (failed) => new Error("Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */ + ':' + (failed.length > 1 ? failed.map(value => `\n- ${value}`) : ' ' + failed[0]));
+                    if (promises || isFunction(callback)) {
+                        const result = new Promise((resolve, reject) => {
+                            const failed = tryRemoveDir(outSrc, emptyDir, !!recursive);
+                            if (failed.length === 0) {
+                                resolve(true);
+                            }
+                            else {
+                                reject(errorResponse(failed));
+                            }
+                        })
+                            .then(success => {
+                            this.emit('dir:remove', outSrc, options);
+                            if (callback) {
+                                callback(null);
+                            }
+                            return success;
+                        });
+                        if (callback) {
+                            result.catch(err => callback(err));
+                        }
+                        return promises ? result : undefined;
+                    }
+                    const failed = tryRemoveDir(outSrc, emptyDir, !!recursive);
+                    if (failed.length === 0) {
+                        this.emit('dir:remove', outSrc, options);
+                        return true;
+                    }
+                    throw errorResponse(failed);
+                }
+                else if (fs.existsSync(outSrc)) {
+                    if (promises) {
+                        return Promise.reject(errorDirectory(outSrc));
+                    }
+                    if (isFunction(callback)) {
+                        callback(errorDirectory(outSrc));
+                        return;
+                    }
+                }
+                else {
+                    if (promises) {
+                        return Promise.resolve(true);
+                    }
+                    if (isFunction(callback)) {
+                        callback(null);
+                        return;
+                    }
+                    return true;
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to remove directory" /* ERR_MESSAGE.REMOVE_DIRECTORY */, src], err, 32 /* LOG_VALUE.FILE */);
+            }
+        }
+        else if (promises) {
+            return Promise.reject(errorPermission(src));
+        }
+        else if (isFunction(callback)) {
+            callback(errorPermission(src));
+            return;
+        }
+        return false;
+    }
+    allSettled(tasks, rejected, options) {
+        rejected || (rejected = "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+        return Promise.allSettled(tasks).then(result => {
+            const items = [];
+            for (const item of result) {
+                if (item.status === 'fulfilled') {
+                    items.push(item);
+                }
+                else if (item.reason) {
+                    this.writeFail(rejected, item.reason, options);
+                }
+            }
+            return items;
+        })
+            .catch(err => {
+            this.writeFail(rejected, err, options);
+            return [];
+        });
+    }
+    writeFail(value, message, options) {
+        let type;
+        if ((0, types_1.isPlainObject)(options)) {
+            ({ type } = options);
+        }
+        else {
+            if (typeof options === 'number') {
+                type = options;
+            }
+            options = {};
+        }
+        this.formatFail(type || types_1.LOG_TYPE.SYSTEM, "FAIL!" /* ERR_MESSAGE.FAIL */, value, message, options);
+    }
+    writeTimeProcess(title, value, startTime, options = {}) {
+        const { type = 0, statusType = 0 } = options;
+        const http = type & 1024 /* LOG_VALUE.HTTP */;
+        const meter = SETTINGS.meter;
+        const failed = isFailed(options);
+        const increment = options.meterIncrement || (http ? meter.http
+            : type & 2048 /* LOG_VALUE.IMAGE */ ? meter.image
+                : type & 8 /* LOG_VALUE.COMPRESS */ ? meter.compress
+                    : meter.process) || 250;
+        const duration = getTimeOffset(startTime);
+        let meterTime = duration, delayTime = options.delayTime;
+        if (delayTime !== undefined) {
+            if (Array.isArray(delayTime)) {
+                delayTime = Math.max((0, types_1.convertTime)(delayTime), 0);
+                if (delayTime < meterTime) {
+                    meterTime -= delayTime;
+                }
+                else {
+                    delayTime = 0;
+                }
+            }
+            if (delayTime >= 0) {
+                options.messageUnitIndent = [Math.round(delayTime / increment), '-'];
+            }
+        }
+        if (failed && !http) {
+            value = "Failed" /* ERR_MESSAGE.FAILED */ + ' -> ' + value;
+        }
+        const args = [
+            (256 /* LOG_VALUE.TIME_PROCESS */ | type),
+            title,
+            [value, formatTimeHint(duration)],
+            (failed ? 'X' : '>').repeat(Math.min(Math.ceil(meterTime / increment), SETTINGS.format.meter.width)),
+            options
+        ];
+        applyLogId.call(this, options);
+        if (statusType > 0) {
+            this.addLog(statusType, value, typeof startTime === 'number' ? startTime : undefined, duration);
+        }
+        if (options.queue && !this._logFlushed) {
+            this._logQueued.push(args);
+        }
+        else {
+            setCpuAndMem.call(this, options);
+            Module.formatMessage(...args);
+        }
+        if (!options.bypassLog) {
+            this.addLog(types_1.STATUS_TYPE.INFO, title + ' -> ' + value, Date.now(), duration);
+        }
+    }
+    writeTimeElapsed(title, value, startTime, options = {}) {
+        const { type = 0, statusType = 0 } = options;
+        let message;
+        if (Array.isArray(value)) {
+            message = value[1];
+            value = value[0];
+        }
+        else if (options.showCpu) {
+            setCpuAndMem.call(this, options);
+        }
+        else {
+            message = value;
+            value = '';
+        }
+        value || (value = isFailed(options) ? "Failed" /* ERR_MESSAGE.FAILED */ : "Success" /* VAL_MESSAGE.SUCCESS */);
+        const duration = getTimeOffset(startTime);
+        const args = [
+            (128 /* LOG_VALUE.TIME_ELAPSED */ | type),
+            title,
+            [value, formatTimeHint(duration)],
+            message,
+            options
+        ];
+        applyLogId.call(this, options);
+        if (statusType > 0) {
+            this.addLog(statusType, value, typeof startTime === 'number' ? startTime : undefined, duration);
+        }
+        if (options.queue && !this._logFlushed) {
+            this._logQueued.push(args);
+        }
+        else {
+            Module.formatMessage(...args);
+        }
+    }
+    formatFail(type, title, value, message, options = {}) {
+        options.type = type;
+        const result = this.checkFail(message, options);
+        if (result) {
+            if (result.type !== undefined) {
+                type = result.type;
+            }
+            if (result.value !== undefined) {
+                value = result.value;
+            }
+            if (result.message !== undefined) {
+                message = result.message;
+            }
+        }
+        else if (result === false) {
+            return;
+        }
+        if (options.passThrough) {
+            message = null;
+        }
+        const args = [(type | 512 /* LOG_VALUE.FAIL */), title, value, message, applyStyle(options, Module.LOG_STYLE_FAIL)];
+        applyLogId.call(this, options);
+        if (options.queue !== false && !options.passThrough && !this._logFlushed) {
+            if (VALUES["error.out" /* KEY_NAME.ERROR_OUT */]) {
+                options.timeStamp = Date.now();
+            }
+            this._logQueued.push(args);
+        }
+        else {
+            Module.formatMessage(...args);
+        }
+        const host = this.host;
+        const target = host || this;
+        let fatal;
+        if (options.exec && (type & 4096 /* LOG_VALUE.EXEC */) && target.willAbort("(exec)" /* ABORT_NAME.EXEC */)) {
+            const exec = { ...options.exec };
+            let output = VALUES["permission.process_exec" /* KEY_NAME.PERMISSION_PROCESS_EXEC */].find(item => exec.command === ((0, types_1.isObject)(item) ? item.command : item));
+            if (output) {
+                if ((0, types_1.isPlainObject)(output)) {
+                    output = { ...output };
+                    if (Array.isArray(output.warn)) {
+                        (exec.warn || (exec.warn = [])).push(...output.warn);
+                    }
+                    delete output.command;
+                    delete output.warn;
+                }
+                else {
+                    output = undefined;
+                }
+                if (target.listenerCount('exec') > 0) {
+                    target.emit('exec', exec, output);
+                }
+                else {
+                    this.emit('exec', exec, output);
+                }
+            }
+            else {
+                this.formatMessage(4096 /* LOG_VALUE.EXEC */, "WARN!" /* ERR_MESSAGE.WARN */, "Exec command not permitted" /* ERR_MESSAGE.EXEC_PERMISSION */, exec.command, { ...Module.LOG_STYLE_WARN });
+            }
+        }
+        if (options.passThrough) {
+            return;
+        }
+        if (options.abortable !== false && (options.fatal !== false || this.isFatal(message))) {
+            if (target.willAbort("(unknown)" /* ABORT_NAME.UNKNOWN */)) {
+                if (host) {
+                    host.abort();
+                }
+                else {
+                    this.abort();
+                }
+                fatal = true;
+            }
+            else if (host && this.abortable) {
+                if (host.abortable) {
+                    host.abort();
+                }
+                this.abort();
+                fatal = true;
+            }
+            else if ((type & 8192 /* LOG_VALUE.PERMISSION */ && (!host || host.willAbort("(permission)" /* ABORT_NAME.PERMISSION */))) ||
+                (type & 1 /* LOG_VALUE.SYSTEM */) && target.willAbort("(system)" /* ABORT_NAME.SYSTEM */) ||
+                (type & 2 /* LOG_VALUE.NODE */) && target.willAbort("(node)" /* ABORT_NAME.NODE */) ||
+                (type & 8 /* LOG_VALUE.COMPRESS */) && target.willAbort("(compress)" /* ABORT_NAME.COMPRESS */) ||
+                (type & 16 /* LOG_VALUE.WATCH */) && target.willAbort("(watch)" /* ABORT_NAME.WATCH */) ||
+                (type & 32 /* LOG_VALUE.FILE */) && target.willAbort("(file)" /* ABORT_NAME.FILE */) ||
+                (type & 64 /* LOG_VALUE.CLOUD */) && target.willAbort("(cloud)" /* ABORT_NAME.CLOUD */) ||
+                (type & 1024 /* LOG_VALUE.HTTP */) && target.willAbort("(http)" /* ABORT_NAME.HTTP */) ||
+                (type & 2048 /* LOG_VALUE.IMAGE */) && target.willAbort("(image)" /* ABORT_NAME.IMAGE */) ||
+                (type & 4096 /* LOG_VALUE.EXEC */) && target.willAbort("(exec)" /* ABORT_NAME.EXEC */) ||
+                (type & 16384 /* LOG_VALUE.TIMEOUT */) && target.willAbort("(timeout)" /* ABORT_NAME.TIMEOUT */) ||
+                (type & 65536 /* LOG_VALUE.DB */) && target.willAbort("(db)" /* ABORT_NAME.DB */)) {
+                if (host) {
+                    if (host.abortable) {
+                        host.abort();
+                        fatal = true;
+                    }
+                }
+                else if (this.abortable) {
+                    this.abort();
+                    fatal = true;
+                }
+            }
+        }
+        if (message) {
+            if (this._logEnabled) {
+                if (fatal) {
+                    const timeStamp = Date.now();
+                    this.addLog(types_1.STATUS_TYPE.FATAL, message, timeStamp, options.startTime && getTimeOffset(options.startTime, timeStamp));
+                }
+                else {
+                    this.addLog(options.statusType || types_1.STATUS_TYPE.ERROR, message);
+                }
+                this.errors.push(message instanceof Error ? getErrorMessage(message) : message);
+            }
+            if (this.listenerCount('error') > 0) {
+                this.emit('error', errorObject(message));
+            }
+            else if (host && host.listenerCount('error') > 0) {
+                host.emit('error', errorObject(message));
+            }
+        }
+    }
+    formatMessage(type, title, value, message, options = {}) {
+        const statusType = options.statusType || 0;
+        const args = [type, title, value, message, options];
+        applyLogId.call(this, options);
+        if (statusType > 0) {
+            this.addLog(statusType, message || (Array.isArray(value) ? value[0] : value));
+        }
+        if (options.queue && !this._logFlushed) {
+            if (VALUES["error.out" /* KEY_NAME.ERROR_OUT */] && (type & 512 /* LOG_VALUE.FAIL */)) {
+                options.timeStamp = Date.now();
+            }
+            this._logQueued.push(args);
+        }
+        else {
+            Module.formatMessage(...args);
+        }
+    }
+    checkPackage(err, name, value, options) {
+        if (typeof value === 'number') {
+            options = value;
+            value = undefined;
+        }
+        else if ((0, types_1.isPlainObject)(value)) {
+            options = value;
+            value = undefined;
+        }
+        if (err instanceof Error && err.code === types_1.ERR_CODE.MODULE_NOT_FOUND && (0, types_1.isString)(name)) {
+            if (typeof options === 'number') {
+                options = undefined;
+            }
+            this.writeFail("Unknown" /* ERR_MESSAGE.UNKNOWN */, err, { ...options, type: types_1.LOG_TYPE.SYSTEM, code: types_1.ERR_CODE.MODULE_NOT_FOUND, exec: { command: 'npm', args: ['i', name] } });
+            return true;
+        }
+        if (value) {
+            this.writeFail(value, err, options);
+        }
+        return false;
+    }
+    checkFail(message, options) {
+        const code = options.code;
+        if (code && message instanceof Error) {
+            const valid = message.code === code;
+            switch (code) {
+                case types_1.ERR_CODE.MODULE_NOT_FOUND: {
+                    const exec = options.exec;
+                    if (exec) {
+                        if (valid && !this.aborted) {
+                            const command = exec.command + (exec.args ? ' ' + exec.args.join(' ') : '');
+                            const target = this.host || this;
+                            let session = CACHE_EXEC.get(target);
+                            if (!session) {
+                                CACHE_EXEC.set(target, session = []);
+                            }
+                            if (session.includes(command)) {
+                                return false;
+                            }
+                            session.push(command);
+                            let type = options.type || 0;
+                            type |= 4096 /* LOG_VALUE.EXEC */;
+                            type &= ~1 /* LOG_VALUE.SYSTEM */;
+                            if (options.passThrough) {
+                                options.passThrough = false;
+                                message = null;
+                            }
+                            return { type, value: ["Install required?" /* ERR_MESSAGE.INSTALL */, command], message };
+                        }
+                        delete options.exec;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    writeLog(type, value, timeStamp, duration) {
+        let queue;
+        if ((0, types_1.isObject)(type)) {
+            if (typeof value === 'boolean') {
+                queue = value;
+            }
+            ({ type = types_1.STATUS_TYPE.UNKNOWN, value, timeStamp, duration } = type);
+        }
+        const output = Module.asString(value);
+        if (output) {
+            if ((queue || (0, types_1.isPlainObject)(timeStamp) && timeStamp.queue) && !this._logFlushed) {
+                this._logQueued.push([-1, output]);
+            }
+            else {
+                writeLine(output);
+            }
+        }
+        this.addLog(type, value, timeStamp, duration);
+    }
+    addLog(type, value, timeStamp, duration, from, source) {
+        if (!this._logEnabled || SETTINGS.production && process.env.NODE_ENV === 'production' && (SETTINGS.production.includes(this.moduleName) || from && SETTINGS.production.includes(from))) {
+            return;
+        }
+        if ((0, types_1.isObject)(type)) {
+            ({ type = types_1.STATUS_TYPE.UNKNOWN, value, timeStamp, duration, from, source } = type);
+        }
+        else if (typeof timeStamp === 'string') {
+            if (typeof duration === 'string') {
+                source = duration;
+                duration = undefined;
+            }
+            from = timeStamp;
+            timeStamp = 0;
+        }
+        else if ((0, types_1.isObject)(timeStamp)) {
+            ({ timeStamp, duration, from, source } = timeStamp);
+        }
+        const name = types_1.STATUS_TYPE[type] || types_1.STATUS_TYPE[type = 0];
+        const logLevel = this.logLevel;
+        if ((0, types_1.isEmpty)(value) || logLevel > 0 && (type > logLevel || type === 0 && logLevel < types_1.STATUS_TYPE.DEBUG) || SETTINGS.status[name.toLowerCase()] === false) {
+            return;
+        }
+        let message = '';
+        if (!timeStamp) {
+            timeStamp = Date.now();
+        }
+        else if (timeStamp instanceof Date) {
+            timeStamp = timeStamp.getTime();
+        }
+        if (typeof duration === 'string') {
+            if (typeof from === 'string') {
+                source = from;
+            }
+            from = duration;
+            duration = undefined;
+        }
+        if (typeof value === 'string') {
+            message = this.supports('stripAnsi') ? stripansi(value) : value;
+        }
+        else if (value instanceof Error) {
+            if (value.name === 'AbortError') {
+                return;
+            }
+            if (value.stack && SETTINGS.status.trace) {
+                message = value.message;
+                this.status.push({ type: types_1.STATUS_TYPE.TRACE, value: message ? value.stack.replace(message, '').trim() : value.stack, timeStamp, name: types_1.STATUS_TYPE[types_1.STATUS_TYPE.TRACE], duration, sessionId: this.sessionId, from: this.moduleName, source });
+            }
+            else {
+                message = getErrorMessage(value);
+            }
+        }
+        else {
+            try {
+                message = Array.isArray(value) ? value.join(' / ') : value.toString();
+            }
+            catch {
+                message = '';
+            }
+        }
+        this.status.push({ value: message.trim() || "Unknown" /* ERR_MESSAGE.UNKNOWN */, name, duration, timeStamp, type, sessionId: this.sessionId, from: from || this.moduleName, source });
+    }
+    getLog(...type) {
+        return this.status.filter(item => type.includes(item.type));
+    }
+    flushLog() {
+        this._logFlushed = true;
+        const logQueued = this._logQueued;
+        if (logQueued.length) {
+            logQueued.sort((a, b) => b[0] - a[0]);
+            logQueued.forEach(args => {
+                if (args.length === 2) {
+                    if (!this.broadcastId) {
+                        writeLine(args[1]);
+                        return;
+                    }
+                    args = [args[0], '', this.supports('stripAnsi') ? stripansi(args[1]) : args[1], null, applyLogId.call(this, { sessionId: '' })];
+                }
+                Module.formatMessage(...args);
+            });
+            logQueued.length = 0;
+        }
+    }
+    reset() {
+        if (this.aborted) {
+            this[kAbortHandler] = new AbortController();
+        }
+        this.status.length = 0;
+        this.errors.length = 0;
+        this._logQueued.length = 0;
+        this._logFlushed = false;
+    }
+    detach() {
+        const host = this.host;
+        if (host) {
+            this.abortable = false;
+            host.modules.delete(this);
+            host.subProcesses.delete(this);
+            const listener = this[kAbortEvent];
+            if (listener) {
+                host.signal.removeEventListener('abort', listener);
+                this[kAbortEvent] = null;
+            }
+            this._host = null;
+        }
+    }
+    abort() {
+        if (!this.aborted) {
+            this[kAbortHandler].abort();
+        }
+    }
+    willAbort(value) {
+        return false;
+    }
+    hasOwnPermission() {
+        return !!this[kPermission];
+    }
+    isFatal(err) {
+        const fatal = this.host?.config.error?.fatal;
+        return fatal ?? VALUES["error.fatal" /* KEY_NAME.ERROR_FATAL */];
+    }
+    get moduleName() {
+        return this._moduleName;
+    }
+    set host(value) {
+        this.detach();
+        if (this._host = value) {
+            this.sessionId = value.sessionId;
+            this.broadcastId = value.broadcastId;
+            this._logEnabled = value.willLog(this.moduleName);
+            const aborting = this._hostEvents.includes('abort');
+            if (value.aborted) {
+                if (aborting) {
+                    this.abort();
+                }
+            }
+            else if (!value.subProcesses.has(this)) {
+                this.abortable = value.willAbort(this);
+                value.modules.add(this);
+                if (aborting) {
+                    value.signal.addEventListener('abort', this[kAbortEvent] = () => this.abort(), { once: true });
+                }
+            }
+        }
+    }
+    get host() {
+        return this._host;
+    }
+    set sessionId(value) {
+        this[kSessionId] = value;
+    }
+    get sessionId() {
+        return this[kSessionId] || (this.host ? this.host.sessionId : '');
+    }
+    set broadcastId(value) {
+        this[kBroadcastId] = value;
+    }
+    get broadcastId() {
+        return this[kBroadcastId] || (this.host ? this.host.broadcastId : '');
+    }
+    set permission(value) {
+        this[kPermission] = value;
+    }
+    get permission() {
+        let host;
+        return this[kPermission] || (host = this.host) && host.permission;
+    }
+    get signal() {
+        return this[kAbortHandler].signal;
+    }
+    get aborted() {
+        return this.signal.aborted;
+    }
+    set abortable(value) {
+        this._abortable = value;
+    }
+    get abortable() {
+        return this._abortable;
+    }
+    get threadable() {
+        return this._threadable;
+    }
+    get logType() {
+        return types_1.LOG_TYPE;
+    }
+    set logLevel(value) {
+        if ((0, types_1.isString)(value)) {
+            value = types_1.STATUS_TYPE[value.toUpperCase()];
+        }
+        if (value >= 0 && value <= types_1.STATUS_TYPE.TRACE) {
+            this._logLevel = value;
+        }
+    }
+    get logLevel() {
+        const value = this._logLevel;
+        if (value === -1) {
+            const host = this.host;
+            return host ? host.logLevel : 0;
+        }
+        return value;
+    }
+    get statusType() {
+        return types_1.STATUS_TYPE;
+    }
+    set tempDir(value) {
+        if (path.isAbsolute(value)) {
+            if (!withinDir(value, PROCESS_CWD)) {
+                return;
+            }
+            value = value.substring(ensureDir(PROCESS_CWD).length);
+        }
+        if (Module.isDir(path.join(PROCESS_CWD, value))) {
+            this[kTempDir] = value;
+        }
+    }
+    get tempDir() {
+        return this[kTempDir];
+    }
+}
+_a = kSessionId, _b = kTempDir, _c = kBroadcastId, _d = kPermission, _e = kSupports, _f = kAbortHandler, _g = kAbortEvent;
+Module.PROCESS_TIMEOUT = 0;
+Module.LOG_STYLE_FAIL = Object.freeze({ titleBgColor: 'bgRed', titleColor: 'white', titleBold: true });
+Module.LOG_STYLE_SUCCESS = Object.freeze({ titleBgColor: 'bgBlack', titleColor: 'green', titleBold: true });
+Module.LOG_STYLE_INFO = Object.freeze({ titleBgColor: 'bgBlue', titleColor: 'white' });
+Module.LOG_STYLE_WARN = Object.freeze({ titleBgColor: 'bgBlack', titleColor: 'yellow', titleBold: true });
+Module.LOG_STYLE_NOTICE = Object.freeze({ titleBgColor: 'bgGrey', titleColor: 'white' });
+Module.LOG_STYLE_REVERSE = Object.freeze({ titleBgColor: 'bgWhite', titleColor: 'black', messageBgColor: 'bgGrey' });
+if (!Module.supported(15, 4)) {
+    ({ AbortController: global.AbortController } = require('abort-controller'));
+    ({ EventTarget: global.EventTarget } = require('event-target-shim'));
+}
+EventEmitter.defaultMaxListeners = Infinity;
+Object.freeze(types_1.LOG_TYPE);
+Object.freeze(types_1.STATUS_TYPE);
+exports.default = Module;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}