@e-mc/file-manager 0.0.1

package/index.js

@@ -0,0 +1,3314 @@
+"use strict";
+/* eslint @typescript-eslint/no-explicit-any: "off" */
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const lib_v4_1 = require("../module/lib-v4");
+const util_1 = require("../request/util");
+const asset_1 = require("../document/asset");
+const util_2 = require("../document/util");
+const types_1 = require("../types");
+const request_1 = require("../request");
+const document_1 = require("../document");
+const task_1 = require("../task");
+const image_1 = require("../image");
+const watch_1 = require("../watch");
+const compress_1 = require("../compress");
+const cloud_1 = require("../cloud");
+const core_1 = require("../core");
+const kBaseDirectory = Symbol('baseDirectory');
+const kIncremental = Symbol('incremental');
+const kRestarting = Symbol('restarting');
+const kDelayed = Symbol('delayed');
+const kCleared = Symbol('cleared');
+const KTimerMain = Symbol('timerMain');
+const KEnabled = Symbol('enabled');
+const kRecursionLimit = Symbol('recursionLimit');
+const kHost = Symbol('host');
+const kQueuedTasks = Symbol('queuedTasks');
+const kProcessTimeout = Symbol('processTimeout');
+const kDownloadStats = Symbol('downloadStats');
+const kReplaceMap = Symbol('replaceMap');
+const PLATFORM_WIN32 = process.platform === 'win32';
+const PROCESS_TIMEOUT = { filemanager: 0, compress: 0 };
+const CACHE_ETAG = {};
+const DISK = {
+    ENABLED: false,
+    EXPIRES: 0,
+    LIMIT: (0, types_1.formatSize)('1gb'),
+    INCLUDE: [],
+    EXCLUDE: []
+};
+const MEMORY = {
+    ENABLED: false,
+    CACHE: {},
+    SIZE: 0,
+    TOTAL: 0,
+    EXPIRES: 0,
+    LIMIT: (0, types_1.formatSize)('100mb'),
+    LIMIT_ALL: (0, types_1.formatSize)('512mb'),
+    INCLUDE: [],
+    EXCLUDE: [],
+    PURGE: 0.25,
+    DISK_MIN: Infinity,
+    DISK_MAX: 0
+};
+let SESSION_ID = 0;
+let SESSION_LIMIT = 1000;
+let ASSET_ID = 0;
+let RECURSION_LIMIT = 10;
+let LOG_TIMEELAPSED = true;
+let LOG_TIMEPROCESS = true;
+const HTTP_CLIENT = {
+    timeout: 60000 /* TIME.m */,
+    connectTimeout: 20 * 1000 /* TIME.S */,
+    redirectLimit: 3,
+    retryWait: 1000 /* TIME.S */,
+    retryAfter: 30 * 1000 /* TIME.S */,
+    retryLimit: 10
+};
+function applyTimeout(target, options) {
+    for (const name in options) {
+        const value = parseTimeout(options[name]);
+        if (value !== undefined) {
+            target[name] = value;
+        }
+    }
+}
+function parseTimeout(value) {
+    if (+value === 0) {
+        return 0;
+    }
+    if ((value = (0, types_1.parseTime)(value)) > 0) {
+        return value;
+    }
+}
+function withinSizeRange(uri, value, pattern) {
+    const match = (pattern || /\(\s*(\d+)\s*(?:,\s*(\d+|\*)\s*)?\)/).exec(value);
+    const [minSize, maxSize] = match && !match[1] ? [+match[2], !match[3] || match[3] === '*' ? Infinity : +match[3]] : [0, Infinity];
+    if (minSize > 0 || maxSize < Infinity) {
+        const fileSize = (0, lib_v4_1.getSize)(uri);
+        if (fileSize === 0 || fileSize < minSize || fileSize > maxSize) {
+            return false;
+        }
+    }
+    return true;
+}
+function startMessage() {
+    this.formatMessage(128 /* LOG_TYPE.TIME_ELAPSED */, 'START', [new Date().toLocaleString(), this.assets.length + ' assets'], this.baseDirectory, { ...core_1.Host.LOG_STYLE_SUCCESS });
+}
+function clearAssets() {
+    this.assets.forEach(item => {
+        if ('buffer' in item) {
+            delete item.buffer;
+        }
+        if ('sourceUTF8' in item) {
+            delete item.sourceUTF8;
+        }
+    });
+}
+function bundleTorrent(files, mimeType, encoding) {
+    let output = '';
+    for (const file of files) {
+        if (core_1.Host.lookupMime(file) === mimeType) {
+            try {
+                output += fs.readFileSync(file, encoding);
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(file)], err, 32 /* LOG_TYPE.FILE */);
+            }
+        }
+    }
+    return output;
+}
+function resetAssets() {
+    this.reset();
+    FileManager.sanitizeAssets(this.assets);
+}
+function abortedHost() {
+    if (this.finalizeState === 6 /* FINALIZE_STATE.ABORTED */) {
+        this.restarting = false;
+        this.performFinalize(true);
+        return this.done;
+    }
+    return false;
+}
+function observeFile(instance) {
+    instance.on('file:delete', (value, options) => this.delete(value, !!options?.emptyDir));
+    instance.on('file:copy', value => this.add(value));
+    instance.on('file:move', (value, options) => {
+        this.add(value);
+        const src = options?.outSrc;
+        if (src) {
+            this.delete(src);
+        }
+    });
+    instance.on('dir:remove', value => {
+        if (this.removeCwd(value)) {
+            if (PLATFORM_WIN32) {
+                value = value.toLowerCase();
+            }
+            if (value[value.length - 1] !== path.sep) {
+                value += path.sep;
+            }
+            for (const name of this.files) {
+                if ((PLATFORM_WIN32 ? name.toLowerCase() : name).startsWith(value)) {
+                    this.files.delete(name);
+                }
+            }
+        }
+    });
+}
+function setCpuUsage() {
+    const usage = core_1.Host.initCpuUsage(this);
+    if ('startCPU' in this) {
+        this.startCPU = usage;
+    }
+}
+function collectErrors() {
+    const result = [];
+    const clearModule = (instance) => {
+        const { moduleName, errors } = instance;
+        if (errors.length) {
+            errors.forEach(value => result.push(`[${moduleName}] ` + (core_1.Host.asString(value) || "Unknown" /* ERR_MESSAGE.UNKNOWN */)));
+            errors.length = 0;
+        }
+    };
+    this.modules.forEach(instance => clearModule(instance));
+    this.subProcesses.forEach(instance => clearModule(instance));
+    clearModule(this);
+    if (!this.restarting) {
+        queueMicrotask(() => {
+            this.flushLog();
+            this.modules.forEach(instance => instance.flushLog());
+            this.subProcesses.forEach(instance => instance.flushLog());
+            this.close();
+            clearAssets.call(this);
+        });
+    }
+    else {
+        clearAssets.call(this);
+    }
+    return result;
+}
+function rejectModule(err, type, hint) {
+    this.writeFail(["Handled rejection" /* ERR_MESSAGE.HANDLED_REJECTION */, this.moduleName + (hint ? ': ' + hint : '')], err, type);
+}
+const isFunction = (value) => typeof value === 'function';
+const ignoreAsset = (item, exists) => item.invalid || (0, types_1.hasBit)(item.flags, 1 /* ASSET_FLAG.IGNORE */ | (!exists ? 128 /* ASSET_FLAG.EXISTS */ : 0));
+class HttpDiskCache {
+    constructor(host, enabled) {
+        this.host = host;
+        this.limit = DISK.LIMIT;
+        this.expires = DISK.EXPIRES;
+        this._flags = 0;
+        this._exclude = [];
+        this._include = [];
+        this._excludeExt = [];
+        this._includeExt = [];
+        this._items = [];
+        this[KEnabled] = enabled;
+    }
+    has(uri) {
+        if (!this[KEnabled]) {
+            return false;
+        }
+        try {
+            if (typeof uri === 'string') {
+                uri = new URL(uri);
+            }
+        }
+        catch {
+            return false;
+        }
+        const flags = this._flags;
+        if (flags === 0) {
+            return true;
+        }
+        if (flags & 10) {
+            let ext = path.extname(uri.pathname);
+            if (ext) {
+                ext = ext.substring(1);
+                if (flags & 2) {
+                    if (!this._includeExt.some(value => value === ext)) {
+                        return false;
+                    }
+                }
+                else if ((flags & 8) && this._excludeExt.some(value => value === ext)) {
+                    return false;
+                }
+            }
+        }
+        return flags & 1 ? this._include.includes(uri.origin) : !this._exclude.includes(uri.origin);
+    }
+    add(uri, etag, target, { buffer, contentLength = (0, lib_v4_1.getSize)(target) } = {}) {
+        let tempDir;
+        if (contentLength <= this.limit && (tempDir = this.host.getCacheDir(uri))) {
+            const baseDir = path.join(tempDir, etag);
+            const tempUri = path.join(baseDir, path.basename(target));
+            try {
+                if (!fs.existsSync(baseDir)) {
+                    fs.mkdirSync(baseDir);
+                }
+                if (buffer) {
+                    fs.writeFileSync(tempUri, buffer);
+                }
+                else {
+                    fs.copyFileSync(target, tempUri);
+                }
+                const expires = this.expires;
+                if (expires > 0 && expires < Infinity) {
+                    setTimeout(() => this.clear(target), Math.min(expires, core_1.Host.MAX_TIMEOUT));
+                }
+            }
+            catch {
+            }
+        }
+    }
+    within(value) {
+        if (typeof value !== 'number') {
+            value = value.contentLength;
+        }
+        return value > 0 && value <= this.limit;
+    }
+    clear(pathname) {
+        core_1.Host.removeDir(path.dirname(pathname));
+    }
+    set enabled(value) {
+        this[KEnabled] = value;
+    }
+    get enabled() {
+        return this[KEnabled];
+    }
+    set include(value) {
+        this._include = [];
+        this._includeExt = [];
+        if ((0, types_1.isArray)(value)) {
+            for (const item of value) {
+                if (core_1.Host.isURL(item)) {
+                    this._include.push(item);
+                    this._flags |= 1;
+                }
+                else {
+                    this._includeExt.push(item);
+                    this._flags |= 2;
+                }
+            }
+        }
+        else {
+            this._flags &= ~3;
+        }
+    }
+    get include() {
+        return this._include.concat(this._includeExt);
+    }
+    set exclude(value) {
+        this._exclude = [];
+        this._excludeExt = [];
+        if ((0, types_1.isArray)(value)) {
+            for (const item of value) {
+                if (core_1.Host.isURL(item)) {
+                    this._exclude.push(item);
+                    this._flags |= 4;
+                }
+                else {
+                    this._excludeExt.push(item);
+                    this._flags |= 8;
+                }
+            }
+        }
+        else {
+            this._flags &= ~12;
+        }
+    }
+    get exclude() {
+        return this._exclude.concat(this._excludeExt);
+    }
+}
+class HttpMemoryCache extends HttpDiskCache {
+    constructor(host, enabled) {
+        super(host, enabled && core_1.Host.enabled("memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */, host.username));
+        this.limit = MEMORY.LIMIT;
+        this.expires = MEMORY.EXPIRES;
+        this.toDisk = [MEMORY.DISK_MIN, MEMORY.DISK_MAX];
+    }
+    has(uri) {
+        return this.expires > 0 && super.has(uri);
+    }
+    add(uri, etag, buffer, { encoding, toDisk, contentLength = Buffer.byteLength(buffer, encoding) } = {}) {
+        if (contentLength <= this.limit) {
+            if (uri instanceof URL) {
+                uri = uri.href;
+            }
+            MEMORY.SIZE += contentLength;
+            if (MEMORY.SIZE >= MEMORY.LIMIT_ALL) {
+                this.purge(MEMORY.PURGE);
+            }
+            this._items.push(MEMORY.CACHE[uri] = [Date.now(), buffer, encoding, contentLength, uri, etag]);
+            if (this.expires < Infinity) {
+                setTimeout(() => this.clear(uri), Math.min(this.expires, core_1.Host.MAX_TIMEOUT));
+            }
+            ++MEMORY.TOTAL;
+            return;
+        }
+        let tempDir;
+        if (toDisk && this.withinDisk(contentLength) && (tempDir = this.host.getCacheDir(uri))) {
+            try {
+                const baseDir = path.join(tempDir, etag);
+                if (!fs.existsSync(baseDir)) {
+                    fs.mkdirSync(baseDir);
+                }
+                fs.writeFileSync(path.join(baseDir, toDisk), buffer);
+                return;
+            }
+            catch {
+            }
+        }
+        this.clear(uri);
+    }
+    clear(uri) {
+        let items;
+        if (uri) {
+            const item = MEMORY.CACHE[uri instanceof URL ? uri.href : uri];
+            if (!item) {
+                return;
+            }
+            items = [item];
+        }
+        else {
+            items = this._items;
+        }
+        for (const item of items) {
+            const expired = MEMORY.CACHE[uri = item[4]];
+            if (expired) {
+                const size = expired[3];
+                if (size > 0) {
+                    MEMORY.SIZE -= size;
+                }
+                delete MEMORY.CACHE[uri];
+                --MEMORY.TOTAL;
+            }
+        }
+    }
+    purge(percent, limit) {
+        FileManager.purgeMemory(percent, limit);
+    }
+    withinDisk(value) {
+        if (typeof value !== 'number') {
+            value = value.contentLength;
+        }
+        return value >= this.toDisk[0] && value <= this.toDisk[1];
+    }
+}
+class FileThread extends core_1.AbortComponent {
+    constructor(host, file, threadCount) {
+        super();
+        this.file = file;
+        this.threadCount = threadCount;
+        this.mimeType = '';
+        this.startTime = Date.now();
+        this[_a] = [];
+        this[kHost] = host;
+    }
+    openThread(instance, timeout = 0) {
+        return this.host.openThread(instance, this, timeout);
+    }
+    closeThread(instance, callback) {
+        return this.host.closeThread(instance, this, callback);
+    }
+    getObject(data) {
+        const result = { ...data, file: this.file };
+        result.mimeType || (result.mimeType = this.mimeType);
+        return result;
+    }
+    get host() {
+        return this[kHost];
+    }
+    get queuedTasks() {
+        return this[kQueuedTasks];
+    }
+}
+_a = kQueuedTasks;
+class FileManager extends core_1.Host {
+    static async purgeMemory(percent = 1, limit = 0, parent) {
+        if (typeof limit === 'boolean') {
+            parent = limit;
+            limit = 0;
+        }
+        let result = 0;
+        if (limit === 0 || (parent === undefined && limit >= MEMORY.SIZE) || (parent !== undefined && limit > MEMORY.TOTAL)) {
+            const cache = MEMORY.CACHE;
+            if (percent >= 1) {
+                for (const uri in cache) {
+                    delete cache[uri];
+                    ++result;
+                }
+                MEMORY.SIZE = 0;
+                MEMORY.TOTAL = 0;
+            }
+            else if (percent > 0) {
+                const bufferSize = Math.ceil(MEMORY.SIZE * percent);
+                const items = [];
+                let purgeSize = 0;
+                for (const uri in cache) {
+                    const item = cache[uri];
+                    if (item) {
+                        items.push([item, uri]);
+                    }
+                }
+                items.sort((a, b) => a[0][0] - b[0][0]);
+                for (const [item, uri] of items) {
+                    const size = item[3];
+                    if (size > 0) {
+                        purgeSize += size;
+                        MEMORY.SIZE -= size;
+                    }
+                    delete MEMORY.CACHE[uri];
+                    ++result;
+                    if (purgeSize >= bufferSize) {
+                        break;
+                    }
+                }
+                MEMORY.TOTAL = items.length - result;
+            }
+        }
+        return result + (parent && result > 0 ? await super.purgeMemory(typeof parent === 'number' && parent > 0 ? parent : percent, limit, true) : 0);
+    }
+    static loadSettings(settings, permission, password) {
+        if (super.loadSettings(settings, permission, password)) {
+            const { download, request, error, logger } = settings;
+            if ((0, types_1.isPlainObject)(request)) {
+                let { timeout, disk, buffer, connect } = request;
+                if ((timeout = (0, util_1.fromSeconds)(timeout)) >= 0) {
+                    HTTP_CLIENT.timeout = timeout;
+                }
+                if (disk) {
+                    this.defineHttpCache(disk, true);
+                }
+                if (buffer) {
+                    this.defineHttpCache(buffer);
+                }
+                if (connect) {
+                    this.defineHttpConnect(connect);
+                }
+                request_1.default.loadSettings({ process: settings.process, request, download }, password);
+            }
+            if (error) {
+                const value = (0, util_1.asInt)(error.recursion_limit);
+                if (value >= 0 && value < Infinity) {
+                    RECURSION_LIMIT = value;
+                }
+            }
+            if (logger) {
+                let value = logger.session_id;
+                if (value === true) {
+                    SESSION_LIMIT = 1000;
+                }
+                else if (value && (value = +value) > 0) {
+                    SESSION_LIMIT = Math.pow(10, value);
+                }
+            }
+            LOG_TIMEELAPSED = this.hasLogType(128 /* LOG_TYPE.TIME_ELAPSED */);
+            LOG_TIMEPROCESS = this.hasLogType(256 /* LOG_TYPE.TIME_PROCESS */);
+            return true;
+        }
+        return false;
+    }
+    static sanitizeAssets(assets, exclusions = []) {
+        assets.forEach(item => {
+            if ((0, types_1.ignoreFlag)(item.flags)) {
+                return;
+            }
+            const initialValue = item.initialValue;
+            for (const attr in initialValue) {
+                const value = initialValue[attr];
+                if (attr in item && typeof value === 'string') {
+                    item[attr] = value;
+                }
+            }
+            for (const attr in item) {
+                switch (attr) {
+                    case 'flags':
+                        item.flags &= ~(128 /* ASSET_FLAG.EXISTS */ | 16 /* ASSET_FLAG.MODIFIED */);
+                        break;
+                    case 'watch':
+                        if ((0, types_1.isPlainObject)(item.watch) && item.watch.assets) {
+                            delete item.watch.assets;
+                        }
+                    case 'buffer':
+                    case 'sourceUTF8':
+                    case 'sourceFiles':
+                    case 'transforms':
+                    case 'descendants':
+                    case 'torrentFiles':
+                    case 'initialValue':
+                    case 'processModule':
+                    case 'etag':
+                    case 'lastModified':
+                    case 'contentLength':
+                    case 'invalid':
+                        if (!exclusions.includes(attr)) {
+                            delete item[attr];
+                        }
+                        break;
+                }
+            }
+        });
+        return assets;
+    }
+    static createFileThread(host, file) {
+        return new FileThread(host, file, 0);
+    }
+    static setTimeout(options) {
+        applyTimeout(PROCESS_TIMEOUT, options);
+    }
+    static defineHttpCache({ enabled, expires, limit, limit_all, include, exclude, to_disk, purge_amount }, disk) {
+        const cache = disk ? DISK : MEMORY;
+        if (typeof enabled === 'boolean') {
+            cache.ENABLED = enabled;
+        }
+        cache.EXPIRES = expires ? (0, types_1.parseExpires)(expires) : 0;
+        cache.INCLUDE = (0, types_1.isArray)(include) ? include.slice(0) : [];
+        cache.EXCLUDE = (0, types_1.isArray)(exclude) ? exclude.slice(0) : [];
+        const setLimit = (value, type) => {
+            if (value !== undefined) {
+                if (typeof value === 'string') {
+                    value = (0, types_1.formatSize)(value);
+                }
+                if (value >= 0) {
+                    switch (type) {
+                        case 1:
+                            (disk ? DISK : MEMORY).LIMIT = value;
+                            break;
+                        case 2:
+                            MEMORY.LIMIT_ALL = value;
+                            break;
+                        case 3:
+                            MEMORY.DISK_MIN = value;
+                            break;
+                        case 4:
+                            MEMORY.DISK_MAX = value;
+                            break;
+                    }
+                }
+                else if (value === -1) {
+                    switch (type) {
+                        case 3:
+                            MEMORY.DISK_MIN = Infinity;
+                            break;
+                        case 4:
+                            MEMORY.DISK_MAX = 0;
+                            break;
+                    }
+                }
+            }
+        };
+        setLimit(limit, 1);
+        if (disk) {
+            return;
+        }
+        setLimit(limit_all, 2);
+        if (to_disk) {
+            let limit_disk;
+            if (Array.isArray(to_disk)) {
+                [to_disk, limit_disk] = to_disk;
+            }
+            setLimit(to_disk, 3);
+            setLimit(limit_disk, 4);
+        }
+        if ((purge_amount = (0, util_1.asFloat)(purge_amount)) > 0) {
+            MEMORY.PURGE = Math.min(purge_amount, 1);
+        }
+    }
+    static defineHttpConnect({ timeout, retry_wait, retry_after, retry_limit, redirect_limit }) {
+        if ((timeout = (0, util_1.fromSeconds)(timeout)) >= 0) {
+            HTTP_CLIENT.connectTimeout = timeout;
+        }
+        if ((retry_wait = (0, util_1.fromSeconds)(retry_wait)) >= 0) {
+            HTTP_CLIENT.retryWait = Math.min(retry_wait, 600 * 1000 /* TIME.S */);
+        }
+        if ((retry_after = (0, util_1.fromSeconds)(retry_after)) >= 0) {
+            HTTP_CLIENT.retryAfter = Math.min(retry_after, this.MAX_TIMEOUT);
+        }
+        if ((retry_limit = (0, util_1.asInt)(retry_limit)) >= 0) {
+            HTTP_CLIENT.retryLimit = retry_limit;
+        }
+        if ((redirect_limit = (0, util_1.asInt)(redirect_limit)) >= 0) {
+            HTTP_CLIENT.redirectLimit = redirect_limit;
+        }
+    }
+    constructor(baseDirectory, config, permission, postFinalize) {
+        super(config);
+        this.archiving = false;
+        this.finalizeState = 0 /* FINALIZE_STATE.READY */;
+        this.processTimeout = PROCESS_TIMEOUT.filemanager;
+        this.Document = [];
+        this.Task = [];
+        this.Image = null;
+        this.Cloud = null;
+        this.Watch = null;
+        this.Compress = null;
+        this[_b] = 'FileManager';
+        this.documentAssets = [];
+        this.taskAssets = [];
+        this.dataSourceItems = [];
+        this.files = new Set();
+        this.filesQueued = new Set();
+        this.filesToRemove = new Set();
+        this.filesToCompare = new Map();
+        this.contentToAppend = new Map();
+        this.contentToReplace = new Map();
+        this.processing = [];
+        this.fetchedAssets = [];
+        this.copiedAssets = [];
+        this.emptyDir = new Set();
+        this._moduleName = 'filemanager';
+        this._pendingResult = null;
+        this[_c] = 'none';
+        this[_d] = false;
+        this[_e] = 0;
+        this[_f] = false;
+        this[_g] = null;
+        this[_h] = RECURSION_LIMIT;
+        this[_j] = {};
+        this[_k] = [[0, 0], [0, 0], [0, 0]];
+        this[_l] = {};
+        if (typeof permission === 'boolean') {
+            this.archiving = permission;
+            permission = undefined;
+        }
+        else if (isFunction(permission)) {
+            postFinalize = permission;
+            permission = undefined;
+        }
+        else if (!core_1.Host.isPermission(permission)) {
+            permission = undefined;
+        }
+        if (LOG_TIMEPROCESS) {
+            setCpuUsage.call(this);
+        }
+        this[kBaseDirectory] = path.normalize(baseDirectory[baseDirectory.length - 1] === path.sep ? baseDirectory.substring(0, baseDirectory.length - 1) : baseDirectory);
+        this.permission = permission || core_1.Host.getPermissionFromSettings();
+        this.sessionId = (++SESSION_ID === SESSION_LIMIT ? SESSION_ID = 1 : SESSION_ID).toString();
+        const { assets = [], dataSource, timeout } = config;
+        let targeted;
+        for (let i = 0, length = assets.length; i < length; ++i) {
+            const item = assets[i];
+            const encoding = item.encoding;
+            if (item.document) {
+                this.documentAssets.push(item);
+            }
+            if (item.tasks) {
+                this.taskAssets.push(item);
+            }
+            if (encoding) {
+                switch (encoding) {
+                    case 'utf-8':
+                        break;
+                    case 'utf-16':
+                    case 'utf-16be':
+                    case 'utf-16le':
+                        item.encoding = 'utf16le';
+                        break;
+                    default:
+                        item.encoding = (0, types_1.getEncoding)(encoding);
+                        break;
+                }
+            }
+            if ((0, types_1.usingFlag)(item.flags)) {
+                (targeted || (targeted = [])).push(item);
+            }
+            item.id || (item.id = ++ASSET_ID);
+        }
+        this._assets = assets.slice(0);
+        if (targeted) {
+            this.using(...targeted);
+        }
+        if (Array.isArray(dataSource)) {
+            this.dataSourceItems.push(...dataSource);
+        }
+        if (this.willAbort(this)) {
+            this.abortable = true;
+        }
+        if ((0, types_1.isPlainObject)(timeout)) {
+            applyTimeout(this[kProcessTimeout], timeout);
+        }
+        if (isFunction(postFinalize)) {
+            this.on('end', postFinalize);
+        }
+        this.cacheToDisk = new HttpDiskCache(this, DISK.ENABLED);
+        this.cacheToMemory = new HttpMemoryCache(this, MEMORY.ENABLED);
+        if (MEMORY.INCLUDE.length) {
+            this.cacheToMemory.include = MEMORY.INCLUDE;
+        }
+        else if (MEMORY.EXCLUDE.length) {
+            this.cacheToMemory.exclude = MEMORY.EXCLUDE;
+        }
+        const request = new request_1.default();
+        request.host = this;
+        this.Request = request;
+        if (this.aborted) {
+            this.finalizeState = 6 /* FINALIZE_STATE.ABORTED */;
+        }
+        else {
+            request.init(config).apply({ client: HTTP_CLIENT });
+            if (!this.queued) {
+                startMessage.call(this);
+            }
+        }
+    }
+    *[(_b = Symbol.toStringTag, _c = kIncremental, _d = kRestarting, _e = kDelayed, _f = kCleared, _g = KTimerMain, _h = kRecursionLimit, _j = kProcessTimeout, _k = kDownloadStats, _l = kReplaceMap, Symbol.iterator)]() {
+        for (const file of this.files) {
+            yield file;
+        }
+    }
+    add(value, parent, type = types_1.FILE_TYPE.TRANSFORM) {
+        const file = this.removeCwd(value);
+        if (file) {
+            this.files.add(file);
+            if (parent) {
+                if (type & types_1.FILE_TYPE.TRANSFORM) {
+                    const transforms = parent.transforms;
+                    if (!transforms) {
+                        parent.transforms = [value];
+                    }
+                    else if (!transforms.includes(value)) {
+                        transforms.push(value);
+                    }
+                }
+                if (type & types_1.FILE_TYPE.TORRENT) {
+                    const torrent = parent.torrentFiles;
+                    if (!torrent) {
+                        parent.torrentFiles = [value];
+                    }
+                    else if (!torrent.includes(value)) {
+                        torrent.push(value);
+                    }
+                }
+                if ((type & types_1.FILE_TYPE.SOURCEMAP) || (type & types_1.FILE_TYPE.COMPRESSED)) {
+                    const connected = parent.descendants;
+                    if (!connected) {
+                        parent.descendants = [value];
+                    }
+                    else if (!connected.includes(value)) {
+                        connected.push(value);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    delete(value, emptyDir = true) {
+        if (this.files.delete(this.removeCwd(value))) {
+            if (emptyDir) {
+                let dir = this.baseDirectory;
+                for (const seg of path.dirname(value).substring(this.baseDirectory.length + 1).split(path.sep)) {
+                    if (seg) {
+                        dir += path.sep + seg;
+                        this.emptyDir.add(dir);
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    has(value) {
+        return this.files.has(this.removeCwd(value));
+    }
+    keys() {
+        return this.files.keys();
+    }
+    values() {
+        return this.files.values();
+    }
+    entries() {
+        return this.files.entries();
+    }
+    forEach(predicate, thisArg) {
+        this.files.forEach(predicate, thisArg);
+    }
+    clear() {
+        core_1.Host.removeDir(this.baseDirectory, true);
+        this.files.clear();
+    }
+    get size() {
+        return this.files.size;
+    }
+    abort() {
+        this.Request.abort();
+        super.abort();
+    }
+    willAbort(value) {
+        if ((0, types_1.isObject)(value)) {
+            value = value.moduleName;
+        }
+        const error = this.config.error;
+        return !!error && (0, types_1.isArray)(error.abort) && error.abort.includes(value);
+    }
+    restart(recursive, exclusions, emptyDir) {
+        if (recursive === 'abort') {
+            this.restarting = false;
+            this.performFinalize(true);
+            return;
+        }
+        if (typeof exclusions === 'boolean') {
+            emptyDir = exclusions;
+            exclusions = undefined;
+        }
+        if (this.restartable && (!recursive || --this[kRecursionLimit] >= 0)) {
+            if (this.reset()) {
+                this.finalizeState = 5 /* FINALIZE_STATE.RESTARTED */;
+                FileManager.sanitizeAssets(this.assets, exclusions);
+                for (const { instance } of this.Document) {
+                    instance.restart();
+                }
+                startMessage.call(this);
+                this.processAssets(emptyDir);
+            }
+            else {
+                this.writeFail('Unable to restart during finalization', (0, types_1.errorMessage)('Session ID', this.sessionId));
+            }
+        }
+        else {
+            this.restarting = false;
+        }
+    }
+    loadModule(name, ...args) {
+        const loaded = super.loadModule(name, ...args);
+        if (loaded) {
+            return loaded;
+        }
+        switch (name) {
+            case 'cloud': {
+                const instance = new cloud_1.default(args[0]);
+                instance.host = this;
+                instance.init(this.config);
+                observeFile.call(this, instance);
+                return this.Cloud = instance;
+            }
+            case 'watch': {
+                const instance = new watch_1.default(...args);
+                instance.host = this;
+                instance.init(this.config);
+                observeFile.call(this, instance);
+                return this.Watch = instance;
+            }
+            case 'compress': {
+                const instance = new compress_1.default(args[0]);
+                instance.host = this;
+                instance.init();
+                observeFile.call(this, instance);
+                return this.Compress = instance;
+            }
+            default:
+                return null;
+        }
+    }
+    reset() {
+        if (this.finalizeState === 1 /* FINALIZE_STATE.COMMIT */) {
+            return false;
+        }
+        super.reset();
+        this.clearProcessTimeout();
+        this.files.clear();
+        this.filesQueued.clear();
+        this.filesToRemove.clear();
+        this.filesToCompare.clear();
+        this.contentToAppend.clear();
+        this.contentToReplace.clear();
+        this.processing.length = 0;
+        this.Request.reset();
+        this.modules.forEach(instance => instance.reset());
+        this.emptyDir.clear();
+        if (!this.restarting) {
+            this.close();
+            this._pendingResult = null;
+        }
+        clearAssets.call(this);
+        this.cleared = false;
+        this[kDelayed] = 0;
+        this.finalizeState = 0 /* FINALIZE_STATE.READY */;
+        return true;
+    }
+    deleteFile(value, options = {}, callback) {
+        if (super.deleteFile(value, options, callback)) {
+            let emptyDir = false;
+            if ((0, types_1.isPlainObject)(options)) {
+                if (options.emptyDir) {
+                    emptyDir = true;
+                }
+                if (options.all) {
+                    value = path.resolve(value);
+                    (options.id ? [this.assets.find(item => item.id === options.id)].filter(item => item) : this.assets.filter(item => item.localUri === value)).forEach(asset => {
+                        asset.transforms?.forEach(file => this.deleteFile(file, emptyDir));
+                        asset.descendants?.forEach(file => this.deleteFile(file, emptyDir));
+                    });
+                }
+            }
+            this.delete(value, emptyDir);
+            return true;
+        }
+        return false;
+    }
+    resumeThread(options) {
+        if (this.aborted || options.aborted) {
+            this.finalizeState = 0 /* FINALIZE_STATE.READY */;
+            this.performFinalize(true);
+            return;
+        }
+        this.finalizeState = 5 /* FINALIZE_STATE.RESTARTED */;
+        startMessage.call(this);
+        this.processAssets(...options.args);
+    }
+    install(name, ...args) {
+        if (this.aborted) {
+            return;
+        }
+        const target = args.shift();
+        switch (name) {
+            case 'document':
+                if (isFunction(target) && target.prototype instanceof document_1.default) {
+                    const instance = new target(...args);
+                    instance.host = this;
+                    instance.init(this.getDocumentAssets(instance), this.config);
+                    observeFile.call(this, instance);
+                    this.Document.push({ instance, constructor: target, params: args });
+                    return instance;
+                }
+                break;
+            case 'task':
+                if (isFunction(target) && target.prototype instanceof task_1.default && (0, types_1.isPlainObject)(args[0])) {
+                    const instance = new target(...args);
+                    instance.host = this;
+                    instance.init(this.config);
+                    observeFile.call(this, instance);
+                    this.Task.push({ instance, constructor: target, params: args });
+                    return instance;
+                }
+                break;
+            case 'cloud': {
+                const database = this.dataSourceItems.filter(item => item.source === 'cloud');
+                let instance;
+                if (typeof target === 'string') {
+                    const module = args.shift();
+                    if ((0, types_1.isObject)(module)) {
+                        if (target === "@e-mc/cloud" /* PACKAGE_NAME.CLOUD */) {
+                            instance = new cloud_1.default(module, database);
+                        }
+                        else {
+                            try {
+                                const Handler = require(target);
+                                if (isFunction(Handler) && Handler.prototype instanceof cloud_1.default) {
+                                    instance = new Handler(module, database);
+                                }
+                                else {
+                                    throw (0, types_1.errorMessage)(this.moduleName, "Not a Cloud constructor" /* ERR_CLOUD.CONSTRUCTOR */, target);
+                                }
+                            }
+                            catch (err) {
+                                this.checkPackage(err, target, ["Unable to load handler" /* ERR_MESSAGE.LOAD_HANDLER */, this.moduleName], 64 /* LOG_TYPE.CLOUD */);
+                            }
+                        }
+                    }
+                }
+                else if ((0, types_1.isObject)(target)) {
+                    instance = new cloud_1.default(target, database);
+                }
+                if (instance) {
+                    instance.host = this;
+                    instance.init(this.config);
+                    observeFile.call(this, instance);
+                    return this.Cloud = instance;
+                }
+                break;
+            }
+            case 'watch': {
+                const instance = (0, types_1.isObject)(target) ? new watch_1.default(target) : new watch_1.default(target, args[0], args[1], args[2]);
+                instance.host = this;
+                instance.init(this.config);
+                instance.whenModified = (assets, sanitize, postFinalize) => {
+                    if (typeof sanitize === 'function') {
+                        postFinalize = sanitize;
+                        sanitize = true;
+                    }
+                    if (sanitize) {
+                        FileManager.sanitizeAssets(assets);
+                        for (const { instance: document, constructor } of this.Document) {
+                            if (constructor.sanitizeAssets) {
+                                constructor.sanitizeAssets(assets.filter(item => this.hasDocument(document, item.document)));
+                            }
+                        }
+                    }
+                    const manager = new FileManager(this.baseDirectory, { ...this.config, incremental: 'none', assets }, postFinalize);
+                    for (const { constructor, params } of this.Document) {
+                        manager.install('document', constructor, ...params);
+                    }
+                    for (const { constructor, params } of this.Task) {
+                        manager.install('task', constructor, ...params);
+                    }
+                    if (this.Cloud) {
+                        manager.install('cloud', this.Cloud.module);
+                    }
+                    if (this.Image) {
+                        for (const handler of this.Image) {
+                            if ((0, types_1.isPlainObject)(handler)) {
+                                const image = handler.instance;
+                                image.reset();
+                                image.host = manager;
+                                observeFile.call(manager, image);
+                            }
+                        }
+                        manager.Image = this.Image;
+                    }
+                    manager.Compress = this.Compress;
+                    manager.sessionId = this.sessionId;
+                    manager.permission = this.permission;
+                    manager.cacheToDisk = this.cacheToDisk;
+                    manager.cacheToMemory = this.cacheToMemory;
+                    if (postFinalize) {
+                        try {
+                            manager.processAssets();
+                        }
+                        catch (err) {
+                            manager.writeFail("Unknown" /* ERR_MESSAGE.UNKNOWN */, err, { startTime: manager.startTime });
+                        }
+                    }
+                    return manager;
+                };
+                return this.Watch = instance;
+            }
+            case 'image':
+                if (target instanceof Map) {
+                    const handler = new Map();
+                    for (const [mimeType, constructor] of target) {
+                        if (constructor.prototype instanceof image_1.default) {
+                            const instance = new constructor(args[0]);
+                            instance.host = this;
+                            instance.init(this.config);
+                            observeFile.call(this, instance);
+                            handler.set(mimeType, { constructor, instance, params: [] });
+                        }
+                    }
+                    if (handler.size) {
+                        this.Image = handler;
+                    }
+                }
+                break;
+            case 'compress': {
+                const instance = new compress_1.default(target);
+                instance.host = this;
+                instance.init();
+                observeFile.call(this, instance);
+                return this.Compress = instance;
+            }
+        }
+    }
+    findAsset(value, instance) {
+        let assets, replaced;
+        if ((0, types_1.isPlainObject)(instance)) {
+            ({ instance, assets, replaced } = instance);
+        }
+        let origin, pathname;
+        if (typeof value === 'string') {
+            if (core_1.Host.isURL(value, 'file')) {
+                try {
+                    ({ origin, pathname, href: value } = new URL(value));
+                }
+                catch {
+                    return;
+                }
+            }
+            else {
+                value = core_1.Host.resolveFile(value);
+            }
+        }
+        else {
+            ({ origin, pathname, href: value } = value);
+        }
+        if (value) {
+            const isSame = (a, b) => a === b || decodeURIComponent(a) === decodeURIComponent(b);
+            const result = (assets || this.assets).filter(item => {
+                let { uri, flags } = item;
+                if (uri && (!instance || this.hasDocument(instance, item.document)) && (!item.invalid || assets || (0, types_1.mainFlag)(flags) || (0, types_1.usingFlag)(flags) || (0, types_1.cloneFlag)(flags) || (0, types_1.watchFlag)(flags))) {
+                    if (origin) {
+                        if (!item.url) {
+                            try {
+                                if ((item.url = new URL(uri)).href === value) {
+                                    return true;
+                                }
+                            }
+                            catch {
+                            }
+                        }
+                        else if (item.url.href === value) {
+                            return true;
+                        }
+                    }
+                    if (isSame(uri, value)) {
+                        return true;
+                    }
+                    const indexA = uri.indexOf('#');
+                    const indexB = value.indexOf('#');
+                    if (indexA !== -1 || indexB !== -1) {
+                        if (indexA !== -1) {
+                            uri = uri.substring(0, indexA);
+                        }
+                        if (indexB !== -1) {
+                            value = value.substring(0, indexB);
+                        }
+                        return isSame(uri, value);
+                    }
+                }
+                return false;
+            });
+            if (replaced) {
+                const map = this[kReplaceMap];
+                const target = pathname || core_1.Host.toPosix(value);
+                const found = [];
+                for (const relative in map) {
+                    const item = map[relative];
+                    if (origin && item.url && item.url.origin !== origin) {
+                        continue;
+                    }
+                    if (path.basename(relative) === path.basename(target) && path.dirname(target).endsWith(path.dirname(relative))) {
+                        found.push([item, relative]);
+                    }
+                }
+                if (found.length) {
+                    if (result.length === 0) {
+                        return found.sort((a, b) => b[1].length - a[1].length)[0][0];
+                    }
+                    result.push(...found.map(item => item[0]));
+                }
+            }
+            return result.sort((a, b) => {
+                if ((a.content || a.base64) && !b.content && !b.base64 || a.uri === value && b.uri !== value) {
+                    return -1;
+                }
+                if ((b.content || b.base64) && !a.content && !a.base64 || b.uri === value && a.uri !== value) {
+                    return 1;
+                }
+                const bundleId = a.bundleId;
+                if (((0, types_1.isEmpty)(bundleId) || a.bundleIndex === 0) && ((0, types_1.isEmpty)(b.bundleId) || b.bundleIndex === 0)) {
+                    if (a.id && b.id) {
+                        return a.id < b.id ? -1 : 1;
+                    }
+                }
+                else if (!(0, types_1.isEmpty)(bundleId) && bundleId === b.bundleId) {
+                    return a.bundleIndex < b.bundleIndex ? -1 : 1;
+                }
+                return 0;
+            })[0];
+        }
+    }
+    removeAsset(file) {
+        const localUri = file.localUri;
+        if (this.has(localUri)) {
+            this.filesToRemove.add(localUri);
+            return true;
+        }
+        return false;
+    }
+    removeCwd(value) {
+        if (typeof value === 'string') {
+            let baseDir = this.baseDirectory + path.sep, leading = value.substring(0, baseDir.length);
+            if (PLATFORM_WIN32) {
+                baseDir = baseDir.toLowerCase();
+                leading = leading.toLowerCase();
+            }
+            if (leading === baseDir) {
+                return value.substring(baseDir.length);
+            }
+        }
+        return '';
+    }
+    replace(file, replaceWith, mimeType) {
+        let ignoreExt, rewritePath;
+        if ((0, types_1.isPlainObject)(mimeType)) {
+            ({ mimeType, ignoreExt, rewritePath } = mimeType);
+        }
+        const { pathname, filename, localUri } = file;
+        if (replaceWith !== localUri) {
+            const name = path.basename(replaceWith);
+            if (!ignoreExt && localUri && path.extname(localUri) === path.extname(replaceWith)) {
+                try {
+                    if (!core_1.Host.renameFile(replaceWith, localUri)) {
+                        this.filesToRemove.add(replaceWith);
+                    }
+                }
+                catch (err) {
+                    this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, name], err, 32 /* LOG_TYPE.FILE */);
+                    return false;
+                }
+            }
+            else {
+                (0, asset_1.setInitialValue)(file);
+                if (rewritePath || !localUri) {
+                    file.pathname = this.removeCwd(path.dirname(replaceWith));
+                }
+                file.filename = name;
+                const replacePath = this.setLocalUri(file, true).localUri;
+                if (replaceWith !== replacePath) {
+                    try {
+                        if (!core_1.Host.renameFile(replaceWith, replacePath)) {
+                            this.filesToRemove.add(replaceWith);
+                        }
+                    }
+                    catch (err) {
+                        file.pathname = pathname;
+                        file.filename = filename;
+                        this.setLocalUri(file, true);
+                        this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, name], err, 32 /* LOG_TYPE.FILE */);
+                        return false;
+                    }
+                }
+                file.mimeType = mimeType || core_1.Host.lookupMime(name) || file.mimeType;
+                this.add(replaceWith);
+                if (localUri && !this.assets.find(item => item.localUri === localUri && !item.invalid)) {
+                    this.filesToRemove.add(localUri);
+                }
+                this[kReplaceMap][core_1.Host.joinPath(file.pathname, file.filename)] = file;
+            }
+        }
+        delete file.buffer;
+        delete file.sourceUTF8;
+        return true;
+    }
+    rename(file, value) {
+        const segments = [file.pathname, value];
+        if (file.moveTo) {
+            segments.unshift(file.moveTo);
+        }
+        const oldPath = file.localUri;
+        const newPath = path.join(this.baseDirectory, ...segments);
+        if (oldPath !== newPath) {
+            if (oldPath) {
+                const copy = this.assets.find(other => file !== other && oldPath === other.localUri);
+                try {
+                    if (fs.existsSync(oldPath)) {
+                        if (copy) {
+                            fs.copyFileSync(oldPath, newPath);
+                        }
+                        else if (!core_1.Host.renameFile(oldPath, newPath)) {
+                            this.filesToRemove.add(oldPath);
+                        }
+                    }
+                }
+                catch (err) {
+                    this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, path.basename(value)], err, 32 /* LOG_TYPE.FILE */);
+                    return false;
+                }
+                if (!copy) {
+                    this.delete(oldPath);
+                }
+            }
+            (0, asset_1.setInitialValue)(file);
+            file.filename = value;
+            this.add(file.localUri = this.setLocalUri(file, true).localUri);
+        }
+        return true;
+    }
+    performAsyncTask() {
+        ++this[kDelayed];
+    }
+    removeAsyncTask() {
+        --this[kDelayed];
+    }
+    completeAsyncTask(err, uri, parent, type) {
+        if (this[kDelayed] !== Infinity) {
+            if (!err && uri) {
+                this.add(uri, parent, type);
+            }
+            this.removeAsyncTask();
+            this.performFinalize();
+        }
+        if (err) {
+            this.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, uri], err, 32 /* LOG_TYPE.FILE */);
+        }
+    }
+    performFinalize(override) {
+        const state = this.finalizeState;
+        if (state === 0 /* FINALIZE_STATE.READY */ && (this.cleared && this[kDelayed] <= 0 || override) || (this.aborted || state === 3 /* FINALIZE_STATE.RESTART */) && override) {
+            this.clearProcessTimeout();
+            this[kDelayed] = Infinity;
+            const resetState = () => {
+                this.finalizeState = 2 /* FINALIZE_STATE.END */;
+                this._pendingResult = null;
+            };
+            const aborted = (err) => {
+                if (!this.restarting) {
+                    this.writeFail(["Transaction was not completed" /* ERR_MESSAGE.INCOMPLETE */, this.baseDirectory], err);
+                    resetState();
+                }
+                else {
+                    this.finalizeState = 4 /* FINALIZE_STATE.QUEUED */;
+                }
+                this.emit('end', [], collectErrors.call(this), this.collectLog());
+                if (!this.restarting) {
+                    this.done = true;
+                }
+            };
+            if (this.aborted) {
+                aborted((0, types_1.createAbortError)());
+                return;
+            }
+            this.finalizeState = 1 /* FINALIZE_STATE.COMMIT */;
+            this.finalize()
+                .then(() => {
+                const errors = collectErrors.call(this);
+                const files = Array.from(this.files).sort((a, b) => {
+                    const sep = path.sep;
+                    if (a.indexOf(sep) !== -1 && b.indexOf(sep) === -1) {
+                        return -1;
+                    }
+                    if (a.indexOf(sep) === -1 && b.indexOf(sep) !== -1) {
+                        return 1;
+                    }
+                    return a < b ? -1 : 1;
+                });
+                if (LOG_TIMEELAPSED) {
+                    this.writeTimeElapsed('END', this.baseDirectory, this.startTime, errors.length > 0 ? { failed: true, ...core_1.Host.LOG_STYLE_FAIL } : { ...core_1.Host.LOG_STYLE_SUCCESS });
+                }
+                resetState();
+                const log = this.config.log;
+                let useNumeric = false, showSize = true;
+                if ((0, types_1.isPlainObject)(log)) {
+                    ({ useNumeric, showSize = true } = log);
+                }
+                const items = !showSize ? files : files.map(name => {
+                    const size = (0, lib_v4_1.getSize)(path.join(this.baseDirectory, name));
+                    return { name, size: useNumeric ? size : (0, types_1.formatSize)(size) };
+                });
+                this.emit('end', items, errors, this.collectLog());
+                this.done = true;
+            })
+                .catch(err => aborted(err));
+        }
+    }
+    hasDocument(instance, document) {
+        const moduleName = instance.moduleName;
+        return document === moduleName || Array.isArray(document) && document.includes(moduleName);
+    }
+    setLocalUri(file, replace) {
+        let uri = file.uri, torrent;
+        if (uri && !file.content && !file.base64 && !file.url) {
+            if (core_1.Host.isFile(uri, 'torrent')) {
+                torrent = true;
+            }
+            else if (core_1.Host.isURL(uri, 'file')) {
+                if (!core_1.Host.isFile(uri, 's/ftp')) {
+                    try {
+                        file.url = new URL(uri);
+                        file.uri = file.url.toString();
+                    }
+                    catch (err) {
+                        this.writeFail(['Unable to parse URL', uri], err, 1024 /* LOG_TYPE.HTTP */);
+                        return { pathname: '', localUri: '' };
+                    }
+                }
+            }
+            else {
+                try {
+                    const errorAbsolute = (value) => (0, types_1.errorValue)('Path not absolute', value);
+                    if (!(file.uri = core_1.Host.resolveFile(uri))) {
+                        throw errorAbsolute(uri);
+                    }
+                    if (file.socketPath) {
+                        if (!path.isAbsolute(file.socketPath)) {
+                            throw errorAbsolute(file.socketPath);
+                        }
+                        if (!path.isAbsolute(uri = file.uri)) {
+                            throw errorAbsolute(uri);
+                        }
+                        const url = new URL('file://' + uri);
+                        file.url = url;
+                        file.uri = url.toString();
+                    }
+                }
+                catch (err) {
+                    this.writeFail(['Unable to resolve file location', uri], err, 32 /* LOG_TYPE.FILE */);
+                    return { pathname: '', localUri: '' };
+                }
+            }
+        }
+        const url = file.url;
+        let type;
+        if (url) {
+            if (url.protocol.startsWith('http')) {
+                type = 1 /* FETCH_TYPE.HTTP */;
+            }
+            else if (file.socketPath && url.protocol === 'file:') {
+                type = 2 /* FETCH_TYPE.UNIX_SOCKET */;
+            }
+        }
+        if (!type && uri) {
+            if (core_1.Host.isFile(uri, 'torrent')) {
+                type = 4 /* FETCH_TYPE.TORRENT */;
+            }
+            else if (core_1.Host.isFile(uri, 's/ftp')) {
+                type = 3 /* FETCH_TYPE.FTP */;
+            }
+        }
+        file.fetchType = type;
+        const segments = [];
+        if (file.moveTo) {
+            segments.push(file.moveTo);
+        }
+        if (file.pathname) {
+            segments.push(file.pathname = core_1.Host.toPosix(file.pathname));
+        }
+        if (file.document) {
+            for (const { instance } of this.Document) {
+                if (instance.setLocalUri && this.hasDocument(instance, file.document)) {
+                    instance.setLocalUri(file, replace);
+                }
+            }
+        }
+        const pathname = segments.length ? path.join(this.baseDirectory, ...segments) : this.baseDirectory;
+        const localUri = file.filename ? path.join(pathname, file.filename) : pathname;
+        file.localUri = localUri;
+        if (!torrent) {
+            file.mimeType || (file.mimeType = file.url && core_1.Host.lookupMime(path.basename(file.url.pathname)) || core_1.Host.lookupMime(file.filename));
+        }
+        return { pathname, localUri };
+    }
+    getLocalUri(data) {
+        return data.file.localUri || '';
+    }
+    getMimeType(data) {
+        return data.mimeType || (data.mimeType = data.file.mimeType || core_1.Host.lookupMime(path.basename(this.getLocalUri(data))));
+    }
+    getDocumentAssets(instance, condition) {
+        return this.documentAssets.filter(item => this.hasDocument(instance, item.document) && (!condition || condition(item)));
+    }
+    getDataSourceItems(instance, condition) {
+        return this.dataSourceItems.filter(item => this.hasDocument(instance, item.document) && (!condition || condition(item)));
+    }
+    getUTF8String(file, uri) {
+        let sourceUTF8 = file.sourceUTF8;
+        if (!sourceUTF8) {
+            file.encoding = (0, types_1.getEncoding)(file.encoding);
+            if (file.buffer) {
+                sourceUTF8 = file.buffer.toString(file.encoding);
+                delete file.buffer;
+            }
+            else if (uri || (uri = file.localUri)) {
+                try {
+                    sourceUTF8 = fs.readFileSync(uri, file.encoding);
+                }
+                catch (err) {
+                    this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(uri)], err, 32 /* LOG_TYPE.FILE */);
+                }
+            }
+            if (sourceUTF8?.[0] === '\uFEFF' && file.encoding !== 'utf16le') {
+                sourceUTF8 = sourceUTF8.substring(1);
+            }
+            return file.sourceUTF8 = sourceUTF8 || '';
+        }
+        return sourceUTF8;
+    }
+    getBuffer(file) {
+        if (file.buffer) {
+            return file.buffer;
+        }
+        const uri = file.localUri;
+        if (uri) {
+            try {
+                return fs.readFileSync(uri);
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(uri)], err, 32 /* LOG_TYPE.FILE */);
+            }
+        }
+        return file.base64 ? Buffer.from(file.base64, 'base64') : null;
+    }
+    getCacheDir(url, createDir = true) {
+        if (typeof url === 'string') {
+            try {
+                url = new URL(url);
+            }
+            catch {
+                return '';
+            }
+        }
+        return this.getTempDir({ pathname: url.hostname + '_' + (url.port || (url.protocol === 'https:' ? '443' : '80')), moduleDir: true, createDir });
+    }
+    setAssetContent(file, content, options) {
+        let trailing = (0, util_2.concatString)(file.trailingContent);
+        if (file.document) {
+            for (const { instance } of this.Document) {
+                if (instance.resolveUri && this.hasDocument(instance, file.document)) {
+                    if (trailing) {
+                        [content, trailing] = instance.resolveUri(file, content, trailing);
+                    }
+                    else {
+                        content = instance.resolveUri(file, content);
+                    }
+                }
+            }
+        }
+        if (trailing) {
+            content += trailing;
+            file.trailingContent = trailing;
+        }
+        if (options) {
+            const { localUri, bundleIndex = 0 } = options;
+            if (bundleIndex > 0) {
+                let appending = this.contentToAppend.get(localUri), replacing = this.contentToReplace.get(localUri);
+                if (!appending) {
+                    this.contentToAppend.set(localUri, appending = []);
+                }
+                if (!replacing) {
+                    this.contentToReplace.set(localUri, replacing = []);
+                }
+                appending[bundleIndex - 1] = content;
+                if ((0, types_1.isString)(options.bundleReplace)) {
+                    replacing[bundleIndex - 1] = options.bundleReplace;
+                }
+                file.invalid = true;
+                return '';
+            }
+        }
+        return file.sourceUTF8 = content;
+    }
+    getAssetContent({ localUri, document, mimeType }, content) {
+        const appending = this.contentToAppend.get(localUri);
+        if (appending) {
+            let newline;
+            const getSeparator = (value) => newline || (newline = (0, util_2.getNewline)(value));
+            if (content) {
+                const replacing = this.contentToReplace.get(localUri);
+                if (replacing?.length) {
+                    for (let i = 0; i < replacing.length; ++i) {
+                        let value = appending[i];
+                        if ((0, types_1.isString)(value)) {
+                            if (replacing[i]) {
+                                const match = new RegExp(replacing[i], 'i').exec(content);
+                                if (match) {
+                                    if (document) {
+                                        for (const { instance } of this.Document) {
+                                            if (instance.replaceContent && this.hasDocument(instance, document)) {
+                                                const output = instance.replaceContent(value, match, mimeType);
+                                                if (output) {
+                                                    value = output;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    content = content.substring(0, match.index) + value + getSeparator(content) + content.substring(match.index + match[0].length);
+                                    continue;
+                                }
+                            }
+                            content += getSeparator(content) + value;
+                        }
+                    }
+                    return content;
+                }
+            }
+            return (content || '') + appending.reduce((a, b) => b ? a + getSeparator(b) + b : a, '');
+        }
+        return content;
+    }
+    writeBuffer(file, options) {
+        const buffer = file.sourceUTF8 ? Buffer.from(file.sourceUTF8, file.encoding || (file.encoding = 'utf-8')) : file.buffer;
+        const localUri = file.localUri;
+        if (buffer && localUri) {
+            try {
+                this.writeFile(localUri, buffer, { ...options, throwsPermission: true });
+                return file.buffer = buffer;
+            }
+            catch (err) {
+                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(localUri)], err, 8192 /* LOG_TYPE.PERMISSION */);
+            }
+        }
+        return null;
+    }
+    writeImage(document, output) {
+        output.baseDirectory || (output.baseDirectory = this.baseDirectory);
+        for (const { instance } of this.Document) {
+            if (instance.writeImage && this.hasDocument(instance, document) && instance.writeImage(output)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    addCopy(data, saveAs, replace = true) {
+        const localUri = this.getLocalUri(data);
+        if (!localUri) {
+            return;
+        }
+        const document = data.file.document;
+        const ext = path.extname(localUri).substring(1);
+        let output;
+        saveAs || (saveAs = ext);
+        if (document) {
+            for (const { instance } of this.Document) {
+                if (instance.addCopy && this.hasDocument(instance, document) && (output = instance.addCopy(data, saveAs, replace))) {
+                    this.filesQueued.add(output);
+                    return output;
+                }
+            }
+        }
+        if (data.outputType && this.getMimeType(data) === data.outputType || ext === saveAs) {
+            if (!replace || this.filesQueued.has(localUri)) {
+                let i = 1;
+                do {
+                    output = (0, types_1.renameExt)(localUri, '__copy__.' + (i > 1 ? `(${i}).` : '') + saveAs);
+                } while (this.filesQueued.has(output) && ++i);
+                try {
+                    fs.copyFileSync(localUri, output);
+                }
+                catch (err) {
+                    this.writeFail(["Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, path.basename(localUri)], err, 32 /* LOG_TYPE.FILE */);
+                    return;
+                }
+            }
+        }
+        else {
+            let i = 1;
+            do {
+                output = (0, types_1.renameExt)(localUri, (i > 1 ? `(${i}).` : '') + saveAs);
+                if (replace) {
+                    break;
+                }
+            } while (this.filesQueued.has(output) && ++i);
+        }
+        this.filesQueued.add(output || (output = localUri));
+        return output;
+    }
+    async findMime(file, rename) {
+        const localUri = file.localUri;
+        if (!localUri) {
+            return '';
+        }
+        let mimeType = '', ext;
+        try {
+            const result = await core_1.Host.resolveMime(file.buffer || localUri);
+            if (result) {
+                ({ mime: mimeType, ext } = result);
+            }
+        }
+        catch (err) {
+            this.writeFail(["Unable to read buffer" /* ERR_MESSAGE.READ_BUFFER */, path.basename(localUri)], err, 32 /* LOG_TYPE.FILE */);
+        }
+        if (rename) {
+            if (!ext) {
+                file.invalid = true;
+            }
+            else {
+                const output = (0, types_1.renameExt)(localUri, ext);
+                if (localUri !== output) {
+                    try {
+                        const success = core_1.Host.renameFile(localUri, output);
+                        this.replace(file, output, mimeType);
+                        if (!success) {
+                            this.filesToRemove.add(localUri);
+                        }
+                    }
+                    catch (err) {
+                        this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, path.basename(output)], err, 32 /* LOG_TYPE.FILE */);
+                    }
+                }
+            }
+        }
+        if (mimeType) {
+            file.mimeType = mimeType;
+        }
+        return mimeType;
+    }
+    compressFile(file, overwrite = true) {
+        const { localUri, compress } = file;
+        const instance = this.Compress;
+        if (instance && compress && localUri && (this.has(localUri) || (0, types_1.existsFlag)(file.flags))) {
+            const tasks = [];
+            for (const config of compress) {
+                const { format, condition } = config;
+                let output;
+                switch (format) {
+                    case 'br':
+                        config.mimeType || (config.mimeType = file.mimeType);
+                    case 'gz':
+                        output = localUri + '.' + format;
+                        break;
+                    case 'woff':
+                    case 'woff2':
+                        output = (0, types_1.renameExt)(localUri, format);
+                        config.filename = file.filename;
+                        config.etag = file.etag;
+                        break;
+                    default:
+                        if (format && typeof instance.compressors[format] === 'function') {
+                            output = (0, types_1.renameExt)(localUri, format);
+                        }
+                        break;
+                }
+                if (output && (!condition || withinSizeRange(localUri, condition))) {
+                    try {
+                        if (overwrite || !fs.existsSync(output) || !(0, types_1.existsFlag)(file.flags) && fs.statSync(output).mtimeMs < this.startTime) {
+                            config.timeout = this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress;
+                            tasks.push(instance.tryFile(file.buffer || localUri, output, config, (err, result) => {
+                                if (err) {
+                                    this.writeFail(["Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, path.basename(localUri)], err, { type: 8 /* LOG_TYPE.COMPRESS */, startTime: config.startTime });
+                                }
+                                else if ((0, types_1.isString)(result)) {
+                                    if (condition?.includes('%') && (0, lib_v4_1.getSize)(result) >= (0, lib_v4_1.getSize)(localUri)) {
+                                        queueMicrotask(() => this.deleteFile(result));
+                                    }
+                                    else {
+                                        this.add(result, file, types_1.FILE_TYPE.COMPRESSED);
+                                    }
+                                }
+                            }));
+                        }
+                    }
+                    catch (err) {
+                        this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(output)], err, 32 /* LOG_TYPE.FILE */);
+                    }
+                }
+            }
+            if (tasks.length) {
+                return Promise.all(tasks);
+            }
+        }
+        return Promise.resolve([]);
+    }
+    async transformAsset(data, parent) {
+        const file = data.file;
+        const localUri = this.getLocalUri(data);
+        if (!this.aborted) {
+            this.processing.push(data);
+            let mimeType = file.mimeType;
+            if ((mimeType?.endsWith('unknown') || file.commands && !mimeType) && (mimeType = await this.findMime(data.file, true))) {
+                file.mimeType = mimeType;
+                data.mimeType = mimeType;
+            }
+            const errorAsset = (instance, err, type = 4 /* LOG_TYPE.PROCESS */) => rejectModule.call(instance, err, type, path.basename(localUri));
+            if (file.tasks) {
+                const taskName = [];
+                for (const { task, handler: moduleName, preceding } of file.tasks) {
+                    if (task && preceding && moduleName && !taskName.includes(moduleName) && !data.aborted) {
+                        const handler = this.Task.find(item => item.instance.moduleName === moduleName);
+                        if (handler) {
+                            const { instance, constructor } = handler;
+                            if (instance.using || constructor.using) {
+                                try {
+                                    if (instance.threadable) {
+                                        if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
+                                            (instance.using ? instance.using(data) : constructor.using.call(this, instance, [file], true))
+                                                .then(() => this.closeThread(instance, data))
+                                                .catch(err => {
+                                                this.closeThread(instance, data);
+                                                errorAsset(instance, err);
+                                            });
+                                        }
+                                    }
+                                    else if (!this.aborted) {
+                                        this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
+                                        await (instance.using ? instance.using(data) : constructor.using.call(this, instance, [file], true));
+                                    }
+                                }
+                                catch (err) {
+                                    errorAsset(instance, err);
+                                }
+                                taskName.push(moduleName);
+                            }
+                        }
+                    }
+                }
+            }
+            if (image_1.default.isBinary(mimeType)) {
+                if (file.commands && this.Image) {
+                    const handler = this.Image.get(mimeType) || this.Image.get('handler');
+                    if (handler) {
+                        const { instance, constructor } = handler;
+                        if (instance.using || constructor.using) {
+                            for (const command of file.commands) {
+                                if (withinSizeRange(localUri, command, constructor.REGEXP_SIZERANGE) && !data.aborted) {
+                                    try {
+                                        if (instance.threadable) {
+                                            if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
+                                                (instance.using ? instance.using(data, command) : constructor.using.call(this, instance, data, command))
+                                                    .then(() => this.closeThread(instance, data))
+                                                    .catch(err => {
+                                                    this.closeThread(instance, data);
+                                                    errorAsset(instance, err, 2048 /* LOG_TYPE.IMAGE */);
+                                                });
+                                            }
+                                        }
+                                        else if (!this.aborted) {
+                                            this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
+                                            await (instance.using ? instance.using(data, command) : constructor.using.call(this, instance, data, command));
+                                        }
+                                    }
+                                    catch (err) {
+                                        errorAsset(instance, err, 2048 /* LOG_TYPE.IMAGE */);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else if (file.document) {
+                for (const handler of this.Document) {
+                    const { instance, constructor } = handler;
+                    if ((instance.using || constructor.using) && this.hasDocument(instance, file.document) && !data.aborted) {
+                        try {
+                            if (instance.threadable) {
+                                if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
+                                    (instance.using ? instance.using(data) : constructor.using.call(this, instance, file))
+                                        .then(() => this.closeThread(instance, data))
+                                        .catch(err => {
+                                        this.closeThread(instance, data);
+                                        errorAsset(instance, err);
+                                    });
+                                }
+                            }
+                            else if (!this.aborted) {
+                                this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
+                                await (instance.using ? instance.using(data) : constructor.using.call(this, instance, file));
+                            }
+                        }
+                        catch (err) {
+                            errorAsset(instance, err);
+                        }
+                    }
+                }
+            }
+        }
+        this.closeThread(null, data, () => {
+            if (!file.invalid) {
+                this.add(localUri, parent);
+            }
+            else if (localUri && (0, types_1.isEmpty)(file.bundleId)) {
+                this.deleteFile(localUri, { emptyDir: true });
+            }
+        });
+    }
+    openThread(instance, data, timeout = 0) {
+        if (this.aborted || data.aborted) {
+            return false;
+        }
+        core_1.AbortComponent.attach(data, instance.signal);
+        if (timeout > 0) {
+            this.addProcessTimeout(instance, data.file, timeout);
+        }
+        this.performAsyncTask();
+        ++data.threadCount;
+        return true;
+    }
+    closeThread(instance, data, callback) {
+        if (data.aborted) {
+            return false;
+        }
+        if (instance) {
+            core_1.AbortComponent.detach(data, instance.signal);
+            this.removeProcessTimeout(instance, data.file);
+        }
+        if (typeof callback === 'function') {
+            data.queuedTasks.push(callback);
+        }
+        else {
+            this.removeAsyncTask();
+        }
+        if (--data.threadCount === 0) {
+            const index = this.processing.findIndex(item => item === data);
+            if (index !== -1) {
+                this.processing.splice(index, 1);
+            }
+            data.queuedTasks.forEach(task => {
+                try {
+                    task();
+                }
+                catch (err) {
+                    this.writeFail(["Unable to perform task" /* ERR_MESSAGE.PERFORM_TASK */, path.basename(this.getLocalUri(data))], err);
+                }
+                this.removeAsyncTask();
+            });
+            this.performFinalize();
+            return true;
+        }
+        return false;
+    }
+    addProcessTimeout(instance, file, timeout) {
+        if (timeout > 0) {
+            const processModule = file.processModule || (file.processModule = {});
+            const current = processModule[instance.moduleName];
+            if (current) {
+                current.timeout += timeout;
+                ++current.threadCount;
+            }
+            else {
+                processModule[instance.moduleName] = { threadCount: 1, startTime: Date.now(), timeout };
+            }
+        }
+    }
+    removeProcessTimeout(instance, file) {
+        const processModule = file.processModule;
+        if (processModule) {
+            const current = processModule[instance.moduleName];
+            if (current && --current.threadCount === 0) {
+                delete processModule[instance.moduleName];
+            }
+        }
+    }
+    getProcessTimeout(handler) {
+        const moduleName = handler.instance.moduleName;
+        return this[kProcessTimeout][moduleName] ?? PROCESS_TIMEOUT[moduleName] ?? (handler.constructor.PROCESS_TIMEOUT || 0);
+    }
+    clearProcessTimeout() {
+        const timerMain = this[KTimerMain];
+        if (timerMain) {
+            clearInterval(timerMain);
+            this[KTimerMain] = null;
+        }
+    }
+    addDownload(value, type = 0, encoding) {
+        if (typeof type === 'string') {
+            encoding = type;
+            type = 0;
+        }
+        let result = 0;
+        if (typeof value === 'number') {
+            result = value;
+        }
+        else if (typeof value === 'string') {
+            if ((result = (0, lib_v4_1.byteLength)(value, encoding)) === 0) {
+                return 0;
+            }
+        }
+        else if (Buffer.isBuffer(value)) {
+            result = value.length;
+        }
+        else {
+            return 0;
+        }
+        const stat = this[kDownloadStats][type];
+        stat[0] += result;
+        stat[1]++;
+        return result;
+    }
+    getDownload(type = 0) {
+        return this[kDownloadStats][type];
+    }
+    fetchObject(uri, options) {
+        if (!(0, types_1.isObject)(options)) {
+            options = { format: options };
+        }
+        options.format || (options.format = 'json');
+        return this.fetchBuffer(uri, options).then(data => typeof data === 'object' ? data : null).catch(() => null);
+    }
+    fetchBuffer(uri, options) {
+        if (options) {
+            options.format = undefined;
+        }
+        return this.Request.get(uri, options).then(buffer => {
+            let encoding, pipeTo;
+            if (options) {
+                ({ encoding, pipeTo } = options);
+            }
+            if (buffer) {
+                this.addDownload(Buffer.byteLength(buffer, encoding));
+            }
+            else if ((0, types_1.isString)(pipeTo) && core_1.Host.isPath(pipeTo, true)) {
+                this.addDownload(pipeTo);
+            }
+            return buffer;
+        });
+    }
+    fetchFiles(uri, options) {
+        if (!(0, types_1.isObject)(options)) {
+            options = { pathname: options };
+        }
+        options.pathname || (options.pathname = this.baseDirectory);
+        return this.Request.aria2c(uri, options);
+    }
+    start(emptyDir) {
+        const listener = (resolve) => {
+            const callback = (files, errors, status) => {
+                if (!this.restarting) {
+                    this.removeListener('end', callback);
+                    resolve({ files, errors, status, aborted: this.aborted });
+                }
+            };
+            return callback;
+        };
+        if (this.aborted) {
+            const pending = this._pendingResult;
+            if (pending) {
+                queueMicrotask(() => abortedHost.call(this));
+                this._pendingResult = null;
+                return pending;
+            }
+            return new Promise(resolve => {
+                this.on('end', listener(resolve));
+                queueMicrotask(() => {
+                    if (!abortedHost.call(this)) {
+                        this.restarting = false;
+                        this.emit('end', [], collectErrors.call(this), this.collectLog());
+                        this.done = true;
+                    }
+                });
+            });
+        }
+        switch (this.finalizeState) {
+            case 0 /* FINALIZE_STATE.READY */:
+                if (this.delayed === 0 && !this.cleared) {
+                    break;
+                }
+            case 1 /* FINALIZE_STATE.COMMIT */:
+            case 3 /* FINALIZE_STATE.RESTART */:
+            case 5 /* FINALIZE_STATE.RESTARTED */:
+            case 4 /* FINALIZE_STATE.QUEUED */:
+                if (this._pendingResult) {
+                    return this._pendingResult;
+                }
+                this.finalizeState = 0 /* FINALIZE_STATE.READY */;
+            case 2 /* FINALIZE_STATE.END */:
+                resetAssets.call(this);
+                break;
+        }
+        return this._pendingResult || (this._pendingResult = new Promise((resolve, reject) => {
+            this.on('end', listener(resolve));
+            try {
+                this.processAssets(emptyDir);
+            }
+            catch (err) {
+                this.done = true;
+                reject(err);
+            }
+        }));
+    }
+    processAssets(emptyDir, targeted) {
+        if (this.aborted) {
+            abortedHost.call(this);
+            return;
+        }
+        if (this.finalizeState === 5 /* FINALIZE_STATE.RESTARTED */) {
+            this.restarting = false;
+        }
+        else if (this._pendingResult) {
+            return;
+        }
+        if (!this.canWrite(this.baseDirectory, { ownPermissionOnly: true })) {
+            this.writeFail("Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */, new Error(this.baseDirectory), 8192 /* LOG_TYPE.PERMISSION */);
+            this.cleared = true;
+            if (this.queued) {
+                this.joinQueue({ reject: true });
+            }
+            return;
+        }
+        switch (this.finalizeState) {
+            case 0 /* FINALIZE_STATE.READY */:
+                if (this.delayed === 0 && !this.cleared) {
+                    break;
+                }
+            case 1 /* FINALIZE_STATE.COMMIT */:
+            case 3 /* FINALIZE_STATE.RESTART */:
+            case 4 /* FINALIZE_STATE.QUEUED */:
+                return;
+            case 2 /* FINALIZE_STATE.END */:
+                resetAssets.call(this);
+                break;
+        }
+        if (this.queued) {
+            const length = arguments.length;
+            const args = new Array(length);
+            for (let i = 0; i < length; ++i) {
+                args[i] = arguments[i];
+            }
+            if (this.joinQueue({ args })) {
+                this.finalizeState = 4 /* FINALIZE_STATE.QUEUED */;
+                return;
+            }
+        }
+        if (targeted) {
+            this.using(true, ...targeted);
+        }
+        this.clearProcessTimeout();
+        this[KTimerMain] = setInterval(() => {
+            const { processing, processTimeout, finalizeState } = this;
+            if (finalizeState === 4 /* FINALIZE_STATE.QUEUED */) {
+                return;
+            }
+            const currentTime = Date.now();
+            let aborted;
+            for (let i = 0; i < processing.length; ++i) {
+                const data = processing[i];
+                const file = data.file;
+                const processModule = file.processModule;
+                let expired = processTimeout > 0 && currentTime - data.startTime >= processTimeout, moduleName;
+                if (processModule && !expired) {
+                    for (const name in processModule) {
+                        const { startTime, timeout } = processModule[name];
+                        if (timeout > 0 && currentTime - startTime >= timeout) {
+                            moduleName = name;
+                            expired = true;
+                            break;
+                        }
+                    }
+                }
+                if (expired || data.aborted) {
+                    let threadCount = data.threadCount + data.queuedTasks.length;
+                    while (threadCount-- > 0) {
+                        this.removeAsyncTask();
+                    }
+                    file.invalid = true;
+                    const localUri = file.localUri;
+                    if (expired) {
+                        data.abort();
+                        if (localUri) {
+                            this.deleteFile(localUri, { id: file.id, emptyDir: true, all: true });
+                        }
+                    }
+                    (moduleName && this.find(moduleName) || this).formatFail(16384 /* LOG_TYPE.TIMEOUT */, "FAIL!" /* ERR_MESSAGE.FAIL */, ["Unable to process file" /* ERR_MESSAGE.PROCESS_FILE */, moduleName || 'main'], (0, types_1.errorValue)(expired ? "Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */ : "Aborted" /* ERR_MESSAGE.ABORTED */, localUri), { queue: false, startTime: data.startTime });
+                    processing.splice(i--, 1);
+                    aborted = true;
+                }
+            }
+            if (this.processing.length === 0 && this.aborted) {
+                this.performFinalize(true);
+            }
+            else if (aborted) {
+                this.performFinalize();
+            }
+        }, 100);
+        const hasIncremental = (value) => value === 'etag' || value === 'exists';
+        const { assets, cacheToDisk, cacheToMemory, fetchedAssets, Watch: watch } = this;
+        const initial = this[kRecursionLimit] === RECURSION_LIMIT;
+        const downloadble = new Map();
+        const completed = Object.create(null);
+        const processing = Object.create(null);
+        const downloading = Object.create(null);
+        const appending = {};
+        const bundling = {};
+        const originCount = {};
+        const emptied = [this.baseDirectory];
+        const incremental = this.config.incremental;
+        const cacheable = initial && !this.archiving;
+        const cacheOpen = cacheable && hasIncremental(incremental);
+        const cacheEtag = cacheable && incremental === 'etag';
+        if (cacheOpen) {
+            this[kIncremental] = incremental;
+        }
+        else if (!initial) {
+            this[kIncremental] = 'none';
+        }
+        const targeting = this._usingObjects.size > 0;
+        const isCacheable = (file) => file.initialValue?.cacheable !== false;
+        const hasEtag = (file) => {
+            if (!cacheable || !(0, types_1.existsFlag)(file.flags)) {
+                return false;
+            }
+            switch (file.incremental) {
+                case false:
+                case 'none':
+                case 'exists':
+                    return false;
+                case 'etag':
+                    return true;
+                default:
+                    return cacheEtag;
+            }
+        };
+        const applyHeaders = (file, headers, lastModified, mainEtag) => {
+            let contentLength = headers['content-length'];
+            if ((contentLength = parseInt(contentLength)) > 0) {
+                file.contentLength = contentLength;
+            }
+            else {
+                contentLength = 0;
+            }
+            const etag = headers.etag;
+            if (etag) {
+                if (mainEtag) {
+                    CACHE_ETAG[file.uri] = etag;
+                }
+                return file.etag = etag;
+            }
+            if (lastModified && watch) {
+                return file.lastModified = headers['last-modified'];
+            }
+        };
+        const checkQueue = (file, localUri, pathname, content) => {
+            var _m;
+            if (!createFolder(file, pathname)) {
+                return true;
+            }
+            const { bundleId, bundleIndex = -1 } = file;
+            if (!(0, types_1.isEmpty)(bundleId) && bundleIndex >= 0) {
+                const items = appending[localUri] || (appending[localUri] = []);
+                bundling[_m = file.uri] || (bundling[_m] = []);
+                if (bundleIndex > 0) {
+                    items[bundleIndex - 1] = file;
+                    const url = file.url;
+                    if (file.fetchType === 1 /* FETCH_TYPE.HTTP */ && (cacheToDisk.has(url) || cacheToMemory.has(url))) {
+                        const parent = assets.find(item => item.bundleIndex === 0 && item.bundleId === bundleId);
+                        if (parent) {
+                            (parent.bundleQueue || (parent.bundleQueue = [])).push(new Promise(resolve => {
+                                this.Request.open(url, { method: 'HEAD', httpVersion: 1 })
+                                    .on('response', res => {
+                                    if (res.statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                                        applyHeaders(file, res.headers);
+                                    }
+                                    resolve(file);
+                                })
+                                    .on('error', () => resolve(file))
+                                    .on('timeout', () => resolve(file));
+                            }));
+                        }
+                    }
+                    return true;
+                }
+            }
+            else if (!content && file.filename) {
+                const previous = completed[localUri];
+                if (previous) {
+                    if (file.uri === previous.uri) {
+                        file.etag = previous.etag;
+                        file.lastModified = previous.lastModified;
+                    }
+                    this.transformAsset(new FileThread(this, file, 1));
+                    return true;
+                }
+                const queue = processing[localUri];
+                if (queue) {
+                    queue.push(file);
+                    return true;
+                }
+                processing[localUri] = [file];
+            }
+            return false;
+        };
+        const copyDownload = (file, queued) => {
+            const uriMap = new Map();
+            for (const item of queued) {
+                const destUri = item.localUri;
+                let items = uriMap.get(destUri);
+                if (!items) {
+                    const pathname = path.dirname(destUri);
+                    if (!core_1.Host.createDir(pathname)) {
+                        item.invalid = true;
+                        continue;
+                    }
+                    uriMap.set(destUri, items = []);
+                }
+                item.etag = file.etag;
+                item.lastModified = file.lastModified;
+                items.push(item);
+            }
+            const buffer = file.sourceUTF8 || file.buffer;
+            for (const [destUri, items] of uriMap) {
+                try {
+                    if (buffer) {
+                        fs.writeFileSync(destUri, buffer);
+                    }
+                    else {
+                        fs.copyFileSync(file.localUri, destUri);
+                    }
+                    for (const queue of items) {
+                        this.performAsyncTask();
+                        this.transformAsset(new FileThread(this, queue, 1));
+                    }
+                }
+                catch (err) {
+                    items.forEach(queue => queue.invalid = true);
+                    this.writeFail([buffer ? "Unable to write buffer" /* ERR_MESSAGE.WRITE_BUFFER */ : "Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, path.basename(file.localUri)], err, 32 /* LOG_TYPE.FILE */);
+                }
+            }
+        };
+        const processQueue = async (file, localUri) => {
+            completed[localUri] = file;
+            if (!(0, types_1.isEmpty)(file.bundleId) && file.bundleIndex === 0) {
+                this.setAssetContent(file, this.getUTF8String(file, localUri));
+                let success = true, error, checkEtag = !file.trailingContent && hasEtag(file);
+                if (file.bundleQueue) {
+                    error = await Promise.all(file.bundleQueue).then(() => null).catch((err) => err);
+                    delete file.bundleQueue;
+                }
+                const items = appending[localUri];
+                if (items) {
+                    if (error) {
+                        items.forEach(queue => queue.invalid = true);
+                        success = false;
+                    }
+                    else {
+                        const tasks = [];
+                        for (const queue of items) {
+                            const encoding = queue.encoding || (queue.encoding = 'utf-8');
+                            const { uri, fetchType: type } = queue;
+                            let tempFile;
+                            if (checkEtag && queue.trailingContent) {
+                                checkEtag = false;
+                            }
+                            const verifyBundle = (value, etag) => {
+                                if (!queue.invalid) {
+                                    if (value instanceof Buffer) {
+                                        value = value.toString(encoding);
+                                    }
+                                    const url = queue.url;
+                                    if (etag && cacheToMemory.has(url)) {
+                                        cacheToMemory.add(url, encodeURIComponent(etag), value, {
+                                            encoding,
+                                            contentLength: queue.contentLength,
+                                            toDisk: !tempFile && isCacheable(queue) ? queue.filename || queue.localUri && path.basename(queue.localUri) : ''
+                                        });
+                                    }
+                                    this.setAssetContent(queue, value, { localUri, bundleIndex: queue.bundleIndex, bundleReplace: queue.bundleReplace });
+                                }
+                            };
+                            if (queue.content) {
+                                verifyBundle(queue.content);
+                                checkEtag = false;
+                            }
+                            else if (uri) {
+                                if (type === 1 /* FETCH_TYPE.HTTP */ || type === 2 /* FETCH_TYPE.UNIX_SOCKET */) {
+                                    const url = queue.url;
+                                    const options = {
+                                        url,
+                                        encoding,
+                                        statusMessage: uri + ` (${queue.bundleIndex})`
+                                    };
+                                    let etag, pipeTo;
+                                    if (type === 2 /* FETCH_TYPE.UNIX_SOCKET */) {
+                                        options.socketPath = queue.socketPath;
+                                        options.httpVersion = 1;
+                                    }
+                                    else {
+                                        if (etag = queue.etag) {
+                                            const valid = incremental !== false || file.incremental === true;
+                                            const cached = valid && MEMORY.CACHE[uri];
+                                            const etagDir = encodeURIComponent(etag);
+                                            if (cached) {
+                                                if (etagDir === cached[5]) {
+                                                    const source = cached[1];
+                                                    verifyBundle(typeof source === 'string' ? source : source.toString(encoding));
+                                                    this.addDownload(Buffer.byteLength(source, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                    continue;
+                                                }
+                                                cacheToMemory.clear(uri);
+                                            }
+                                            if (cacheToDisk.has(url) && isCacheable(queue)) {
+                                                const baseDir = path.join(this.getCacheDir(url), etagDir);
+                                                pipeTo = path.join(baseDir, path.basename(localUri));
+                                                try {
+                                                    if (valid && (0, lib_v4_1.hasSize)(pipeTo)) {
+                                                        const buffer = fs.readFileSync(pipeTo, { encoding });
+                                                        verifyBundle(buffer, etag);
+                                                        this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                        continue;
+                                                    }
+                                                    if (!fs.existsSync(baseDir)) {
+                                                        fs.mkdirSync(baseDir);
+                                                    }
+                                                    tempFile = path.join(baseDir, (0, types_1.generateUUID)());
+                                                    options.pipeTo = tempFile;
+                                                }
+                                                catch {
+                                                    pipeTo = undefined;
+                                                }
+                                            }
+                                        }
+                                        if ((originCount[url.origin] || 0) <= 1) {
+                                            options.httpVersion = 1;
+                                        }
+                                        options.connected = (headers) => {
+                                            etag = applyHeaders(queue, headers, true);
+                                            return true;
+                                        };
+                                    }
+                                    tasks.push(this.fetchBuffer(url, options)
+                                        .then(data => {
+                                        if (data) {
+                                            verifyBundle(data, etag);
+                                        }
+                                        else {
+                                            queue.invalid = true;
+                                        }
+                                        const downloaded = bundling[uri];
+                                        if ((0, types_1.isArray)(downloaded)) {
+                                            if (data) {
+                                                if (typeof data === 'string') {
+                                                    queue.sourceUTF8 = data;
+                                                }
+                                                else {
+                                                    queue.buffer = data;
+                                                }
+                                                copyDownload(queue, downloaded);
+                                            }
+                                            else {
+                                                downloaded.forEach(item => item.invalid = true);
+                                            }
+                                        }
+                                        if (tempFile && (!pipeTo || core_1.Host.isPath(pipeTo) || !core_1.Host.renameFile(tempFile, pipeTo, false))) {
+                                            queueMicrotask(() => fs.unlink(tempFile, () => { }));
+                                        }
+                                    })
+                                        .catch(() => {
+                                        queue.invalid = true;
+                                        if (tempFile) {
+                                            queueMicrotask(() => fs.unlink(tempFile, () => { }));
+                                        }
+                                    }));
+                                }
+                                else if (type) {
+                                    const mimeType = queue.mimeType || file.mimeType;
+                                    const pathname = this.getTempDir({ uuidDir: true });
+                                    if (!pathname || !mimeType) {
+                                        queue.invalid = true;
+                                        tasks.push(Promise.reject(!pathname ? new Error("Unable to create temp directory" /* ERR_MESSAGE.TEMP_DIRECTORY */) : (0, types_1.errorValue)("MIME not found" /* ERR_MESSAGE.NOTFOUND_MIME */, uri)));
+                                        break;
+                                    }
+                                    tasks.push(this.fetchFiles(queue.url || uri, { pathname, binOpts: queue.binOpts || file.binOpts })
+                                        .then(result => {
+                                        if (result.length) {
+                                            verifyBundle(bundleTorrent.call(this, result, mimeType, encoding));
+                                        }
+                                        else {
+                                            queue.invalid = true;
+                                        }
+                                        queueMicrotask(() => core_1.Host.removeDir(pathname));
+                                    })
+                                        .catch(() => {
+                                        queue.invalid = true;
+                                        queueMicrotask(() => core_1.Host.removeDir(pathname));
+                                    }));
+                                }
+                                else if (this.canRead(uri)) {
+                                    tasks.push(fs.promises.readFile(uri, encoding)
+                                        .then(data => {
+                                        verifyBundle(data);
+                                        this.addDownload(Buffer.byteLength(data, encoding), types_1.DOWNLOAD_TYPE.DISK);
+                                    })
+                                        .catch(() => {
+                                        queue.invalid = true;
+                                    }));
+                                }
+                                else {
+                                    checkEtag = false;
+                                    errorPermission(file);
+                                }
+                            }
+                        }
+                        if (tasks.length) {
+                            success = await Promise.all(tasks)
+                                .then(() => true)
+                                .catch(err => {
+                                this.writeFail(["Unable to download file" /* ERR_MESSAGE.DOWNLOAD_FILE */, 'bundle: ' + path.basename(localUri)], err, 1024 /* LOG_TYPE.HTTP */);
+                                return false;
+                            });
+                        }
+                        else if (checkEtag && core_1.Host.isPath(localUri)) {
+                            this.completeAsyncTask();
+                            appending[localUri] = undefined;
+                            return;
+                        }
+                    }
+                }
+                if (success) {
+                    if (!fetchedAssets.includes(file)) {
+                        fetchedAssets.push(file);
+                    }
+                    this.transformAsset(new FileThread(this, file, 1));
+                }
+                else {
+                    file.invalid = true;
+                    delete file.buffer;
+                    delete file.sourceUTF8;
+                    this.completeAsyncTask(error);
+                    queueMicrotask(() => this.deleteFile(localUri, { emptyDir: true }));
+                }
+                appending[localUri] = undefined;
+                return;
+            }
+            const uri = file.uri;
+            const processed = processing[localUri];
+            const downloaded = downloading[uri];
+            if ((0, types_1.isArray)(downloaded)) {
+                copyDownload(file, downloaded);
+            }
+            if (processed) {
+                for (const item of processed) {
+                    if (item !== file) {
+                        if (item.uri === file.uri) {
+                            item.etag = file.etag;
+                            item.lastModified = file.lastModified;
+                        }
+                        this.performAsyncTask();
+                    }
+                    this.transformAsset(new FileThread(this, item, 1));
+                }
+                processing[localUri] = undefined;
+            }
+            else {
+                this.transformAsset(new FileThread(this, file, 1));
+            }
+            downloading[uri] = undefined;
+        };
+        const clearQueue = (data, attr) => {
+            if (attr && data[attr]) {
+                data[attr].forEach(item => item.invalid = true);
+                data[attr] = undefined;
+            }
+        };
+        const errorRequest = (file, err, preceding) => {
+            const { uri, localUri } = file;
+            clearQueue(processing, localUri);
+            clearQueue(downloading, uri);
+            clearQueue(appending, localUri);
+            file.invalid = true;
+            if (!preceding) {
+                this.completeAsyncTask();
+            }
+            this.writeFail(["Unable to download file" /* ERR_MESSAGE.DOWNLOAD_FILE */, uri], err, err instanceof Error && err.message.startsWith("Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */) ? 16384 /* LOG_TYPE.TIMEOUT */ : 1024 /* LOG_TYPE.HTTP */);
+        };
+        const errorPermission = (file) => {
+            this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, file.uri], (0, types_1.errorValue)('Operation not permitted', file.uri || "Unknown" /* ERR_MESSAGE.UNKNOWN */), 8192 /* LOG_TYPE.PERMISSION */);
+            file.invalid = true;
+        };
+        const createFolder = (file, pathname) => {
+            if (!emptied.includes(pathname)) {
+                if (emptyDir && core_1.Host.removeDir(pathname, true)) {
+                    emptied.push(pathname);
+                }
+                else if (core_1.Host.createDir(pathname)) {
+                    emptied.push(pathname);
+                }
+                else {
+                    file.invalid = true;
+                    this.writeFail("Unable to create directory" /* ERR_MESSAGE.CREATE_DIRECTORY */, (0, types_1.errorValue)('Path not found', pathname));
+                    return false;
+                }
+            }
+            return true;
+        };
+        const fileReceived = (item, localUri, err, fetched, binary) => {
+            if (err) {
+                item.invalid = true;
+                this.completeAsyncTask(err, localUri);
+                return;
+            }
+            if (fetched) {
+                fetchedAssets.push(item);
+            }
+            else {
+                this.copiedAssets.push(item);
+            }
+            if (binary) {
+                this.transformAsset(new FileThread(this, item, 1));
+            }
+            else {
+                processQueue(item, localUri);
+            }
+        };
+        const imported = assets.filter(item => item.imported && (0, types_1.isArray)(item.imported));
+        for (let item of assets) {
+            if (item.invalid || (0, types_1.ignoreFlag)(item.flags)) {
+                continue;
+            }
+            if (!item.filename) {
+                if (!(item.uri && core_1.Host.isFile(item.uri, 'torrent'))) {
+                    item.invalid = true;
+                    continue;
+                }
+                item.filename = '';
+            }
+            if (targeting && !this.contains(item, (other) => (0, asset_1.isEqual)(item, other))) {
+                this.setLocalUri(item);
+                item.invalid = true;
+                continue;
+            }
+            let download = this.setLocalUri(item);
+            const localUri = download.localUri;
+            if (!localUri) {
+                item.invalid = true;
+                continue;
+            }
+            const type = item.incremental;
+            let valid = cacheOpen;
+            if (valid) {
+                if (type === false || type === 'none') {
+                    valid = false;
+                }
+            }
+            else if (hasIncremental(type)) {
+                if (cacheable) {
+                    valid = true;
+                }
+                else {
+                    item.incremental = undefined;
+                }
+            }
+            if (valid && item.filename) {
+                let uri = item.uri, cached;
+                const etag = (cacheEtag && type !== 'exists' || type === 'etag') && !!uri;
+                if (etag && imported.some(file => file.imported.includes(uri))) {
+                    item.incremental = 'none';
+                }
+                else if (!(0, types_1.mainFlag)(item.flags)) {
+                    const { bundleId, bundleIndex = -1 } = item;
+                    const setBuffer = (target) => {
+                        if (!etag && (uri = target.uri) && (cached = MEMORY.CACHE[uri])) {
+                            target.etag = cached[5];
+                            target.contentLength = cached[3];
+                            return true;
+                        }
+                        return false;
+                    };
+                    if ((!etag || item.fetchType === 1 /* FETCH_TYPE.HTTP */ && ((0, types_1.isEmpty)(bundleId) || bundleIndex <= 0)) && (!watch || !item.watch || setBuffer(item))) {
+                        let childBundle, childDownload;
+                        if (!(0, types_1.isEmpty)(bundleId) && bundleIndex > 0) {
+                            const target = assets.find(parent => parent.bundleId === bundleId && parent.bundleIndex === 0);
+                            if (target) {
+                                if ((0, types_1.existsFlag)(target.flags)) {
+                                    setBuffer(item);
+                                    item.invalid = true;
+                                }
+                                else if (target.localUri) {
+                                    downloadble.set(item, download);
+                                }
+                                else {
+                                    childDownload = download;
+                                    download = this.setLocalUri(target);
+                                    if (download.localUri) {
+                                        childBundle = item;
+                                        item = target;
+                                        cached = undefined;
+                                    }
+                                    else {
+                                        item.invalid = true;
+                                    }
+                                }
+                            }
+                            else {
+                                item.invalid = true;
+                            }
+                            if (!childBundle) {
+                                continue;
+                            }
+                        }
+                        if (!cached) {
+                            setBuffer(item);
+                        }
+                        if (core_1.Host.isPath(localUri)) {
+                            item.flags |= 128 /* ASSET_FLAG.EXISTS */;
+                            if (!etag || item.fetchType !== 1 /* FETCH_TYPE.HTTP */) {
+                                if (!(0, types_1.isEmpty)(bundleId) && bundleIndex === 0) {
+                                    assets.filter(child => child.bundleId === bundleId && child.bundleIndex > 0).forEach(child => {
+                                        setBuffer(child);
+                                        child.invalid = true;
+                                    });
+                                }
+                                continue;
+                            }
+                        }
+                        else if (childBundle) {
+                            downloadble.set(childBundle, childDownload);
+                        }
+                        else if (cached) {
+                            try {
+                                const buffer = cached[1];
+                                fs.writeFileSync(localUri, buffer);
+                                if (item.willChange && Buffer.isBuffer(buffer)) {
+                                    item.buffer = buffer;
+                                }
+                                this.performAsyncTask();
+                                fileReceived(item, localUri, null, true);
+                                continue;
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                }
+                else if (core_1.Host.isPath(localUri)) {
+                    try {
+                        const buffer = fs.readFileSync(localUri);
+                        if (!etag) {
+                            (0, asset_1.setInitialValue)(item, false);
+                            item.initialValue.buffer = buffer;
+                        }
+                        else if (uri && CACHE_ETAG[uri]) {
+                            (0, asset_1.setInitialValue)(item, false);
+                            item.initialValue.buffer = buffer;
+                            item.initialValue.etag = CACHE_ETAG[uri];
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+            downloadble.set(item, download);
+        }
+        if (downloadble.size > 1 && this.Request.httpVersion !== 1) {
+            for (const { url } of downloadble.keys()) {
+                if (url?.protocol === 'https:') {
+                    originCount[url.origin] = (originCount[url.origin] || 0) + 1;
+                }
+            }
+        }
+        for (const [item, download] of downloadble) {
+            if (this.aborted) {
+                break;
+            }
+            const { pathname, localUri } = download;
+            let uri;
+            if (item.content) {
+                if (!checkQueue(item, localUri, pathname, true)) {
+                    item.sourceUTF8 = item.content;
+                    this.performAsyncTask();
+                    fs.writeFile(localUri, item.content, item.encoding || (item.encoding = 'utf-8'), err => fileReceived(item, localUri, err));
+                }
+            }
+            else if (item.dataView) {
+                if (createFolder(item, pathname)) {
+                    this.performAsyncTask();
+                    const dataView = item.dataView;
+                    fs.writeFile(localUri, dataView, err => {
+                        if (!err) {
+                            item.buffer = Buffer.isBuffer(dataView) ? dataView : Buffer.from(dataView.buffer);
+                        }
+                        fileReceived(item, localUri, err, false, true);
+                    });
+                }
+            }
+            else if (item.base64) {
+                if (createFolder(item, pathname)) {
+                    this.performAsyncTask();
+                    fs.writeFile(localUri, item.base64, 'base64', err => fileReceived(item, localUri, err, false, true));
+                }
+            }
+            else if (uri = item.uri) {
+                const checkDest = (src) => this.archiving || !(0, lib_v4_1.hasSameStat)(src, localUri);
+                const type = item.fetchType;
+                const bundleMain = !(0, types_1.isEmpty)(item.bundleId) && item.bundleIndex === 0;
+                let isHttp;
+                if ((isHttp = type === 1 /* FETCH_TYPE.HTTP */) || type === 2 /* FETCH_TYPE.UNIX_SOCKET */) {
+                    const url = item.url;
+                    const checkEtag = hasEtag(item);
+                    if ((0, types_1.isEmpty)(item.bundleId) && bundling[uri]) {
+                        bundling[uri].push(item);
+                    }
+                    else if (checkEtag || !checkQueue(item, localUri, pathname)) {
+                        if (!isHttp && !checkDest(uri)) {
+                            fileReceived(item, localUri);
+                        }
+                        else if (!checkEtag && downloading[uri]) {
+                            downloading[uri].push(item);
+                        }
+                        else if (!isHttp && !this.canRead(uri)) {
+                            errorPermission(item);
+                        }
+                        else {
+                            if (!checkEtag) {
+                                downloading[uri] = [];
+                            }
+                            let cacheDir, cacheBuffer, mainEtag, encoding = item.encoding, client = null;
+                            if (isHttp) {
+                                cacheDir = cacheToDisk.has(url) && isCacheable(item);
+                                cacheBuffer = cacheToMemory.has(url);
+                                mainEtag = (0, types_1.mainFlag)(item.flags) && (cacheEtag || item.incremental === 'etag');
+                            }
+                            const closeResponse = () => client?.destroy();
+                            const downloadUri = (request, etagDir) => {
+                                if (checkEtag) {
+                                    item.flags &= ~128 /* ASSET_FLAG.EXISTS */;
+                                }
+                                closeResponse();
+                                const location = request.url.toString();
+                                request.encoding = encoding;
+                                request.pipeTo = localUri;
+                                request.statusMessage = location + (bundleMain ? ' (0)' : '');
+                                if (isHttp) {
+                                    request.method = 'GET';
+                                    request.httpVersion = (originCount[request.url.origin] || 0) <= 1 ? 1 : undefined;
+                                    request.connected = headers => {
+                                        applyHeaders(item, headers, true, mainEtag);
+                                        return item.willChange || !!etagDir && (cacheDir || !item.contentLength || cacheToMemory.within(item.contentLength));
+                                    };
+                                }
+                                else {
+                                    request.socketPath = item.socketPath;
+                                    request.httpVersion = 1;
+                                }
+                                this.fetchBuffer(request.url, request)
+                                    .then(data => {
+                                    if (typeof data === 'string') {
+                                        item.sourceUTF8 = data;
+                                    }
+                                    else if (data) {
+                                        item.buffer = data;
+                                    }
+                                    fileReceived(item, localUri, null, isHttp);
+                                    if (etagDir) {
+                                        queueMicrotask(() => {
+                                            if (cacheBuffer && data) {
+                                                cacheToMemory.add(location, etagDir, data, { encoding, contentLength: item.contentLength, toDisk: !cacheDir && isCacheable(item) ? path.basename(localUri) : '' });
+                                            }
+                                            if (cacheDir) {
+                                                cacheToDisk.add(location, etagDir, localUri, { buffer: data, contentLength: item.contentLength });
+                                            }
+                                        });
+                                    }
+                                })
+                                    .catch(err => errorRequest(item, err));
+                            };
+                            this.performAsyncTask();
+                            const request = this.Request;
+                            if (cacheDir || cacheBuffer || mainEtag) {
+                                let redirects = 0;
+                                (function checkHeaders(href) {
+                                    try {
+                                        const target = request.opts(href, { method: 'HEAD', httpVersion: 1 });
+                                        (client = request.open(href, target))
+                                            .on('response', res => {
+                                            const statusCode = res.statusCode;
+                                            if (statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                                                const etag = applyHeaders(item, res.headers, false, mainEtag);
+                                                let tempDir, etagDir;
+                                                if (etag) {
+                                                    if (cacheDir) {
+                                                        tempDir = this.getCacheDir(href);
+                                                    }
+                                                    etagDir = encodeURIComponent(etag);
+                                                    if (incremental !== false || item.incremental === true) {
+                                                        const location = href.toString();
+                                                        const cached = MEMORY.CACHE[location];
+                                                        let buffer;
+                                                        if (cached) {
+                                                            if (etagDir === cached[5] && (!encoding || encoding === cached[2])) {
+                                                                if (checkEtag) {
+                                                                    this.completeAsyncTask(null, localUri);
+                                                                    closeResponse();
+                                                                    return;
+                                                                }
+                                                                buffer = cached[1];
+                                                                encoding = cached[2];
+                                                                item.encoding = encoding;
+                                                                cached[0] = Date.now();
+                                                            }
+                                                            else {
+                                                                cacheToMemory.clear(location);
+                                                            }
+                                                        }
+                                                        try {
+                                                            const setBuffer = () => {
+                                                                if (typeof buffer === 'string') {
+                                                                    item.sourceUTF8 = buffer;
+                                                                }
+                                                                else if (buffer) {
+                                                                    item.buffer = buffer;
+                                                                }
+                                                            };
+                                                            let pipeAs;
+                                                            if (tempDir && (0, lib_v4_1.hasSize)(pipeAs = path.join(tempDir, etagDir, path.basename(localUri)))) {
+                                                                if (!checkEtag) {
+                                                                    if (cacheBuffer && !buffer) {
+                                                                        buffer = fs.readFileSync(pipeAs, encoding);
+                                                                        if (cacheToMemory.within(item.contentLength = Buffer.byteLength(buffer, encoding))) {
+                                                                            cacheToMemory.add(location, etagDir, buffer, { encoding, contentLength: item.contentLength, tempFile: pipeAs });
+                                                                        }
+                                                                    }
+                                                                    if (checkDest(pipeAs)) {
+                                                                        if (buffer) {
+                                                                            fs.writeFileSync(localUri, buffer);
+                                                                            this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                                        }
+                                                                        else {
+                                                                            fs.copyFileSync(pipeAs, localUri);
+                                                                            this.addDownload(pipeAs, types_1.DOWNLOAD_TYPE.CACHE);
+                                                                        }
+                                                                    }
+                                                                    if (item.willChange) {
+                                                                        setBuffer();
+                                                                    }
+                                                                    fileReceived(item, localUri, null, true);
+                                                                }
+                                                                else {
+                                                                    this.completeAsyncTask(null, localUri);
+                                                                }
+                                                                closeResponse();
+                                                                return;
+                                                            }
+                                                            if (buffer) {
+                                                                setBuffer();
+                                                                fs.writeFileSync(localUri, buffer);
+                                                                this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                                if (checkEtag) {
+                                                                    item.flags &= ~128 /* ASSET_FLAG.EXISTS */;
+                                                                }
+                                                                fileReceived(item, localUri, null, true);
+                                                                closeResponse();
+                                                                if (pipeAs) {
+                                                                    fs.writeFile(pipeAs, buffer, () => { });
+                                                                }
+                                                                return;
+                                                            }
+                                                        }
+                                                        catch {
+                                                        }
+                                                    }
+                                                }
+                                                downloadUri(target, etagDir);
+                                            }
+                                            else if (statusCode < 400 /* HTTP_STATUS.BAD_REQUEST */) {
+                                                closeResponse();
+                                                const location = res.headers.location;
+                                                if (location && ++redirects <= HTTP_CLIENT.redirectLimit) {
+                                                    try {
+                                                        checkHeaders.call(this, new URL(request_1.default.fromURL(href, location)));
+                                                        return;
+                                                    }
+                                                    catch {
+                                                    }
+                                                }
+                                                errorRequest(item, (0, types_1.errorMessage)(statusCode, 'Exceeded redirect limit', url.toString()));
+                                            }
+                                            else {
+                                                downloadUri(target);
+                                            }
+                                        })
+                                            .on('error', err => {
+                                            if (!client.destroyed) {
+                                                if ((0, util_1.checkRetryable)(err)) {
+                                                    downloadUri(target);
+                                                }
+                                                else {
+                                                    errorRequest(item, err);
+                                                }
+                                            }
+                                        })
+                                            .on('timeout', () => {
+                                            if (!client.destroyed) {
+                                                downloadUri(target);
+                                            }
+                                        });
+                                    }
+                                    catch {
+                                        downloadUri(request.opts(href));
+                                    }
+                                }).bind(this)(url);
+                            }
+                            else {
+                                downloadUri(request.opts(url));
+                            }
+                        }
+                    }
+                }
+                else if (type) {
+                    if (bundleMain && !item.mimeType) {
+                        errorRequest(item, (0, types_1.errorValue)("MIME not found" /* ERR_MESSAGE.NOTFOUND_MIME */, uri), true);
+                    }
+                    else if (!checkQueue(item, localUri, pathname, false)) {
+                        if (downloading[uri]) {
+                            downloading[uri].push(item);
+                            continue;
+                        }
+                        downloading[uri] = [];
+                        this.performAsyncTask();
+                        this.fetchFiles(item.url || uri, { pathname, binOpts: item.binOpts })
+                            .then(result => {
+                            if (result.length === 0) {
+                                errorRequest(item, (0, types_1.errorValue)('No files were successfully downloaded', uri));
+                            }
+                            else if (bundleMain) {
+                                const encoding = item.encoding || (item.encoding = 'utf-8');
+                                fs.writeFile(localUri, bundleTorrent.call(this, result, item.mimeType, encoding), encoding, err => {
+                                    if (!err) {
+                                        fetchedAssets.push(item);
+                                        processQueue(item, localUri);
+                                    }
+                                    else {
+                                        errorRequest(item, err);
+                                    }
+                                });
+                            }
+                            else {
+                                const ext = item.filename && path.extname(item.filename);
+                                let found;
+                                for (const file of result) {
+                                    if (!found && ext === path.extname(file).toLowerCase()) {
+                                        try {
+                                            if (file !== localUri && !core_1.Host.renameFile(file, localUri)) {
+                                                this.filesToRemove.add(file);
+                                            }
+                                            found = true;
+                                        }
+                                        catch (err) {
+                                            this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, item.filename], err, 32 /* LOG_TYPE.FILE */);
+                                        }
+                                    }
+                                    else {
+                                        this.add(file, item, types_1.FILE_TYPE.TORRENT);
+                                    }
+                                }
+                                if (found) {
+                                    fetchedAssets.push(item);
+                                    processQueue(item, localUri);
+                                }
+                                else {
+                                    item.filename = '';
+                                    item.localUri = '';
+                                    item.mimeType = '';
+                                    clearQueue(processing, localUri);
+                                    clearQueue(downloading, uri);
+                                    this.completeAsyncTask();
+                                }
+                            }
+                        })
+                            .catch(err => errorRequest(item, err));
+                    }
+                }
+                else if (!this.canRead(uri)) {
+                    errorPermission(item);
+                }
+                else if (!checkQueue(item, localUri, pathname)) {
+                    this.performAsyncTask();
+                    if (checkDest(uri)) {
+                        fs.copyFile(uri, localUri, err => {
+                            if (!err) {
+                                this.addDownload(localUri, types_1.DOWNLOAD_TYPE.DISK);
+                            }
+                            fileReceived(item, localUri, err);
+                        });
+                    }
+                    else {
+                        fileReceived(item, localUri);
+                    }
+                }
+            }
+            else {
+                item.invalid = true;
+            }
+        }
+        this.cleared = true;
+    }
+    async finalizeCompress(assets) {
+        const compress = this.Compress;
+        if (!(compress && assets.length)) {
+            return;
+        }
+        const tasks = [];
+        for (const item of assets) {
+            if (image_1.default.isBinary(item.mimeType)) {
+                const localUri = item.localUri;
+                const files = [localUri];
+                if (item.transforms) {
+                    files.push(...item.transforms);
+                }
+                const format = item.mimeType.split('/').pop();
+                for (const file of files) {
+                    if (this.has(file)) {
+                        const output = item.compress.filter(({ condition }) => !condition || withinSizeRange(file, condition));
+                        if (output.length) {
+                            const found = output.filter(value => value.format === format);
+                            for (const config of found.length ? found : output) {
+                                const options = { ...config };
+                                options.timeout = this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress;
+                                options.proxyUrl = (uri) => {
+                                    const proxy = this.Request.proxyOf(uri);
+                                    return proxy ? proxy.host.href : '';
+                                };
+                                tasks.push(compress.tryImage(item.buffer && files.length === 1 ? item.buffer : file, file, options)
+                                    .then(result => {
+                                    if (result instanceof Buffer && file === localUri) {
+                                        item.buffer = result;
+                                    }
+                                })
+                                    .catch(err => this.writeFail(["Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, path.basename(file)], err, { type: 8 /* LOG_TYPE.COMPRESS */, startTime: options.startTime })));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (tasks.length) {
+            return Promise.all(tasks);
+        }
+    }
+    async finalizeDocument() {
+        for (const { instance, constructor } of this.Document) {
+            if (constructor.finalize && instance.assets.length) {
+                await constructor.finalize.call(this, instance).catch(err => rejectModule.call(instance, err, 4 /* LOG_TYPE.PROCESS */));
+                if (this.aborted) {
+                    break;
+                }
+            }
+        }
+    }
+    async finalizeTask(assets) {
+        if (assets.length) {
+            for (const { instance, constructor } of this.Task) {
+                const items = assets.filter(item => item.tasks.find(data => data.handler === instance.moduleName));
+                if (items.length) {
+                    await (constructor.using || constructor.finalize).call(this, instance, items).catch(err => rejectModule.call(instance, err, 4 /* LOG_TYPE.PROCESS */));
+                    if (this.aborted) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    async finalizeCloud() {
+        if (this.Cloud) {
+            return cloud_1.default.finalize.call(this, this.Cloud).catch(err => rejectModule.call(this.Cloud, err, 64 /* LOG_TYPE.CLOUD */));
+        }
+    }
+    async finalizeCleanup() {
+        if (this.Compress) {
+            const tasks = [];
+            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
+            if (tasks.length) {
+                await Promise.allSettled(tasks);
+            }
+        }
+        if (this.emptyDir.size) {
+            for (const value of Array.from(this.emptyDir).reverse()) {
+                try {
+                    fs.rmdirSync(value);
+                }
+                catch {
+                }
+            }
+        }
+        for (const { instance, constructor } of this.Document) {
+            if (constructor.cleanup && instance.assets.length) {
+                await constructor.cleanup.call(this, instance).catch(err => rejectModule.call(instance, err, 4 /* LOG_TYPE.PROCESS */));
+            }
+        }
+    }
+    async finalize() {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        if (LOG_TIMEELAPSED) {
+            this.writeTimeElapsed('READY', 'Finalizing assets...', this.startTime, { ...core_1.Host.LOG_STYLE_WARN, showCpu: true });
+        }
+        const startTime = process.hrtime();
+        const filesToRemove = this.filesToRemove;
+        const removeFiles = () => {
+            if (filesToRemove.size) {
+                filesToRemove.forEach(value => this.deleteFile(value, { emptyDir: true }));
+                filesToRemove.clear();
+            }
+        };
+        for (const [file, output] of this.filesToCompare) {
+            const localUri = file.localUri;
+            let minFile = localUri, minSize = (0, lib_v4_1.getSize)(minFile);
+            for (const other of output) {
+                const size = (0, lib_v4_1.getSize)(other);
+                if (minSize === 0 || size > 0 && size < minSize) {
+                    filesToRemove.add(minFile);
+                    minFile = other;
+                    minSize = size;
+                }
+                else {
+                    filesToRemove.add(other);
+                }
+            }
+            if (minFile !== localUri) {
+                this.replace(file, minFile);
+            }
+        }
+        removeFiles();
+        await this.finalizeCompress(this.assets.filter(item => item.compress && !ignoreAsset(item))).catch(err => rejectModule.call(this, err, 8 /* LOG_TYPE.COMPRESS */));
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        await this.finalizeDocument().catch(err => rejectModule.call(this, err, 4 /* LOG_TYPE.PROCESS */));
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        for (const item of this.assets) {
+            if (item.sourceUTF8 && !ignoreAsset(item)) {
+                try {
+                    fs.writeFileSync(item.localUri, item.sourceUTF8, item.encoding || (item.encoding = 'utf-8'));
+                }
+                catch (err) {
+                    this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(item.localUri)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
+                }
+            }
+        }
+        removeFiles();
+        await this.finalizeTask(this.taskAssets.filter(item => item.tasks?.find(data => !data.preceding) && item.localUri && this.has(item.localUri) && !ignoreAsset(item))).catch(err => rejectModule.call(this, err, 4 /* LOG_TYPE.PROCESS */));
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        removeFiles();
+        await this.finalizeCloud().catch(err => rejectModule.call(this, err, 64 /* LOG_TYPE.CLOUD */));
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        removeFiles();
+        await this.finalizeCleanup().catch(err => rejectModule.call(this, err, 1 /* LOG_TYPE.SYSTEM */));
+        removeFiles();
+        if (LOG_TIMEELAPSED) {
+            const [h, d, c] = this[kDownloadStats];
+            const errorCount = this.errorCount;
+            const message = [];
+            if (errorCount) {
+                message.push(`ERROR ${errorCount}`);
+            }
+            let [size, count] = h;
+            if (count) {
+                message.push('HTTP ' + (count > 1 ? count + '/' : '') + (0, types_1.formatSize)(size));
+            }
+            [size, count] = d;
+            if (count) {
+                message.push('DISK ' + (count > 1 ? count + '/' : '') + (0, types_1.formatSize)(size));
+            }
+            [size, count] = c;
+            if (count) {
+                message.push('CACHE ' + (count > 1 ? count + '/' : '') + (0, types_1.formatSize)(size));
+            }
+            if (MEMORY.SIZE > 0) {
+                const bufferCount = Object.keys(MEMORY.CACHE).length;
+                message.push('BUFFER ' + (bufferCount > 1 ? bufferCount + '/' : '') + (0, types_1.formatSize)(MEMORY.SIZE));
+            }
+            this.writeTimeElapsed('CLOSE', ['No further modifications', message.join(' | ')], startTime, { ...core_1.Host.LOG_STYLE_WARN });
+        }
+        this.Watch?.start(this.assets);
+    }
+    close() {
+        this.Request.close();
+    }
+    set restarting(value) {
+        this.finalizeState = (this[kRestarting] = value) ? 3 /* FINALIZE_STATE.RESTART */ : 0 /* FINALIZE_STATE.READY */;
+    }
+    get restarting() {
+        return this[kRestarting];
+    }
+    get baseDirectory() {
+        return this[kBaseDirectory];
+    }
+    get assets() {
+        return this._assets;
+    }
+    get incremental() {
+        return this[kIncremental];
+    }
+    get delayed() {
+        return this[kDelayed];
+    }
+    set cleared(value) {
+        this[kCleared] = value;
+        if (value) {
+            this.performFinalize();
+        }
+    }
+    get cleared() {
+        return this[kCleared];
+    }
+    get errorCount() {
+        return Array.from(this.modules).reduce((a, b) => a + b.errors.length, this.errors.length);
+    }
+}
+exports.default = FileManager;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}