@e-mc/document 0.0.1

package/index.js

@@ -0,0 +1,1296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const pm = require("picomatch");
+const yaml = require("js-yaml");
+const chalk = require("chalk");
+const types_1 = require("../types");
+const core_1 = require("../core");
+const db_1 = require("../db");
+const util_1 = require("./util");
+const transform_1 = require("./transform");
+const parse_1 = require("./parse");
+const EMC2_PLUGINS = Object.freeze({
+    "@babel/core": "@e-mc2/babel",
+    "clean-css": "@e-mc2/clean-css",
+    "csso": "@e-mc2/csso",
+    "eslint": "@e-mc2/eslint",
+    "html-minifier": "@e-mc2/html-minifier",
+    "html-minifier-terser": "@e-mc2/html-minifier-terser",
+    "html-validate": "@e-mc2/html-validate",
+    "postcss": "@e-mc2/postcss",
+    "posthtml": "@e-mc2/posthtml",
+    "prettier": "@e-mc2/prettier",
+    "rollup": "@e-mc2/rollup",
+    "sass": "@e-mc2/sass",
+    "stylelint": "@e-mc2/stylelint",
+    "svgo": "@e-mc2/svgo",
+    "terser": "@e-mc2/terser",
+    "uglify-js": "@e-mc2/uglify-js"
+});
+const CACHE_PACKAGE = {};
+const CACHE_REQUIRE = {};
+const CACHE_ETAG = {};
+const CACHE_CODE = {};
+const CACHE_HASH = {};
+const CACHE_TEMPLATE = {};
+const CACHE_EXTERNAL = {};
+const CACHE_PICOMATCH = new Map();
+let CACHE_TOTAL = 0;
+function renewTransform(map, key, expires) {
+    if (expires > 0) {
+        return setTimeout(() => deleteTransform(map, key), expires);
+    }
+    return null;
+}
+function deleteTransform(map, key, timeout) {
+    if (timeout) {
+        clearTimeout(timeout);
+    }
+    delete map[key];
+    --CACHE_TOTAL;
+}
+function getSourceMappingURL(value, css) {
+    if (value.indexOf(' ') !== -1) {
+        value = encodeURIComponent(value);
+    }
+    return css ? `\n/*# sourceMappingURL=${value} */\n` : `\n//# sourceMappingURL=${value}\n`;
+}
+const joinString = (...values) => values.reduce((a, b) => b ? a + (a ? ' -> ' : '') + b : a, '');
+const spliceSource = (source, startIndex, endIndex, content) => source.substring(0, startIndex) + content + source.substring(endIndex);
+const isFunction = (value) => typeof value === 'function';
+class Document extends core_1.Client {
+    static async purgeMemory(percent = 1, limit = 0, parent) {
+        if (limit > 0 && CACHE_TOTAL < limit) {
+            return 0;
+        }
+        let result = 0;
+        if (percent >= 1) {
+            for (const cache of [CACHE_ETAG, CACHE_CODE, CACHE_HASH]) {
+                for (const name in cache) {
+                    const map = cache[name];
+                    for (const key in map) {
+                        deleteTransform(map, key, map[key].timeout);
+                        ++result;
+                    }
+                    delete cache[name];
+                }
+            }
+            for (const cache of [CACHE_PACKAGE, CACHE_REQUIRE, CACHE_EXTERNAL, CACHE_TEMPLATE]) {
+                for (const name in cache) {
+                    delete cache[name];
+                }
+            }
+            CACHE_PICOMATCH.clear();
+            CACHE_TOTAL = 0;
+        }
+        else if (percent > 0) {
+            const stored = [];
+            for (const cache of [CACHE_ETAG, CACHE_CODE, CACHE_HASH]) {
+                for (const name in cache) {
+                    const map = cache[name];
+                    for (const key in map) {
+                        stored.push([map, key]);
+                    }
+                }
+            }
+            stored.sort(([a1, a2], [b1, b2]) => a1[a2].lastAccessed - b1[b2].lastAccessed);
+            result = Math.floor(stored.length * percent);
+            for (let i = 0; i < result; ++i) {
+                const [map, key] = stored[i];
+                deleteTransform(map, key, map[key].timeout);
+            }
+            CACHE_TOTAL = stored.length - result;
+        }
+        return result + (parent && result > 0 ? await super.purgeMemory(percent, limit, true) : 0);
+    }
+    static async finalize(instance) {
+        for (const ext of instance.extensions) {
+            if (instance.aborted) {
+                return Promise.reject((0, types_1.createAbortError)());
+            }
+            try {
+                const args = [instance];
+                // @ts-ignore
+                if (ext["__cjs__" /* INTERNAL.CJS */]) {
+                    args.push(__dirname);
+                }
+                else if (core_1.Client.enabled("node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */)) {
+                    args.push(require);
+                }
+                await ext.apply(this, args);
+            }
+            catch (err) {
+                instance.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, this.moduleName], err);
+            }
+        }
+    }
+    static writeSourceMap(uri, data, options) {
+        const map = data.map;
+        if (!map) {
+            return;
+        }
+        let file, sourceRoot, sourceMappingURL, hash, inlineMap, emptySources, mimeType;
+        if (options) {
+            ({ file, sourceRoot, sourceMappingURL, hash, inlineMap, emptySources, mimeType } = options);
+        }
+        file || (file = path.basename(uri));
+        map.file = file;
+        if (sourceRoot) {
+            map.sourceRoot = sourceRoot;
+        }
+        if (emptySources) {
+            map.sources = [""];
+        }
+        try {
+            let css = mimeType === 'text/css', flags = 0 /* SOURCEMAP.NONE */;
+            const output = JSON.stringify(map);
+            const toBase64 = () => 'data:application/json;base64,' + Buffer.from(output).toString('base64');
+            if (!inlineMap) {
+                if (!sourceMappingURL) {
+                    sourceMappingURL = data.sourceMappingURL || file;
+                }
+                if (!sourceMappingURL.endsWith('.map')) {
+                    sourceMappingURL += '.map';
+                }
+                if (hash) {
+                    const [algorithm, length] = (0, util_1.getHashData)(hash);
+                    if (algorithm) {
+                        const value = this.asHash(output, algorithm);
+                        if (value) {
+                            sourceMappingURL = (0, util_1.appendSuffix)(sourceMappingURL, length ? value.substring(0, length) : value);
+                        }
+                    }
+                }
+            }
+            let code = data.code.replace(transform_1.SourceMap.RE_SOURCE_MAPPING_URL, (...capture) => {
+                flags |= 1 /* SOURCEMAP.FOUND */;
+                if (capture[2] && capture[5]) {
+                    css = true;
+                }
+                if (inlineMap || capture[3]) {
+                    flags |= 2 /* SOURCEMAP.INLINE */;
+                    return getSourceMappingURL(toBase64(), css);
+                }
+                return capture[1] || css ? getSourceMappingURL(sourceMappingURL, css) : capture[0];
+            });
+            if (inlineMap || flags & 2 /* SOURCEMAP.INLINE */) {
+                if (flags === 0 /* SOURCEMAP.NONE */) {
+                    code += getSourceMappingURL(toBase64(), css);
+                }
+                data.code = code;
+            }
+            else {
+                if (flags === 0 /* SOURCEMAP.NONE */) {
+                    code += getSourceMappingURL(sourceMappingURL, css);
+                }
+                const result = path.join(path.dirname(uri), sourceMappingURL);
+                fs.writeFileSync(result, output);
+                data.code = code;
+                return result;
+            }
+        }
+        catch {
+        }
+    }
+    static createSourceMap(code, uri) {
+        return new transform_1.SourceMap(code, uri);
+    }
+    static updateGradle(source, namespaces, value, options) {
+        const local = /^(\w+)\s*(=)?\s*(".+"|'.+'|\([\S\s]+\)||\[[\S\s]+\]|\S+)$/.exec(value = value.trim());
+        if (!local) {
+            return source;
+        }
+        let upgrade, multiple, addendum, updateOnly;
+        if (typeof options === 'boolean') {
+            upgrade = options;
+        }
+        else if (options) {
+            ({ upgrade, multiple, addendum, updateOnly } = options);
+        }
+        if (addendum) {
+            value += ' ' + addendum;
+        }
+        const length = namespaces.length;
+        let ident, lastIndex = 0, i = 0;
+        while (i < length) {
+            const pattern = new RegExp(`([\\t ]*)${(0, types_1.escapePattern)(namespaces[i])}\\s*\\{` + parse_1.XmlWriter.PATTERN_TRAILINGSPACE);
+            pattern.lastIndex = lastIndex;
+            const match = pattern.exec(source);
+            if (!match) {
+                break;
+            }
+            if (i > 0 && !ident && match[1]) {
+                ident = match[1];
+            }
+            lastIndex = match.index + match[0].length;
+            ++i;
+        }
+        const newline = (0, util_1.getNewline)(source);
+        ident || (ident = (0, util_1.getIndent)(source));
+        if (i === length) {
+            const sanitizeValue = (segment) => segment.replace(/["'()]/g, '').trim();
+            const pattern = new RegExp(`\\b${(0, types_1.escapePattern)(local[1])}\\b` + (local[2] ? '\\s*=\\s*' : '\\s*') + `("[^"]+"|'[^']+'|\\([^)]+\\)|[^\\s]+)?` + (addendum ? '[^\\r\\n]*' : '[^\\w\\r\\n]*'), 'g');
+            pattern.lastIndex = lastIndex;
+            let match;
+            while (match = pattern.exec(source)) {
+                const preceding = source.substring(lastIndex, match.index);
+                let opening = 0, closing = namespaces.length - 1;
+                for (let j = 0, q = preceding.length; j < q; ++j) {
+                    switch (preceding[j]) {
+                        case '{':
+                            ++opening;
+                            break;
+                        case '}':
+                            ++closing;
+                            break;
+                    }
+                }
+                if (opening === closing && (!multiple || match[1] && sanitizeValue(match[1]) === sanitizeValue(local[3]))) {
+                    return upgrade ? parse_1.XmlWriter.replaceMatch(match, source, value, pattern) : source;
+                }
+            }
+            return spliceSource(source, lastIndex, lastIndex, ident.repeat(length) + value + newline);
+        }
+        if (updateOnly) {
+            return source;
+        }
+        const j = i;
+        let leading = '', trailing = '';
+        while (i < length) {
+            leading += ident.repeat(i) + namespaces[i] + ' {' + newline;
+            ++i;
+        }
+        for (i = length - 1; i >= j; --i) {
+            trailing += ident.repeat(i) + '}' + newline;
+        }
+        const content = leading + ident.repeat(length) + value + newline + trailing;
+        return lastIndex > 0 ? spliceSource(source, lastIndex, lastIndex, content) : source + newline + content;
+    }
+    static generateLintTable(messages, options) {
+        const { leadingText, trailingText, pathname, filename, ruleWidth = 30, messageWidth = 60 } = options;
+        const result = [];
+        const truncate = (value, width) => value.length > width ? value.substring(0, width - 3) + '...' : value.padStart(width);
+        const currentTime = Date.now();
+        let timeStamp = options.timeStamp, maxWidth = 0, maxLine = 0, maxColumn = 0, errorCount = 0, warningCount = 0, fatalErrorCount = 0;
+        messages.sort((a, b) => {
+            const offset = a.line - b.line;
+            return offset === 0 ? a.column - b.column : offset;
+        });
+        if (!timeStamp) {
+            timeStamp = currentTime;
+        }
+        else if (timeStamp instanceof Date) {
+            timeStamp = timeStamp.getTime();
+        }
+        for (const { line, column } of messages) {
+            maxLine = Math.max(line, maxLine);
+            maxColumn = Math.max(column, maxColumn);
+        }
+        maxLine = maxLine.toString().length + 1;
+        maxColumn = maxColumn.toString().length + 1;
+        for (const { severity, line, column, ruleId, message, fatal } of messages) {
+            let error;
+            if (severity) {
+                if (error = severity === 2 /* LINT_SEVERITY.ERROR */ || severity === "error" /* LINT_SEVERITY.ERROR_TEXT */) {
+                    ++errorCount;
+                }
+                else {
+                    ++warningCount;
+                }
+            }
+            if (fatal) {
+                ++fatalErrorCount;
+            }
+            const [type, errorColor] = typeof error === 'boolean' ? error ? [types_1.STATUS_TYPE.ERROR, 'red'] : [types_1.STATUS_TYPE.WARN, 'yellow'] : [types_1.STATUS_TYPE.INFO, 'white'];
+            maxWidth = Math.max(1 + 0 + 1 + 0 + 1 + 2 + Math.min(Math.max(ruleId.length, ruleWidth), ruleWidth) + 2 + Math.min(Math.max(message.length, messageWidth), messageWidth), maxWidth);
+            result.push({
+                type,
+                value: chalk[errorColor]('[') + chalk.bold(line.toString().padStart(maxLine)) + chalk.grey(':' + column.toString().padEnd(maxColumn)) + chalk[errorColor](']') + '  ' + chalk.bold(chalk.white(truncate(ruleId, ruleWidth))) + '  ' + chalk.grey(truncate(message, messageWidth)),
+                timeStamp
+            });
+        }
+        maxWidth += maxLine + maxColumn;
+        const title = (leadingText || '') + (pathname || filename ? (leadingText ? ': ' : '') + (pathname && filename ? path.join(pathname, filename) : pathname || filename) : '');
+        const divider = { type: types_1.STATUS_TYPE.INFO, value: '-'.repeat(maxWidth), timeStamp };
+        errorCount = (options.errorCount ?? errorCount).toString();
+        warningCount = (options.warningCount ?? warningCount).toString();
+        fatalErrorCount = (options.fatalErrorCount ?? fatalErrorCount).toString();
+        const hasFatal = fatalErrorCount !== '0';
+        result.unshift(divider, { type: types_1.STATUS_TYPE.INFO, value: title + ' '.repeat(maxWidth - title.length - (hasFatal ? fatalErrorCount.length + 9 : 0)) + (hasFatal ? `fatal(${chalk.bold.bgRed.white(` ${fatalErrorCount} `)})` : ''), timeStamp, duration: currentTime - timeStamp }, divider);
+        result.push(divider);
+        if (trailingText) {
+            const wrapCount = (value) => chalk.grey('(') + value + chalk.grey(')');
+            result.push({ type: types_1.STATUS_TYPE.INFO, value: chalk.bold.red('error') + wrapCount(errorCount) + ' / ' + chalk.bold.yellow('warning') + wrapCount(warningCount) + ' '.repeat(maxWidth - trailingText.length - (7 + errorCount.length + 3 + warningCount.length + 9)) + trailingText, timeStamp });
+        }
+        return result;
+    }
+    constructor(data) {
+        super(data);
+        this.Db = null;
+        this.config = {};
+        this._assets = null;
+        this._dataSource = null;
+        this._transformConfig = null;
+        this._mimeMap = null;
+        const transform = this.settingsOf('transform', 'cache');
+        if (transform !== undefined) {
+            this.customize({ transform });
+        }
+    }
+    restart() { }
+    init(assets, config) {
+        var _a;
+        let ignoreModules;
+        if (config) {
+            const { baseUrl, ignoreExtensions } = config;
+            if (ignoreExtensions === true) {
+                this._extensions = [];
+            }
+            else if (typeof ignoreExtensions === 'string') {
+                this._extensions = ignoreExtensions === this.moduleName ? [] : this._extensions.filter(value => value !== ignoreExtensions);
+            }
+            else if (Array.isArray(ignoreExtensions)) {
+                this._extensions = ignoreExtensions.includes(this.moduleName) ? [] : this._extensions.filter(value => !ignoreExtensions.includes(value));
+            }
+            if (baseUrl) {
+                const username = this.host?.username;
+                let pages = this.settings.pages;
+                if (username) {
+                    const users = this.settings.users?.[username]?.pages;
+                    if ((0, types_1.isPlainObject)(users)) {
+                        pages = (0, types_1.isPlainObject)(pages) ? { ...pages, ...users } : users;
+                    }
+                }
+                if ((0, types_1.isPlainObject)(pages)) {
+                    let mimeMap;
+                    if (!(0, types_1.isPlainObject)(mimeMap = pages[baseUrl])) {
+                        const items = [];
+                        for (const pattern in pages) {
+                            const item = pages[pattern];
+                            if ((0, types_1.isPlainObject)(item)) {
+                                let isMatch;
+                                if (!(isMatch = CACHE_PICOMATCH.get(pattern)) && (0, types_1.hasGlob)(pattern)) {
+                                    isMatch = pm(pattern, { matchBase: true });
+                                    CACHE_PICOMATCH.set(pattern, isMatch);
+                                }
+                                else {
+                                    continue;
+                                }
+                                if (isMatch(baseUrl)) {
+                                    items.push(item);
+                                }
+                            }
+                            else {
+                                delete pages[pattern];
+                            }
+                        }
+                        if (items.length > 1) {
+                            items.sort((a, b) => typeof a.ordinal === 'number' && typeof b.ordinal === 'number' ? a.ordinal - b.ordinal : 0);
+                            mimeMap = items.reduce((a, b) => Object.assign(a, b), {});
+                        }
+                        else {
+                            mimeMap = items[0];
+                        }
+                    }
+                    if (mimeMap) {
+                        let merge;
+                        for (const item of assets) {
+                            const mimeType = item.mimeType;
+                            if (mimeType && (0, types_1.isPlainObject)(merge = mimeMap[mimeType])) {
+                                Object.assign(item, merge);
+                            }
+                        }
+                        this._mimeMap = mimeMap;
+                    }
+                }
+            }
+            ignoreModules = config.ignoreModules;
+        }
+        if (this.dataSource.length && !ignoreModules?.includes('db')) {
+            const db = (_a = this.module).db || (_a.db = {});
+            const handler = db.handler;
+            const database = this.dataSource.filter(this.forDb.bind(this));
+            let instance;
+            if ((0, types_1.isString)(handler) && handler !== "@e-mc/db" /* PACKAGE_NAME.DB */) {
+                try {
+                    const Handler = require(handler);
+                    if (isFunction(Handler) && Handler.prototype instanceof db_1.default) {
+                        instance = new Handler(db, database);
+                    }
+                    else {
+                        throw (0, types_1.errorMessage)(this.moduleName, "Not a Db constructor" /* ERR_DB.CONSTRUCTOR */, handler);
+                    }
+                }
+                catch (err) {
+                    this.checkPackage(err, handler, ["Unable to load handler" /* ERR_MESSAGE.LOAD_HANDLER */, this.moduleName], 65536 /* LOG_TYPE.DB */);
+                }
+            }
+            else {
+                instance = new db_1.default(db, database);
+            }
+            if (instance) {
+                const host = this.host;
+                if (host) {
+                    instance.host = host;
+                    instance.init(host.config);
+                }
+                else {
+                    instance.init();
+                }
+                this.Db = instance;
+            }
+        }
+        this.assets = assets;
+        return super.init();
+    }
+    abort(name) {
+        if (this.aborted || name && this.settingsOf(name, 'abort') !== true) {
+            return;
+        }
+        super.abort();
+    }
+    customize(options) {
+        const transform = options.transform;
+        if (transform) {
+            const config = this._transformConfig || (this._transformConfig = { algorithm: undefined, etag: false, expires: 0, renew: false, limit: Infinity, exclude: {}, include: {} });
+            let enabled, algorithm, etag, expires, renew, limit, exclude, include;
+            if (transform === true || transform === 'etag') {
+                etag = true;
+                enabled = true;
+            }
+            else if (typeof transform === 'string') {
+                algorithm = transform;
+                enabled = true;
+            }
+            else if ((0, types_1.isPlainObject)(transform)) {
+                ({ enabled = true, algorithm, etag, expires, renew, limit, exclude, include } = transform);
+            }
+            if (!enabled) {
+                this._transformConfig = null;
+                return;
+            }
+            switch (algorithm = algorithm?.toLowerCase()) {
+                case 'md5':
+                case 'sha1':
+                case 'sha224':
+                case 'sha256':
+                case 'sha384':
+                case 'sha512':
+                    config.algorithm = algorithm;
+                    break;
+                default:
+                    config.algorithm = undefined;
+                    break;
+            }
+            if (typeof etag === 'boolean') {
+                config.etag = etag;
+            }
+            if (expires && (expires = (0, types_1.parseExpires)(expires)) >= 0) {
+                config.expires = Math.min(expires, core_1.Client.MAX_TIMEOUT);
+            }
+            if (renew) {
+                config.renew = true;
+            }
+            if ((0, types_1.isPlainObject)(exclude)) {
+                for (const type in exclude) {
+                    const item = exclude[type];
+                    if (item === '*') {
+                        config.exclude[type] = true;
+                    }
+                    else if ((0, types_1.isArray)(item)) {
+                        config.exclude[type] = item;
+                    }
+                }
+            }
+            if ((0, types_1.isPlainObject)(include)) {
+                for (const type in include) {
+                    const item = include[type];
+                    if (item === '*') {
+                        config.include[type] = true;
+                    }
+                    else if ((0, types_1.isArray)(item)) {
+                        config.include[type] = item;
+                    }
+                }
+            }
+            if (limit !== undefined) {
+                let value;
+                if (typeof limit === 'string') {
+                    if (parseFloat(limit) === 0) {
+                        value = 0;
+                    }
+                    else if ((value = (0, types_1.formatSize)(limit)) === 0) {
+                        return;
+                    }
+                }
+                else {
+                    value = limit;
+                }
+                if (value >= 0) {
+                    config.limit = value;
+                }
+            }
+        }
+        else if (transform === false || transform === null) {
+            this._transformConfig = null;
+        }
+    }
+    findConfig(data, name, type) {
+        for (const plugin in data) {
+            const settings = data[plugin];
+            for (const attr in settings) {
+                if (attr === name) {
+                    const options = this.loadConfig(settings, attr);
+                    const output = this.loadConfig(settings, attr + '-output');
+                    if (options || output) {
+                        return [plugin, options, output, true];
+                    }
+                }
+            }
+        }
+        return [];
+    }
+    loadConfig(data, name) {
+        const value = data[name];
+        const getObject = (target, cache) => {
+            if (this.settingsOf('transform', 'coerce') === true) {
+                (0, types_1.coerceObject)(target, cache);
+            }
+            return (0, types_1.cloneObject)(data[name] = target, true);
+        };
+        switch (typeof value) {
+            case 'function':
+                return value;
+            case 'object':
+                if (value) {
+                    return getObject(value, true);
+                }
+                break;
+            case 'string': {
+                const warning = (message) => this.addLog(types_1.STATUS_TYPE.ERROR, joinString(this.moduleName, 'transform@' + name, message));
+                const result = this.asSourceFile(value);
+                if (typeof result === 'function') {
+                    if (!name.endsWith('-output')) {
+                        return data[name] = result;
+                    }
+                    warning('"output" can only be a plain object');
+                }
+                else if ((0, types_1.isPlainObject)(result)) {
+                    return getObject(result, false);
+                }
+                else {
+                    warning(path.isAbsolute(value) ? "Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */ + ` (${value})` : "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+                }
+                break;
+            }
+        }
+        delete data[name];
+    }
+    resolveDir(name, ...paths) {
+        let baseDir = this.settings.directory?.[name];
+        if (baseDir) {
+            try {
+                baseDir = path.resolve(baseDir);
+                const username = this.host?.username;
+                let result;
+                if (username) {
+                    const leading = path.join(baseDir, 'users', username);
+                    if (fs.existsSync(result = path.join(leading, ...paths)) && result.startsWith(leading)) {
+                        return result;
+                    }
+                }
+                if (fs.existsSync(result = path.join(baseDir, ...paths)) && result.startsWith(baseDir)) {
+                    return result;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    asSourceFile(value, options) {
+        let encoding, persist, cache;
+        if (typeof options === 'boolean') {
+            cache = options;
+        }
+        else if ((0, types_1.isObject)(options)) {
+            ({ encoding, persist, cache } = options);
+        }
+        let result;
+        if ((value = value.trim()).startsWith('npm:')) {
+            const pkgName = value.substring(4);
+            if (persist) {
+                result = CACHE_REQUIRE[pkgName];
+            }
+            if (!result) {
+                if (!core_1.Client.enabled("node.require.npm" /* KEY_NAME.NODE_REQUIRE_NPM */)) {
+                    return null;
+                }
+                try {
+                    if (!persist) {
+                        delete require.cache[pkgName];
+                    }
+                    result = require(pkgName);
+                    if (persist && result) {
+                        CACHE_REQUIRE[pkgName] = result;
+                    }
+                    if (typeof result === 'function') {
+                        return Object.defineProperty(result, "__cjs__" /* INTERNAL.CJS */, { value: true });
+                    }
+                }
+                catch (err) {
+                    this.checkPackage(err, pkgName, "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+                }
+                if (!result) {
+                    return null;
+                }
+            }
+        }
+        try {
+            const source = result || this.readFile(value, { ownPermissionOnly: true, absolutePath: this.hasEval('absolute'), requireExt: true, encoding, cache }) || value;
+            if (typeof source !== 'string') {
+                result = source;
+            }
+            else if (!(result = (0, types_1.asFunction)(source))) {
+                try {
+                    result = this.tryParse(source, path.extname(value).substring(1));
+                }
+                catch {
+                }
+            }
+            // @ts-ignore
+            if ((0, types_1.isObject)(result) || typeof result === 'function' && (result["__cjs__" /* INTERNAL.CJS */] || this.hasEval('function'))) {
+                return result;
+            }
+        }
+        catch (err) {
+            this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(value)], err, 8192 /* LOG_TYPE.PERMISSION */);
+        }
+        return null;
+    }
+    findVersion(name, fallback = '') {
+        let result;
+        const versions = this.module.versions;
+        if (versions) {
+            if (Array.isArray(name)) {
+                for (const value of name) {
+                    if (result = versions[value]) {
+                        break;
+                    }
+                }
+            }
+            else {
+                result = this.module.versions?.[name];
+            }
+        }
+        return result || fallback;
+    }
+    findSourceRoot(uri, imports = this.imports) {
+        if (imports) {
+            const normalizeDir = (value) => value + (value[value.length - 1] !== '/' ? '/' : '');
+            for (const url in imports) {
+                if (uri === url || normalizeDir(uri) === normalizeDir(url)) {
+                    return imports[url];
+                }
+            }
+            const found = [];
+            for (const hostname in imports) {
+                if (uri.startsWith(normalizeDir(hostname)) && (0, types_1.isString)(imports[hostname])) {
+                    found.push(hostname);
+                }
+            }
+            if (found.length) {
+                const hostname = found.sort((a, b) => b.length - a.length)[0];
+                return core_1.Client.toPosix(path.resolve(imports[hostname], uri.substring(normalizeDir(hostname).length).split('?')[0]));
+            }
+        }
+    }
+    locateSourceFiles(file, code, bundleContent) {
+        return (imports = this.imports) => {
+            const href = file.uri;
+            const sourceFile = [];
+            let mainFile, invalid;
+            if (Document.isFile(href, 'unc') || path.isAbsolute(href)) {
+                sourceFile.push([href]);
+            }
+            else if (imports && Object.keys(imports).length) {
+                const bundleId = file.bundleId;
+                const assets = !(0, types_1.isEmpty)(bundleId) ? this.assets.filter(item => item.bundleId === bundleId).sort((a, b) => a.bundleIndex - b.bundleIndex) : [file];
+                if (!Array.isArray(bundleContent) || bundleContent.length !== assets.length - 1) {
+                    bundleContent = undefined;
+                }
+                for (const item of assets) {
+                    const localFile = !item.exported && item.uri ? this.findSourceRoot(item.uri, imports) : undefined;
+                    if (localFile && core_1.Client.isPath(localFile) && !item.trailingContent) {
+                        sourceFile.push([localFile]);
+                    }
+                    else {
+                        let source;
+                        if (item.bundleIndex === 0) {
+                            const localUri = item.localUri;
+                            try {
+                                source = fs.readFileSync(localUri, file.encoding || (file.encoding = 'utf-8'));
+                                if (this.resolveUri && (0, types_1.isArray)(file.trailingContent)) {
+                                    let trailing;
+                                    [source, trailing] = this.resolveUri(file, source, (0, util_1.concatString)(file.trailingContent));
+                                    if ((0, types_1.isString)(trailing)) {
+                                        source += trailing;
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, localUri && path.basename(localUri)], 32 /* LOG_TYPE.FILE */);
+                            }
+                        }
+                        else if (bundleContent) {
+                            source = bundleContent[item.bundleIndex - 1];
+                        }
+                        if (!source) {
+                            invalid = true;
+                            break;
+                        }
+                        sourceFile.push(['', this.resolveImports?.(item, source, localFile) || source, localFile]);
+                    }
+                }
+            }
+            if (sourceFile.length && (sourceFile[0] && (mainFile = sourceFile[0][0]) || !invalid) && (!this.hasOwnPermission() || !sourceFile.some(item => item[0] && !this.canRead(item[0])))) {
+                return { code, sourceFile: !invalid ? sourceFile : undefined, sourcesRelativeTo: mainFile && path.dirname(mainFile) };
+            }
+        };
+    }
+    resolveSourceFile(file) {
+        return (code, imports = this.imports) => {
+            const uri = file.uri;
+            let source, sourceFile;
+            if (code && imports && Object.keys(imports).length) {
+                const output = this.resolveImports?.(file, code, uri && this.findSourceRoot(uri, imports));
+                if (output) {
+                    source = output;
+                }
+            }
+            if (uri) {
+                sourceFile = Document.isFile(uri, 'unc') || path.isAbsolute(uri) ? uri : this.findSourceRoot(uri, imports);
+            }
+            if (source || sourceFile) {
+                return { code: source || code, sourceFile, sourcesRelativeTo: sourceFile && path.dirname(sourceFile) };
+            }
+        };
+    }
+    tryParse(source, format, options) {
+        try {
+            switch (format.toLowerCase()) {
+                case 'yml':
+                case 'yaml':
+                    return yaml.load(source, options);
+                case 'json5':
+                    return require('json5').parse(source);
+                case 'xml':
+                    return new (require('fast-xml-parser').XMLParser)(options).parse(source);
+                case 'toml':
+                    return require('toml').parse(source);
+                default:
+                    return JSON.parse(source);
+            }
+        }
+        catch (err) {
+            const name = (0, util_1.getModuleName)(err);
+            if (name) {
+                this.checkPackage(err, (0, util_1.getModuleName)(err), "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+            }
+            throw err;
+        }
+    }
+    forDb(item) {
+        return item.source !== 'cloud';
+    }
+    hasEval(name) {
+        return !!this.module.eval?.[name];
+    }
+    settingsOf(name, option) {
+        const options = this.settings.options?.[name];
+        if ((0, types_1.isObject)(options)) {
+            return options[option];
+        }
+    }
+    async parseTemplate(viewEngine, template, data) {
+        let target, stored;
+        if (typeof viewEngine === 'string') {
+            target = this.settings.view_engine?.[viewEngine];
+            const username = this.host?.username;
+            const userConfig = username && this.settings.users?.[username]?.view_engine?.[viewEngine];
+            if ((0, types_1.isPlainObject)(userConfig)) {
+                if ((0, types_1.isPlainObject)(target)) {
+                    (0, types_1.cloneObject)(userConfig, { target, deep: true, preserve: true });
+                }
+                else {
+                    target = userConfig;
+                }
+            }
+            stored = true;
+        }
+        else {
+            target = viewEngine;
+        }
+        if (!((0, types_1.isPlainObject)(target) && target.name)) {
+            this.abort('view_engine');
+            const from = typeof viewEngine === 'string' ? viewEngine : this.moduleName;
+            this.writeFail(["Unable to load configuration" /* ERR_MESSAGE.LOAD_CONFIG */, from], (0, types_1.errorMessage)('view-engine', from, "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+            return null;
+        }
+        const length = data.length;
+        if (length === 0 && !target.outputEmpty) {
+            return '';
+        }
+        let name;
+        try {
+            const context = require(name = target.name);
+            const { singleRow, options = {} } = target;
+            let { compile, output } = options;
+            if (!(0, types_1.isPlainObject)(output)) {
+                output = undefined;
+            }
+            if (this.settingsOf('view_engine', 'coerce') === true) {
+                if (compile) {
+                    (0, types_1.coerceObject)(compile, stored);
+                }
+                if (output) {
+                    (0, types_1.coerceObject)(output, stored);
+                }
+            }
+            const username = this.host?.username || '';
+            const cache = CACHE_TEMPLATE[name] || (CACHE_TEMPLATE[name] = {});
+            const cacheKey = username + core_1.Client.asHash(template + (compile ? core_1.Client.asString(compile) : ''), 64 /* VALUES.HASH_MINLENGTH */);
+            let result = '', render, valid;
+            if (!(render = cache[cacheKey])) {
+                render = await context.compile(template, compile); // eslint-disable-line @typescript-eslint/await-thenable
+                cache[cacheKey] = render;
+                if (!core_1.Client.enabled("memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */, username)) {
+                    setTimeout(() => delete cache[cacheKey], 60000 /* VALUES.TEMPLATE_TIMEOUT */);
+                }
+            }
+            for (let i = 0, j = 0, row; i < length; ++i) {
+                if ((0, types_1.isPlainObject)(row = data[i])) {
+                    row['__index__'] ?? (row['__index__'] = ++j);
+                    if (output) {
+                        row = { ...output, ...row };
+                    }
+                }
+                else if (!(0, types_1.isObject)(row)) {
+                    this.addLog(types_1.STATUS_TYPE.WARN, joinString(`view engine[${name}]`, `row #${i + 1}`, core_1.Client.asString(row) || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                    continue;
+                }
+                if (!singleRow) {
+                    const content = await render.call(context, row); // eslint-disable-line @typescript-eslint/await-thenable
+                    if (content !== undefined && content !== null) {
+                        result += content;
+                        valid = true;
+                    }
+                }
+            }
+            return singleRow ? render.call(context, data) ?? null : valid ? result : null;
+        }
+        catch (err) {
+            this.abort('view_engine');
+            this.checkPackage(err, name, "Unknown" /* ERR_MESSAGE.UNKNOWN */, 4 /* LOG_TYPE.PROCESS */);
+        }
+        return null;
+    }
+    async transform(type, code, format, options = {}) {
+        var _a;
+        let transform = this.settings.transform;
+        const data = transform?.[type];
+        if (!(0, types_1.isObject)(data)) {
+            return;
+        }
+        format = typeof format === 'string' ? format.trim().split(/\s*\+\s*/) : format.map(item => typeof item === 'string' ? item.trim() : '');
+        const moduleName = this.moduleName;
+        const username = this.host?.username || '';
+        const config = this._transformConfig;
+        const cacheData = config && options.cacheData;
+        const cacheType = username && core_1.Client.enabled("memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */, username) ? true : this.cacheDir || core_1.Client.enabled("memory.settings.users" /* KEY_NAME.MEMORY_SETTINGS_USERS */);
+        let formatKey, hashKey, excludeKey;
+        if (cacheData && cacheType && !CACHE_EXTERNAL[excludeKey = moduleName + '_' + type + '_' + format] && (!config.exclude[type] || Array.isArray(config.exclude[type]) && !format.some(value => config.exclude[type].includes(value)) || Array.isArray(config.include[type]) && format.every(value => config.include[type].includes(value)))) {
+            const { uri, etag } = cacheData;
+            const encoding = (0, types_1.getEncoding)(cacheData.encoding);
+            const algorithm = config.algorithm;
+            let result, cacheName;
+            formatKey = type + '_' + format + '_' + encoding + (username ? '_' + username : '') + core_1.Client.asString(options.external) + core_1.Client.asString(options.metadata);
+            const resetTimeout = (map, key, stored) => {
+                if (config.renew) {
+                    if (stored.timeout) {
+                        clearTimeout(stored.timeout);
+                    }
+                    stored.timeout = renewTransform(map, key, config.expires);
+                }
+                stored.lastAccessed = Date.now();
+            };
+            const getData = (stored) => {
+                const location = stored.format[formatKey];
+                if (typeof location === 'string') {
+                    try {
+                        return JSON.parse(fs.readFileSync(location, encoding));
+                    }
+                    catch {
+                        fs.unlink(location, () => { });
+                        return;
+                    }
+                }
+                return location;
+            };
+            if (config.etag && etag && uri) {
+                const etagMap = CACHE_ETAG[moduleName] || (CACHE_ETAG[moduleName] = {});
+                const stored = etagMap[uri];
+                if (stored) {
+                    if (stored.etag !== etag) {
+                        deleteTransform(etagMap, uri, stored.timeout);
+                    }
+                    else if (result = getData(stored)) {
+                        resetTimeout(etagMap, uri, stored);
+                        cacheName = 'etag';
+                    }
+                }
+            }
+            if (!result) {
+                if (algorithm) {
+                    const limit = config.limit;
+                    if ((limit === Infinity || limit > 0 && Buffer.byteLength(code, encoding) <= limit) && (hashKey = core_1.Client.asHash(code, { algorithm, encoding }))) {
+                        const hashMap = CACHE_HASH[moduleName] || (CACHE_HASH[moduleName] = {});
+                        const stored = hashMap[hashKey];
+                        if (stored && (result = getData(stored))) {
+                            resetTimeout(hashMap, hashKey, stored);
+                            cacheName = algorithm;
+                        }
+                    }
+                    else {
+                        formatKey = '';
+                    }
+                }
+                else if (uri) {
+                    const codeMap = CACHE_CODE[moduleName] || (CACHE_CODE[moduleName] = {});
+                    const stored = codeMap[uri];
+                    if (stored) {
+                        if (stored.code !== code) {
+                            deleteTransform(codeMap, uri, stored.timeout);
+                        }
+                        else if (result = getData(stored)) {
+                            resetTimeout(codeMap, uri, stored);
+                        }
+                    }
+                }
+                else {
+                    formatKey = '';
+                }
+            }
+            if (result) {
+                result.storedLog?.forEach(log => this.addLog(log));
+                this.formatMessage(4 /* LOG_TYPE.PROCESS */, type, [joinString(cacheName, format.filter(value => value).join(' | '), options.filename), 'cache'], uri, { ...core_1.Client.LOG_STYLE_NOTICE, hintBold: true });
+                return result;
+            }
+        }
+        if (cacheData) {
+            delete options.cacheData;
+        }
+        const imports = (_a = transform).imports || (_a.imports = {});
+        const series = new transform_1.TransformSeries(type, code, options);
+        series.init(this, __dirname);
+        let valid, excluded, userData, userImports, ignoreCache, storedLog, sourceFiles;
+        if (username && (transform = this.settings.users?.[username]?.transform)) {
+            userData = transform[type];
+            userImports = transform.imports;
+        }
+        const abort = () => {
+            ignoreCache = true;
+            this.abort('transform');
+        };
+        const includes = (name) => {
+            const include = config?.include[type];
+            if (include === true || include?.includes(name)) {
+                const exclude = config.exclude[type];
+                return !exclude || exclude === true && include !== true || Array.isArray(exclude) && !exclude.includes(name);
+            }
+            return cacheData?.override === true;
+        };
+        for (let i = 0, length = format.length, name; i < length; ++i) {
+            if (this.aborted) {
+                break;
+            }
+            if (!(name = format[i])) {
+                continue;
+            }
+            let [plugin, baseConfig, outputConfig, baseSettings] = this.findConfig(data, name, type);
+            if ((0, types_1.isObject)(userData)) {
+                const [a, b, c, d] = this.findConfig(userData, name, type);
+                if (!plugin || a === plugin) {
+                    if (b) {
+                        if (baseConfig) {
+                            (0, types_1.cloneObject)(b, { target: baseConfig, deep: true, preserve: true });
+                        }
+                        else {
+                            baseConfig = b;
+                        }
+                    }
+                    if (c) {
+                        if (outputConfig) {
+                            (0, types_1.cloneObject)(c, { target: outputConfig, deep: true, preserve: true });
+                        }
+                        else {
+                            outputConfig = c;
+                        }
+                    }
+                    if (!d) {
+                        baseSettings = false;
+                    }
+                }
+            }
+            if (!baseSettings) {
+                excluded = !includes(name);
+            }
+            outputConfig || (outputConfig = {});
+            if (plugin && baseConfig) {
+                series.outputConfig = outputConfig;
+                const source = series.code;
+                const startTime = process.hrtime();
+                const hint = plugin + '@' + name;
+                const next = (value) => {
+                    if (this.aborted) {
+                        valid = false;
+                        return;
+                    }
+                    const out = series.out;
+                    let bypassLog, failed;
+                    if (typeof value !== 'string' || (0, types_1.isArray)(out.sourceFiles) && this.hasOwnPermission() && out.sourceFiles.some(item => !this.canRead(item, { ownPermissionOnly: true }))) {
+                        failed = true;
+                        ignoreCache = true;
+                        this.writeFail(["Unable to transform document" /* ERR_MESSAGE.TRANSFORM_DOCUMENT */, plugin], (0, types_1.errorMessage)(plugin, name, typeof value === 'string' ? "Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */ : 'Empty'), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
+                    }
+                    else if (source !== value) {
+                        series.code = value;
+                        valid = true;
+                        if (out.ignoreCache && !includes(name)) {
+                            ignoreCache = true;
+                        }
+                        if ((0, types_1.isArray)(out.sourceFiles)) {
+                            if (!sourceFiles) {
+                                sourceFiles = out.sourceFiles.slice(0);
+                            }
+                            else {
+                                out.sourceFiles.forEach(item => !sourceFiles.includes(item) && sourceFiles.push(item));
+                            }
+                        }
+                    }
+                    if ((0, types_1.isArray)(out.logAppend)) {
+                        out.logAppend.forEach(log => this.addLog(log));
+                        (storedLog || (storedLog = [])).push(...out.logAppend);
+                        bypassLog = true;
+                    }
+                    if ((0, types_1.isArray)(out.logQueued)) {
+                        out.logQueued.forEach(log => this.writeLog(log, true));
+                        (storedLog || (storedLog = [])).push(...out.logQueued);
+                        bypassLog = true;
+                    }
+                    if (i < length - 1) {
+                        series.reset();
+                    }
+                    this.writeTimeProcess(failed ? 'CHECK' : type, joinString(hint, options.filename) + (series.out.messageAppend || ''), startTime, { failed, bypassLog });
+                };
+                this.formatMessage(4 /* LOG_TYPE.PROCESS */, type, ['Transforming source...', hint], options.filename, { hintColor: 'cyan' });
+                try {
+                    let context = require(plugin);
+                    series.packageName = plugin;
+                    if (typeof baseConfig === 'function') {
+                        series.baseConfig = outputConfig;
+                        // @ts-ignore
+                        if (baseConfig["__cjs__" /* INTERNAL.CJS */]) {
+                            next(await baseConfig(context, source, series));
+                        }
+                        else {
+                            const thisArg = core_1.Client.enabled("node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */) ? process : null;
+                            const inline = core_1.Client.enabled("node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */);
+                            const args = [context, source, series];
+                            if (baseConfig.toString().startsWith('async')) {
+                                if (inline) {
+                                    args.push(require);
+                                }
+                                next(await baseConfig.apply(thisArg, args));
+                            }
+                            else {
+                                next(await new Promise(resolve => {
+                                    args.push(resolve);
+                                    if (inline) {
+                                        args.push(require);
+                                    }
+                                    baseConfig.apply(thisArg, args);
+                                }));
+                            }
+                        }
+                    }
+                    else {
+                        let transformer = CACHE_PACKAGE[plugin + username];
+                        if (!transformer) {
+                            try {
+                                let pkg = this.resolveDir('package', plugin + '.js') || userImports?.[plugin] || imports[plugin] || EMC2_PLUGINS[plugin];
+                                if ((0, types_1.isString)(pkg)) {
+                                    const match = /^(@?\S+)@(\d+(?:\.\d+(?:\.\S+)?)?|[a-z]+)$/.exec(pkg);
+                                    if (match) {
+                                        pkg = match[1];
+                                        series.version = match[2];
+                                    }
+                                    transformer = require(pkg);
+                                }
+                                else {
+                                    transformer = context;
+                                    context = this;
+                                    pkg = undefined;
+                                }
+                                if (typeof transformer !== 'function' && typeof (transformer = transformer?.['default']) !== 'function') {
+                                    throw (0, types_1.errorMessage)(plugin, pkg || name, 'Invalid function');
+                                }
+                                if (pkg) {
+                                    CACHE_PACKAGE[plugin + username] = transformer;
+                                }
+                            }
+                            catch (err) {
+                                abort();
+                                this.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, username ? plugin + ':' + username : hint], err, { type: 4 /* LOG_TYPE.PROCESS */, startTime });
+                                continue;
+                            }
+                        }
+                        series.baseConfig = baseConfig;
+                        next(await transformer(context, source, series));
+                    }
+                }
+                catch (err) {
+                    abort();
+                    this.checkPackage(err, (0, util_1.getModuleName)(err), ["Unable to transform document" /* ERR_MESSAGE.TRANSFORM_DOCUMENT */, hint], { type: 4 /* LOG_TYPE.PROCESS */, startTime });
+                    if (i < length - 1) {
+                        series.reset();
+                    }
+                }
+            }
+            else {
+                abort();
+                if (plugin) {
+                    this.writeFail("Unable to load configuration" /* ERR_MESSAGE.LOAD_CONFIG */, (0, types_1.errorMessage)(plugin, name, 'Invalid config'), 4 /* LOG_TYPE.PROCESS */);
+                }
+                else {
+                    this.writeFail('Format method was not found', (0, types_1.errorValue)(name, "Unknown" /* ERR_MESSAGE.UNKNOWN */), 4 /* LOG_TYPE.PROCESS */);
+                }
+            }
+        }
+        if (this.aborted) {
+            series.detach();
+            return;
+        }
+        series.close(this);
+        if (excluded && excludeKey) {
+            CACHE_EXTERNAL[excludeKey] = true;
+        }
+        if (!valid) {
+            return;
+        }
+        const output = { type, code: series.code };
+        const sourceMap = series.sourceMap;
+        if (sourceMap.map && sourceMap.code === output.code) {
+            output.map = sourceMap.map;
+        }
+        if ((0, types_1.isArray)(series.supplementChunks)) {
+            output.chunks = series.supplementChunks.map(item => ({ code: item.code, map: output.map && item.sourceMap?.map, entryPoint: item.entryPoint, filename: item.filename }));
+        }
+        if (sourceFiles) {
+            output.sourceFiles = sourceFiles;
+        }
+        if (formatKey && !excluded && !ignoreCache) {
+            const { uri, etag } = cacheData;
+            const formatData = { ...output, storedLog };
+            const lastAccessed = Date.now();
+            const setData = () => {
+                let pathname;
+                if (typeof cacheType === 'string' && core_1.Client.createDir(pathname = path.join(cacheType, 'transform', type))) {
+                    try {
+                        fs.writeFileSync(pathname = path.join(pathname, (0, types_1.generateUUID)()), JSON.stringify(formatData));
+                        return pathname;
+                    }
+                    catch {
+                    }
+                }
+                return formatData;
+            };
+            if (config.etag && etag && uri) {
+                const etagMap = CACHE_ETAG[moduleName];
+                const stored = etagMap[uri];
+                if (stored) {
+                    if (stored.etag === etag) {
+                        stored.format[formatKey] = setData();
+                        stored.lastAccessed = lastAccessed;
+                        return output;
+                    }
+                    deleteTransform(etagMap, uri, stored.timeout);
+                }
+                etagMap[uri] = { lastAccessed, etag, timeout: renewTransform(etagMap, uri, config.expires), format: { [formatKey]: setData() } };
+                ++CACHE_TOTAL;
+            }
+            else if (hashKey) {
+                const hashMap = CACHE_HASH[moduleName];
+                const stored = hashMap[hashKey];
+                if (stored) {
+                    stored.format[formatKey] = setData();
+                    stored.lastAccessed = lastAccessed;
+                    return output;
+                }
+                hashMap[hashKey] = { lastAccessed, timeout: renewTransform(hashMap, hashKey, config.expires), format: { [formatKey]: setData() } };
+                ++CACHE_TOTAL;
+            }
+            else if (uri) {
+                const codeMap = CACHE_CODE[moduleName];
+                const stored = codeMap[uri];
+                if (stored) {
+                    if (stored.code === code) {
+                        stored.format[formatKey] = setData();
+                        stored.lastAccessed = lastAccessed;
+                        return output;
+                    }
+                    deleteTransform(codeMap, uri, stored.timeout);
+                }
+                codeMap[uri] = { lastAccessed, code, timeout: renewTransform(codeMap, uri, config.expires), format: { [formatKey]: setData() } };
+                ++CACHE_TOTAL;
+            }
+        }
+        return output;
+    }
+    set assets(value) {
+        this._assets = value;
+    }
+    get assets() {
+        if (this.host) {
+            try {
+                return this._assets || (this._assets = this.host.getDocumentAssets(this));
+            }
+            catch {
+            }
+        }
+        return this._assets || [];
+    }
+    set dataSource(value) {
+        this._dataSource = value;
+    }
+    get dataSource() {
+        if (this.host) {
+            try {
+                return this._dataSource || (this._dataSource = this.host.getDataSourceItems(this));
+            }
+            catch {
+            }
+        }
+        return this._dataSource || [];
+    }
+    get watching() {
+        return this.assets.some(item => item.watch);
+    }
+}
+exports.default = Document;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}