@e-mc/document 0.1.0 → 0.3.0

package/chrome/index.js

@@ -1,3545 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const asset_1 = require("../asset");
-const util_1 = require("../util");
-const types_1 = require("../../types");
-const core_1 = require("../../core");
-const index_1 = require("../index");
-const cloud_1 = require("../../cloud");
-const dom_1 = require("../parse/dom");
-const transform_1 = require("../transform");
-const CACHE_DBRESULT = new Map();
-const CACHE_LOCALFILE = new Map();
-const CACHE_DATASET = {};
-const CACHE_ATRULES = {};
-let CACHE_TOTAL = 0;
-const REGEXP_SRCSETSIZE = /~\s*([\d.]+)\s*([wx])/i;
-const REGEXP_TEMPLATECONDITIONAL = /(\n\s+)?\{\{if\s+((?:[^}]|}(?!}))+?)\}\}(\s*)([\S\s]*?)(?:\s*\{\{else(?:\s+if\s+((?:[^}]|}(?!}))+?))?\}\}(\s*)([\S\s]*?)\s*)?\s*\{\{end\}\}/g;
-const REGEXP_TEMPLATECOMPARISON = /\s*\(\s*(?:(eq|ne|lt|le|gt|ge)\s+)?("[^"]+"|'[^']+'|[^\s)]+)(?:\s+("[^"]+"|'[^']+'|[^\s)]+))?\s*\)/g;
-const REGEXP_TEMPLATEMATCH = new RegExp(`^(?:(and|or|not)\\s+)?((?:${REGEXP_TEMPLATECOMPARISON.source})+)|(!|not\\s+)?([^\\s][\\S\\s]*)$`);
-const REGEXP_IMPORTMODULE = /(?:(?:^|[\n;]+)\s*import\s+(?:("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')|.+?from\s+("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(?:[ \t]+assert[ \t]+\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]+{|{[^}]+}|}[^}]+}|(?![{}])[^"'`])+)\})?)|\bimport\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*(?:,\s*\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]+{|{[^}]+}|}[^}]+}|(?![{}])[^"'`])+)\}\s*)?\))/g;
-const REGEXP_BLOCKEXCLUDE = new RegExp(`(\\s*)<!--\\s*exclude\\s*:\\s*(?:start|end)\\s*-->` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
-const [PATTERN_STRING_SOME, PATTERN_STRING_MANY] = (function () {
-    const pattern = '(?:\\s|' + dom_1.DomWriter.PATTERN_COMMENT + '|`[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}`)';
-    return [pattern + '*', pattern + '+'];
-})();
-const REGEXP_COMMENT = new RegExp(dom_1.DomWriter.PATTERN_COMMENT, 'g');
-const REGEXP_CONTENT = new RegExp(`\\bcontent${PATTERN_STRING_SOME}:${PATTERN_STRING_SOME}(?:"[^"]*"|'[^']*')`, 'gi');
-const REGEXP_STYLE = new RegExp(`(<style${dom_1.DomWriter.PATTERN_TAGOPEN}*>)([\\S\\s]*?)(<\\/style\\s*>)`, 'gi');
-const REGEXP_VARIABLES = new RegExp(`(\\s*)(--[^\\s:]*)${PATTERN_STRING_SOME}:[^;}]*([;}])` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'g');
-const REGEXP_FONTFACE = new RegExp(`(\\s*)@font-face${PATTERN_STRING_SOME}{([^}]+)}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
-const REGEXP_FONTFAMILY = new RegExp(`font-family${PATTERN_STRING_SOME}:([^;}]+)`, 'i');
-const REGEXP_KEYFRAMES = new RegExp(`(\\s*)@keyframes${PATTERN_STRING_MANY}([^{]+){`, 'gi');
-const REGEXP_NTHCHILD = new RegExp(`\\(${PATTERN_STRING_SOME}([+-])?(?:(\\d*)[nN]|(0))${PATTERN_STRING_SOME}([+-])?${PATTERN_STRING_SOME}(\\d*)${PATTERN_STRING_SOME}\\)`, 'g');
-const REGEXP_VARIABLES_UNSAFE = new RegExp(`(\\s*)(--[^\\s:]*)\\s*:[^;}]*([;}])` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'g');
-const REGEXP_FONTFACE_UNSAFE = new RegExp(`(\\s*)@font-face\\s*{([^}]+)}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
-const REGEXP_FONTFAMILY_UNSAFE = /font-family\s*:([^;}]+)/i;
-const REGEXP_KEYFRAMES_UNSAFE = /(\s*)@keyframes\s+([^{]+){/gi;
-const REGEXP_NTHCHILD_UNSAFE = /\(\s*([+-])?(?:(\d*)[nN]|(0))\s*([+-])?\s*(\d*)\s*\)/g;
-function removeNamespace(name, source, newline, comments) {
-    if (source.indexOf('-' + name) !== -1) {
-        const dataset = CACHE_DATASET[name] || (CACHE_DATASET[name] = [
-            new RegExp(`(\\s*)<(script|style)(${dom_1.DomWriter.PATTERN_TAGOPEN}+)>[\\S\\s]*?<\\/\\2\\s*>` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi'),
-            new RegExp(`(\\s*)<link(${dom_1.DomWriter.PATTERN_TAGOPEN}+)>` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi'),
-            new RegExp(`\\s+data-${name}-[a-z-]+\\s*` + dom_1.DomWriter.PATTERN_ATTRVALUE, 'g'),
-            new RegExp(`data-${name}-file\\s*=\\s*(["'])?exclude\\1`),
-            new RegExp(`data-${name}-template\\s*` + dom_1.DomWriter.PATTERN_ATTRVALUE)
-        ]);
-        source = source
-            .replace(dataset[0], (...capture) => dataset[3].test(capture[3]) || dataset[4].test(capture[3]) ? getNewlineString(capture[1], capture[7], newline) : capture[0])
-            .replace(dataset[1], (...capture) => dataset[3].test(capture[2]) ? getNewlineString(capture[1], capture[6], newline) : capture[0])
-            .replace(dataset[2], '');
-    }
-    return (0, types_1.isArray)(comments) ? source.replace(REGEXP_BLOCKEXCLUDE, (...capture) => getNewlineString(capture[1], capture[2], newline)) : source;
-}
-function getObjectValue(value, key) {
-    const pattern = /([^[.\s]+)((?:\s*\[[^\]]+\]\s*)+)?\s*\.?\s*/g;
-    let found, match;
-    while (match = pattern.exec(key)) {
-        if ((0, types_1.isObject)(value)) {
-            value = value[match[1]];
-            if (match[2]) {
-                const subscript = /\[\s*(["'])?(.+?)\1\s*\]/g;
-                let index;
-                while (index = subscript.exec(match[2])) {
-                    const attr = index[1] ? index[2] : index[2].trim();
-                    if (index[1] && (0, types_1.isObject)(value) || /^\d+$/.test(attr) && (typeof value === 'string' || (0, types_1.isObject)(value))) {
-                        value = value[attr];
-                    }
-                    else {
-                        return null;
-                    }
-                }
-            }
-            if (value !== undefined && value !== null) {
-                found = true;
-                continue;
-            }
-        }
-        return null;
-    }
-    return found ? value : null;
-}
-function trimTemplate(value) {
-    const leading = /\s*\{\{- \s*((?:[^}]|}(?!}))+?)\}\}/g;
-    let match;
-    while (match = leading.exec(value)) {
-        value = replaceMatch(match, value, 1, leading);
-    }
-    const trailing = /\{\{((?:[^}]|}(?!}))+?)\s*? -\}\}\s*/g;
-    while (match = trailing.exec(value)) {
-        value = replaceMatch(match, value, 1, trailing);
-    }
-    return value;
-}
-function trimQuote(value) {
-    value = value.trim();
-    const first = value[0];
-    const last = value[value.length - 1];
-    return first === last && (first === '"' || first === "'") ? value.substring(1, value.length - 1).trim() : value;
-}
-function findClosingIndex(source, lastIndex) {
-    const pattern = /[{}]/g;
-    pattern.lastIndex = lastIndex;
-    let opened = 1, closed = 0, endIndex = -1, trailing = '', match;
-    while (match = pattern.exec(source)) {
-        if (match[0] === '{') {
-            ++opened;
-        }
-        else if (++closed === opened) {
-            endIndex = match.index + 1;
-            let ch;
-            while (isSpace(ch = source[endIndex])) {
-                trailing += ch;
-                ++endIndex;
-                if (ch === '\n') {
-                    break;
-                }
-            }
-            break;
-        }
-    }
-    return [endIndex, trailing];
-}
-function getPackageName(err, value) {
-    if (err instanceof Error && err.code === types_1.ERR_CODE.MODULE_NOT_FOUND) {
-        switch (value) {
-            case 'mongodb':
-            case 'redis':
-                return value;
-            case 'mysql':
-                return 'mysql2';
-            case 'postgres':
-                return 'pg';
-            case 'oracle':
-                return 'oracledb';
-            case 'mssql':
-                return 'tedious';
-            default:
-                return (0, util_1.getModuleName)(err);
-        }
-    }
-}
-function getCacheItem(map, key) {
-    const result = map.get(key);
-    if (result) {
-        result[0] = Date.now();
-        return result[1];
-    }
-}
-function addCacheItem(map, key, data, timeout) {
-    if (!map.has(key)) {
-        ++CACHE_TOTAL;
-    }
-    map.set(key, [
-        Date.now(),
-        data,
-        setTimeout(() => deleteCacheItem(map, key), timeout * 1000 /* TIME.S */)
-    ]);
-}
-function deleteCacheItem(map, key) {
-    const item = map.get(key);
-    if (item) {
-        clearTimeout(item[2]);
-        map.delete(key);
-        --CACHE_TOTAL;
-    }
-}
-function spliceSource(source, startIndex, endIndex, pattern, leading = '', trailing = '', content = '') {
-    if (leading || trailing) {
-        content += getNewlineString(leading, trailing);
-    }
-    if (pattern && content) {
-        pattern.lastIndex = startIndex + content.length;
-    }
-    return spliceString(source, startIndex, endIndex, content);
-}
-function hasCondition(data, condition) {
-    if (!condition) {
-        return true;
-    }
-    let match = REGEXP_TEMPLATEMATCH.exec(condition.trim());
-    if (match) {
-        if (match[2]) {
-            const join = match[1];
-            const comparison = match[2];
-            const items = [];
-            while (match = REGEXP_TEMPLATECOMPARISON.exec(comparison)) {
-                if (items.length && !isSpace(match[0][0])) {
-                    return false;
-                }
-                items.push([match[1], match[2], match[3]]);
-            }
-            REGEXP_TEMPLATECOMPARISON.lastIndex = 0;
-            const length = items.length;
-            if (length > 1 && !join) {
-                return false;
-            }
-            const parseArg = (value) => {
-                if (!isNaN(+value)) {
-                    return +value;
-                }
-                if (match = /^(["'])([\S\s]*)\1$/.exec(value)) {
-                    return match[2];
-                }
-                return getObjectValue(data, value);
-            };
-            for (let i = 0; i < length; ++i) {
-                const item = items[i];
-                const arg1 = item[1];
-                const arg2 = item[2];
-                let valid;
-                if (arg2) {
-                    switch (item[0]) {
-                        case 'eq':
-                            valid = parseArg(arg1) == parseArg(arg2); // eslint-disable-line eqeqeq
-                            break;
-                        case 'ne':
-                            valid = parseArg(arg1) != parseArg(arg2); // eslint-disable-line eqeqeq
-                            break;
-                        case 'lt':
-                            valid = parseArg(arg1) < parseArg(arg2);
-                            break;
-                        case 'le':
-                            valid = parseArg(arg1) <= parseArg(arg2);
-                            break;
-                        case 'gt':
-                            valid = parseArg(arg1) > parseArg(arg2);
-                            break;
-                        case 'ge':
-                            valid = parseArg(arg1) >= parseArg(arg2);
-                            break;
-                        default:
-                            return false;
-                    }
-                }
-                else if (item[0]) {
-                    return false;
-                }
-                else {
-                    valid = isTruthy(data, arg1, false);
-                }
-                if (join === 'or') {
-                    if (valid) {
-                        return true;
-                    }
-                }
-                else {
-                    if (join === 'not') {
-                        valid = !valid;
-                    }
-                    if (!valid) {
-                        return false;
-                    }
-                }
-            }
-            return join === 'or' ? false : true;
-        }
-        if (match[7]) {
-            return isTruthy(data, match[7].trim(), match[6]);
-        }
-    }
-    return false;
-}
-function isTruthy(data, attr, falsey) {
-    const value = getObjectValue(data, attr);
-    return falsey ? !value : !!value;
-}
-function hasSameOrigin(value, ...other) {
-    for (let url of other) {
-        if (!url) {
-            continue;
-        }
-        try {
-            if (typeof value === 'string') {
-                value = new URL(value);
-            }
-            if (typeof url === 'string') {
-                url = new URL(url);
-            }
-            if (value.origin === url.origin) {
-                return true;
-            }
-        }
-        catch {
-        }
-    }
-    return false;
-}
-function restoreSearchParams(value, prefix = '__sqd') {
-    if (value) {
-        if (value.indexOf(prefix) !== -1) {
-            const params = new URLSearchParams(value);
-            params.forEach((_, key) => key.startsWith(prefix) && params.delete(key));
-            if (value = params.toString()) {
-                return '?' + value;
-            }
-        }
-        return value;
-    }
-    return '';
-}
-function getBaseURLs(asset, baseUrl) {
-    const result = [];
-    let parentUrl = asset ? asset.url || asset.uri : undefined;
-    try {
-        if (parentUrl) {
-            if (typeof parentUrl === 'string') {
-                parentUrl = new URL(parentUrl);
-                asset.url = parentUrl;
-            }
-            result.push(parentUrl);
-        }
-    }
-    catch {
-        parentUrl = undefined;
-    }
-    if (baseUrl) {
-        const url = new URL(baseUrl);
-        if (!parentUrl) {
-            result.push(parentUrl = url);
-        }
-        else if (parentUrl.origin !== url.origin) {
-            result.push(new URL(parentUrl.href.replace(parentUrl.origin, url.origin)), url);
-        }
-    }
-    return result;
-}
-function createHash(host, file, bufferMap) {
-    const hash = file.hash;
-    if (hash) {
-        try {
-            const localUri = file.localUri;
-            const buffer = localUri && bufferMap[localUri] || getBuffer(file);
-            if (buffer) {
-                const [algorithm, length] = (0, util_1.getHashData)(hash);
-                let value;
-                if (algorithm && (value = index_1.default.asHash(buffer, { algorithm, encoding: file.encoding }))) {
-                    if (localUri) {
-                        bufferMap[localUri] = buffer;
-                    }
-                    host.rename(file, (0, util_1.appendSuffix)(file.filename, length ? value.substring(0, length) : value));
-                    return file.filename;
-                }
-            }
-            throw (0, types_1.errorMessage)('hash', 'Source not found', file.filename);
-        }
-        catch (err) {
-            host.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, file.filename], err, 32 /* LOG_TYPE.FILE */);
-        }
-    }
-}
-function getSrcURL(parent, file) {
-    const relativeUrl = file.relativeUrl || this.host.removeCwd(file.localUri) && getRelativeURL(file);
-    if (!relativeUrl) {
-        return [''];
-    }
-    if (parent.inlineContent) {
-        return [relativeUrl];
-    }
-    let parentDir = parent.pathname, assetDir = file.pathname;
-    if (!this.productionRelease) {
-        if (parent.moveTo) {
-            parentDir = joinPath(parent.moveTo, parentDir);
-        }
-        if (file.moveTo) {
-            assetDir = joinPath(file.moveTo, assetDir);
-        }
-    }
-    if (parentDir === assetDir) {
-        return [file.filename, true];
-    }
-    const splitPath = (value) => value.split(/[\\/]/).filter(segment => segment.trim());
-    const prefix = splitPath(parentDir);
-    const suffix = splitPath(assetDir);
-    let found;
-    while (prefix.length && suffix.length && prefix[0] === suffix[0]) {
-        prefix.shift();
-        suffix.shift();
-        found = true;
-    }
-    return [found ? joinPath('../'.repeat(prefix.length), suffix.join('/'), file.filename) : '../'.repeat(prefix.length) + relativeUrl];
-}
-function transformURL(host, parent, type, source, importFile) {
-    const related = [];
-    const baseHref = getBaseURLs(importFile || parent, this.baseUrl);
-    const isHtml = type === 'html';
-    const isJs = type === 'js';
-    const pattern = isJs ? /\bimport\(/g : type === 'svg' ? /(?:\b[Uu][Rr][Ll]\(|@import\s+(["'])|\b([Hh][Rr][Ee][Ff])\s*=)/g : /\b[Uu][Rr][Ll]\(|@import\s+(["'])/g;
-    let length = source.length, modified, match;
-    while (match = pattern.exec(source)) {
-        const isText = !!match[1];
-        const isHref = !!match[2];
-        const isUrl = !isText && !isHref;
-        const startIndex = match.index;
-        let quote = match[1], content = '', trailing = '', closed = -1, i = startIndex + match[0].length;
-        for (let j = -1; i < length; ++i) {
-            const ch = source[i];
-            if (quote && ch === quote) {
-                if (!isText) {
-                    content += ch;
-                }
-                if (isHref) {
-                    break;
-                }
-                if (source[i - 1] !== '\\') {
-                    if (isText) {
-                        break;
-                    }
-                    if (closed === -1) {
-                        closed = i + 1;
-                    }
-                }
-                j = i + 1;
-                continue;
-            }
-            if (!quote && (ch === '"' || ch === "'" || ch === '`' && isJs) && (isHref || !content.trim())) {
-                quote = ch;
-            }
-            else if (isHref && !quote && isSpace(ch) && content.trim()) {
-                break;
-            }
-            else if (ch === ')') {
-                if (isUrl) {
-                    if (quote && closed !== -1 || !quote && (isJs || source[i - 1] !== '\\')) {
-                        break;
-                    }
-                    j = i;
-                }
-            }
-            else if (j !== -1 && (ch === '\n' ||
-                isText && (ch === ';' || ch === '{') ||
-                isHref && (ch === '=' || ch === '>') ||
-                isUrl && (ch === ';' ||
-                    !isJs && (!isHtml && (ch === ':' && !isJs || ch === '}') ||
-                        isHtml && (ch === '"' || ch === "'" || ch === ':' || ch === '>'))))) {
-                if (closed !== -1) {
-                    i = closed;
-                }
-                else {
-                    content = content.substring(0, i = j);
-                }
-                break;
-            }
-            if (closed === -1) {
-                content += ch;
-            }
-        }
-        const setOutputURL = (value, asset) => {
-            if (!value) {
-                return;
-            }
-            if (asset) {
-                if (!asset.inlineBase64) {
-                    if (host.Cloud?.getStorage('upload', asset.cloudStorage)) {
-                        const inlineUrlCloud = asset.inlineUrlCloud || (asset.inlineUrlCloud = (0, types_1.generateUUID)());
-                        (parent.inlineUrlCloudMap || (parent.inlineUrlCloudMap = {}))[inlineUrlCloud] = value;
-                        value = inlineUrlCloud;
-                    }
-                    else if (asset.hash && this.productionRelease) {
-                        const inlineUrl = asset.inlineUrl || (asset.inlineUrl = (0, types_1.generateUUID)());
-                        (parent.inlineUrlMap || (parent.inlineUrlMap = {}))[inlineUrl] = value;
-                        value = inlineUrl;
-                    }
-                }
-                const font = findFont(asset.format);
-                if (font) {
-                    found: {
-                        for (let k = i + 1; k < length; ++k) {
-                            switch (source[k]) {
-                                case ')': {
-                                    const component = source.substring(i + 1, k + 1);
-                                    const format = /\s+format\([^)]+\)$/i.exec(component);
-                                    if (format) {
-                                        trailing = component.replace(format[0], ` format("${font}")`);
-                                        i = k;
-                                        break found;
-                                    }
-                                    break;
-                                }
-                                case ',':
-                                case ';':
-                                case ':':
-                                case '}':
-                                    break found;
-                            }
-                        }
-                    }
-                }
-                if (asset.initialValue && !asset.initialValue.cacheable) {
-                    parent.flags |= 16 /* ASSET_FLAG.MODIFIED */;
-                }
-                related.push(asset);
-            }
-            if (!quote && !isHtml && !isJs) {
-                if (value.indexOf('"') === -1) {
-                    quote = '"';
-                }
-                else if (value.indexOf("'") === -1) {
-                    quote = "'";
-                }
-            }
-            if (isUrl) {
-                const index = value.indexOf('#');
-                if (index !== -1) {
-                    value = value.substring(0, index);
-                }
-            }
-            if (quote) {
-                value = quote + value + quote;
-            }
-            const revised = isJs ? 'import(' + value + trailing + ')' : isHref ? 'href=' + value : (isText ? '@import ' + value : `url(${value})`) + trailing;
-            source = spliceString(source, startIndex, i + 1, revised);
-            length = source.length;
-            pattern.lastIndex = startIndex + revised.length;
-            modified = true;
-        };
-        let url;
-        if (isJs) {
-            if (!quote) {
-                continue;
-            }
-            const file = new RegExp('^\\s*(' + quote + '((?:[^' + quote + ']|(?<=\\\\)' + quote + ')+)' + quote + ')\\s*(,.+)$').exec(content);
-            if (file) {
-                url = file[1].trim();
-                trailing = file[2].trim();
-            }
-            else {
-                url = trimQuote(content);
-            }
-        }
-        else {
-            url = trimQuote(content);
-        }
-        if (url.startsWith('data:')) {
-            const base64 = url.split(',')[1]?.trim();
-            if (base64) {
-                for (const item of this.assets) {
-                    if (item.base64 === base64) {
-                        setOutputURL(getSrcURL.call(this, parent, item)[0], item);
-                        break;
-                    }
-                }
-            }
-        }
-        else if (baseHref.length) {
-            let fullUrl, asset;
-            for (const parentUrl of baseHref) {
-                if (asset = host.findAsset(fullUrl = resolvePath(url, parentUrl), { replaced: true }) || (this.related.has(parent) ? host.findAsset(fullUrl, { assets: Array.from(this.related.get(parent)), replaced: true }) : undefined)) {
-                    break;
-                }
-            }
-            if (asset && asset !== importFile) {
-                if (!(0, util_1.hasValue)(asset.format, 'base64')) {
-                    if (asset.bundleReplace) {
-                        let k, valid;
-                        if (!isText) {
-                            let j = startIndex;
-                            while (isSpace(source[--j])) { }
-                            valid = source.substring(k = j - 6, j + 1) === '@import';
-                        }
-                        else {
-                            k = startIndex;
-                            valid = true;
-                        }
-                        if (valid) {
-                            let l = i, revised = transform_1.SourceMap.removeSourceMappingURL(host.getUTF8String(asset))[0];
-                            for (let ch; l < length; ++l) {
-                                if ((ch = source[l]) === ';' || ch === '\n') {
-                                    break;
-                                }
-                            }
-                            const layer = this.replaceContent(revised, source.substring(k, l + 1), 'text/css');
-                            if (layer) {
-                                revised = layer;
-                            }
-                            source = spliceString(source, k, l + 1, revised = transformURL.call(this, host, parent, type, this.removeServerRoot(revised), asset) || revised);
-                            length = source.length;
-                            pattern.lastIndex = k + revised.length;
-                            if (!parent.watch) {
-                                host.deleteFile(asset.localUri, { ignorePermission: true, emptyDir: true, all: true, id: asset.id });
-                                asset.invalid = true;
-                            }
-                            else {
-                                related.push(asset);
-                                if (!(0, types_1.existsFlag)(asset.flags)) {
-                                    asset.flags |= 8 /* ASSET_FLAG.WATCH */;
-                                }
-                            }
-                            modified = true;
-                            continue;
-                        }
-                    }
-                    if (hasSameOrigin(asset.url || fullUrl, ...baseHref)) {
-                        let sameDir;
-                        [fullUrl, sameDir] = getSrcURL.call(this, parent, asset);
-                        if (sameDir && isJs) {
-                            fullUrl = './' + fullUrl;
-                        }
-                    }
-                    else {
-                        const pathname = parent.pathname;
-                        const count = pathname && pathname !== '/' && pathname !== '\\' ? pathname.split(/[\\/]/).length : 0;
-                        fullUrl = (count ? '../'.repeat(count) : '') + asset.relativeUrl;
-                    }
-                }
-                else if (!asset.invalid) {
-                    fullUrl = asset.inlineBase64 || (asset.inlineBase64 = (0, types_1.generateUUID)());
-                }
-                if (url !== fullUrl) {
-                    setOutputURL(fullUrl, asset);
-                }
-            }
-            else if (importFile && url !== fullUrl) {
-                setOutputURL(fullUrl);
-            }
-        }
-    }
-    if (modified) {
-        if (related.length) {
-            const previous = this.related.get(parent);
-            if (previous) {
-                related.forEach(item => previous.add(item));
-            }
-            else {
-                this.related.set(parent, new Set(related));
-            }
-        }
-        return source;
-    }
-}
-function getFormatUUID(attr, ext) {
-    const format = 'formatMap' in this ? this.formatMap : this.module.format;
-    let pattern;
-    if ((0, types_1.isObject)(format) && (0, types_1.isObject)(pattern = ext && ext in format ? format[ext] : format.uuid) && pattern[attr]) {
-        return (0, types_1.randomString)(pattern[attr], pattern.dictionary);
-    }
-    return (0, types_1.generateUUID)();
-}
-function setLocationUUID(data, file, ext) {
-    const { pathname, filename } = data;
-    const assignUUID = ChromeDocument.INTERNAL_ASSIGNUUID;
-    let index, modified;
-    if (filename) {
-        ext || (ext = path.extname(filename).substring(1));
-        if ((index = filename.indexOf(assignUUID)) !== -1) {
-            data.filename = spliceString(filename, index, index + assignUUID.length, getFormatUUID.call(this, 'filename', ext));
-            if (file) {
-                file.inlineFilename = data.filename;
-            }
-            modified = true;
-        }
-    }
-    if (pathname && (index = pathname.indexOf(assignUUID)) !== -1) {
-        data.pathname = spliceString(pathname, index, index + assignUUID.length, getFormatUUID.call(this, 'pathname', ext));
-        modified = true;
-    }
-    if (file && modified) {
-        (0, asset_1.setInitialValue)(file, false);
-        if (file.hash) {
-            delete file.hash;
-        }
-    }
-}
-function transformOptions(file, mimeType, code, bundleContent) {
-    const { uri, localUri, exported } = file;
-    let metadata;
-    if (mimeType === 'text/css') {
-        metadata = { ...this.config, ...file.metadata };
-    }
-    else if (mimeType === 'text/html') {
-        metadata = { '__fromhtml__': true, ...this.config, ...file.metadata };
-    }
-    else {
-        metadata = file.metadata;
-    }
-    const [pathname, filename] = localUri ? [path.dirname(localUri), path.basename(localUri)] : ['', file.filename];
-    const options = { pathname, filename, mimeType, metadata, imported: !!file.imports && file.imported !== false };
-    const sourceFile = !exported && uri && this.findSourceRoot(uri);
-    if (sourceFile) {
-        if (isPath(sourceFile)) {
-            options.sourceFile = sourceFile;
-        }
-        options.sourceName = path.basename(sourceFile);
-        options.sourcesRelativeTo = path.dirname(sourceFile);
-        options.getMainFile = this.resolveSourceFile(file);
-        if (code) {
-            options.getSourceFiles = this.locateSourceFiles(file, code, bundleContent);
-        }
-    }
-    if ((!this.productionRelease || this.productionIncremental) && !(0, types_1.modifiedFlag)(file.flags)) {
-        options.cacheData = { uri: !exported ? uri : undefined, etag: !file.modified ? file.etag : undefined, encoding: file.encoding };
-    }
-    return options;
-}
-function transformJs(host, file, output) {
-    const { sourceFiles, chunks, map } = output;
-    const localUri = file.localUri;
-    const emptySources = !!this.productionRelease;
-    let uri;
-    if (map && (uri = writeSourceMap(localUri, output, { hash: file.hash, emptySources, inlineMap: hasSourceMap(file.metadata, 'inline') }))) {
-        host.add(uri, file, types_1.FILE_TYPE.SOURCEMAP);
-    }
-    if (chunks) {
-        const elements = this.elements;
-        const localDir = path.dirname(localUri);
-        const relativeDir = joinPath(file.moveTo, file.pathname);
-        const element = file.element;
-        let order = 0, index, appending;
-        if (element) {
-            index = element.index;
-            for (const item of elements) {
-                const append = item.append;
-                if (append && !append.prepend && dom_1.DomWriter.isEqual(item, element, host.moduleName, true)) {
-                    (appending || (appending = [])).push(append);
-                }
-            }
-        }
-        for (const chunk of chunks) {
-            let chunkName = chunk.filename;
-            if (!chunkName) {
-                chunkName = getFormatUUID.call(this, 'filename', 'js') + path.extname(localUri);
-                chunk.entryPoint = true;
-            }
-            const chunkUri = path.join(localDir, chunkName);
-            if (chunk.map && (uri = writeSourceMap(chunkUri, chunk, { emptySources, inlineMap: hasSourceMap(file.metadata, 'inline') }))) {
-                host.add(uri, file, types_1.FILE_TYPE.SOURCEMAP);
-            }
-            try {
-                fs.writeFileSync(chunkUri, chunk.code);
-                host.add(chunkUri, file);
-                if (chunk.entryPoint) {
-                    if (element) {
-                        const attributes = { ...file.attributes, src: joinPath(relativeDir, chunkName) };
-                        if (file.imports && file.imported !== false) {
-                            attributes.type || (attributes.type = 'module');
-                        }
-                        elements.push({
-                            ...element,
-                            attributes,
-                            append: { tagName: 'script', tagCount: element.tagCount, nextSibling: dom_1.DomWriter.isIndex(index) ? index + 1 : undefined, order: ++order }
-                        });
-                    }
-                    else {
-                        this.writeFail(['Unable to create element entry point', path.basename(chunkUri)], (0, types_1.errorMessage)('js', 'Element not found', chunkUri), 4 /* LOG_TYPE.PROCESS */);
-                    }
-                }
-            }
-            catch (err) {
-                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(chunkUri)], err, 32 /* LOG_TYPE.FILE */);
-            }
-        }
-        appending?.forEach(item => item.order += order);
-    }
-    if ((0, types_1.isArray)(sourceFiles)) {
-        file.sourceFiles = sourceFiles;
-    }
-    file.modified = true;
-    return file.sourceUTF8 = output.code;
-}
-function replaceCss(file) {
-    const sanitize = (map) => {
-        for (const id in map) {
-            map[id] = this.removeServerRoot(map[id]).replace(/^\//, '');
-        }
-    };
-    if (file.inlineUrlMap) {
-        sanitize(file.inlineUrlMap);
-    }
-    if (file.inlineUrlCloudMap) {
-        sanitize(file.inlineUrlCloudMap);
-    }
-}
-function replaceHtml(source, { productionRelease, contentMap }, cssMap) {
-    for (const data of [cssMap, contentMap]) {
-        for (const id in data) {
-            source = source.replace(new RegExp((0, types_1.escapePattern)(id), 'g'), data[id]);
-        }
-    }
-    return productionRelease ? this.removeServerRoot(source) : source;
-}
-function isWatched(file) {
-    const { initialValue, format } = file;
-    if (file.imported || file.bundleReplace || file.inlineContent || file.inlineBase64 || this.replaced.includes(file) || initialValue && (file.inlineFilename !== initialValue.inlineFilename || file.pathname !== initialValue.pathname || initialValue.cacheable === false) || format && ((0, util_1.hasValue)(format, 'base64') || (0, util_1.hasValue)(format, 'woff') || (0, util_1.hasValue)(format, 'woff2'))) {
-        return true;
-    }
-    return false;
-}
-function loadLocalFile(item, pathname, cacheData, encoding, out) {
-    let content;
-    encoding = (0, types_1.getEncoding)(encoding);
-    if (out) {
-        content = fs.readFileSync(pathname, encoding);
-        out.content = content;
-    }
-    const ext = path.extname(pathname).substring(1).toLowerCase();
-    if (ext === 'cjs') {
-        return require(pathname);
-    }
-    content || (content = fs.readFileSync(pathname, encoding));
-    const result = this.tryParse(content, ext);
-    if (result !== undefined && result !== null) {
-        setCacheData.call(this, item, result, pathname, cacheData, true);
-        return result;
-    }
-}
-function setCacheData(item, data, dataKey, cacheData, template) {
-    if ((0, types_1.isObject)(data) || template) {
-        const cache = this.settingsOf(item.source, template && item.source !== 'local' ? 'local_file' : 'cache');
-        let timeout;
-        if (cache && (timeout = core_1.ClientDb.getTimeout(cache)) && timeout > 0) {
-            addCacheItem(template ? CACHE_LOCALFILE : CACHE_DBRESULT, dataKey, data, timeout);
-        }
-        else {
-            cacheData[dataKey] = data;
-        }
-    }
-}
-async function checkData(item, name, result, validate) {
-    let callback;
-    if (typeof name === 'string') {
-        const template = this.findDataValue(name) || name;
-        callback = this.hasEval('userconfig') ? index_1.default.parseFunction(template, this.hasEval('absolute')) : (0, types_1.asFunction)(template);
-    }
-    else {
-        callback = name;
-        name = '';
-    }
-    if (typeof callback === 'function') {
-        try {
-            let output;
-            // @ts-ignore
-            if (callback["__cjs__" /* INTERNAL.CJS */]) {
-                output = await callback(result, item);
-            }
-            else {
-                output = await callback.apply(index_1.default.enabled("node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */) ? process : null, index_1.default.enabled("node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */) ? [result, item, require] : [result, item]);
-            }
-            if (validate(output)) {
-                return output;
-            }
-        }
-        catch (err) {
-            this.writeFail(["Unable to parse inline method" /* ERR_MESSAGE.INLINE_METHOD */, name], err);
-        }
-    }
-}
-const getNewlineString = dom_1.DomWriter.getNewlineString.bind(dom_1.DomWriter);
-const isSpace = dom_1.DomWriter.isSpace.bind(dom_1.DomWriter);
-const replaceMatch = dom_1.DomWriter.replaceMatch.bind(dom_1.DomWriter);
-const joinPath = index_1.default.joinPath.bind(index_1.default);
-const isPath = index_1.default.isPath.bind(index_1.default);
-const writeSourceMap = index_1.default.writeSourceMap.bind(index_1.default);
-const asString = index_1.default.asString.bind(index_1.default);
-const resolvePath = index_1.default.resolvePath.bind(index_1.default);
-const toPosix = index_1.default.toPosix.bind(index_1.default);
-const isDir = index_1.default.isDir.bind(index_1.default);
-const hasSourceMap = (metadata, value) => (0, types_1.isObject)(metadata) && metadata['__sourcemap__'] === value;
-const isBundled = (value, main) => typeof value === 'number' && (value > 0 || main && value === 0);
-const isFont = (value) => value === 'truetype' || value === 'opentype' || value === 'woff' || value === 'woff2';
-const isImage = (value) => typeof value === 'string' && value.startsWith('image/') && value !== 'image/svg+xml';
-const getBuffer = (item) => item.sourceUTF8 || item.buffer || (item.localUri && isPath(item.localUri) ? fs.readFileSync(item.localUri, item.encoding) : null);
-const isRemoved = (item) => item.exclude === true || isBundled(item.bundleIndex);
-const isUnedited = (item) => !item.attributes && !item.inlineContent && !item.srcSet && !item.element.dynamic && item.element.textContent === undefined && (!item.uri && !isBundled(item.bundleIndex, true) || (0, util_1.hasValue)(item.format, 'crossorigin'));
-const isIgnored = (item, exists) => item.invalid || (0, types_1.ignoreFlag)(item.flags) || !exists && (0, types_1.existsFlag)(item.flags);
-const findFont = (value) => value && (Array.isArray(value) ? value : [value]).find(format => isFont(format));
-const spliceString = (source, startIndex, endIndex, content) => source.substring(0, startIndex) + content + source.substring(endIndex);
-const getEndIndex = (match) => match.index + match[0].length;
-const getRelativeURL = (file) => joinPath(file.moveTo, file.pathname, file.inlineFilename || file.filename) + (!file.static ? restoreSearchParams(file.url?.search) : '');
-const errorHtml = ({ tagName, tagIndex = -1 }) => (0, types_1.errorMessage)('html', 'Location did not resolve', tagName.toLowerCase() + (tagIndex >= 0 ? ': ' + tagIndex : ''));
-const errorDataSource = (value, hint) => (0, types_1.errorMessage)('data-source', value, hint);
-class ChromeDocument extends index_1.default {
-    constructor() {
-        super(...arguments);
-        this.config = {
-            usedVariables: undefined,
-            usedFontFace: undefined,
-            usedKeyframes: undefined,
-            unusedStyles: undefined,
-            unusedMedia: undefined,
-            unusedContainer: undefined,
-            unusedSupports: undefined,
-            unusedAtRules: undefined,
-            useOriginalHtmlPage: undefined,
-            useUnsafeHtmlReplace: undefined,
-            useUnsafeCssReplace: undefined,
-            stripCommentsAndCDATA: undefined,
-            normalizeHtmlOutput: undefined,
-            escapeReservedCharacters: undefined,
-            ignoreServerCodeBlocks: undefined
-        };
-        this.htmlFile = null;
-        this.cssFiles = [];
-        this.jsFiles = [];
-        this.svgFiles = [];
-        this.baseDirectory = '';
-        this.baseUrl = '';
-        this.productionRelease = false;
-        this.productionIncremental = false;
-        this.templateMap = {};
-        this.related = new Map();
-        this.replaced = [];
-        this._moduleName = 'chrome';
-        this._threadable = true;
-        this._elements = null;
-        this._idMap = Object.create(null);
-        this._editing = [];
-        this._selectorMap = {};
-    }
-    static async purgeMemory(percent = 1, limit = 0, parent) {
-        if (typeof limit === 'boolean') {
-            parent = limit;
-            limit = 0;
-        }
-        let result = 0;
-        if (limit === 0 || CACHE_TOTAL >= limit) {
-            if (percent >= 1) {
-                result += CACHE_DBRESULT.size + CACHE_LOCALFILE.size;
-                CACHE_DBRESULT.clear();
-                CACHE_LOCALFILE.clear();
-                CACHE_TOTAL = 0;
-            }
-            else if (percent > 0) {
-                const stored = [];
-                for (const map of [CACHE_DBRESULT, CACHE_LOCALFILE]) {
-                    for (const [key, value] of map) {
-                        stored.push([map, key, value[0]]);
-                    }
-                }
-                stored.sort((a, b) => a[2] - b[2]);
-                result = Math.floor(stored.length * percent);
-                for (let i = 0; i < result; ++i) {
-                    const [map, key] = stored[i];
-                    deleteCacheItem(map, key);
-                }
-                CACHE_TOTAL = stored.length - result;
-            }
-        }
-        return result + (parent && result > 0 ? await super.purgeMemory(typeof parent === 'number' && parent > 0 ? parent : percent, limit, true) : 0);
-    }
-    static async finalize(instance) {
-        if (instance.aborted) {
-            return Promise.reject((0, types_1.createAbortError)());
-        }
-        const productionRelease = instance.productionRelease;
-        const processing = { host: this, startTime: process.hrtime(), hashed: new Set(), contentMap: {}, bufferMap: {}, cacheMiss: [], productionRelease: productionRelease ? true : undefined };
-        const { Db: db, htmlFile, assets } = instance;
-        const outHtml = htmlFile && !isIgnored(htmlFile, true);
-        if (db && await db.commit()) {
-            db.writeTimeElapsed('DB', ["Transactions were committed" /* VAL_MESSAGE.COMMIT_TRANSACTION */, db.moduleName], processing.startTime, { ...index_1.default.LOG_STYLE_SUCCESS, type: 65536 /* LOG_TYPE.DB */ });
-        }
-        if (instance.dataSource.length === 0 && outHtml) {
-            const incremental = htmlFile.incremental ?? this.incremental;
-            if (incremental === 'etag' || incremental === 'exists') {
-                const fetched = this.fetchedAssets;
-                const isHtmlOnly = () => !fetched.find(item => item !== htmlFile && assets.includes(item));
-                if (!productionRelease || instance.productionIncremental && (isHtmlOnly() || !fetched.find(item => item.hash))) {
-                    let hint = '';
-                    switch (incremental) {
-                        case 'etag': {
-                            if (outHtml) {
-                                const { etag, initialValue } = htmlFile;
-                                let buffer;
-                                if (!initialValue || !(etag && initialValue.etag === etag && (buffer = initialValue.buffer)) || fetched.find(item => item.bundleReplace && (!(0, types_1.isArray)(item.from) || item.from.includes('style')))) {
-                                    break;
-                                }
-                                try {
-                                    const { localUri, encoding } = htmlFile;
-                                    fs.writeFileSync(localUri, buffer, (0, types_1.getEncoding)(encoding));
-                                    htmlFile.buffer = buffer;
-                                    htmlFile.sourceUTF8 = undefined;
-                                }
-                                catch {
-                                    break;
-                                }
-                            }
-                            const { jsFiles, cssFiles, svgFiles } = instance;
-                            const copiedAssets = this.copiedAssets;
-                            const wasModified = (item) => fetched.includes(item) || copiedAssets.includes(item) && (!(0, types_1.isEmpty)(item.bundleId) || !(0, types_1.isEmpty)(item.trailingContent));
-                            const js = jsFiles.filter(item => item.imports || wasModified(item));
-                            const css = cssFiles.filter(wasModified);
-                            const svg = svgFiles.filter(wasModified);
-                            if (js.length || css.length || svg.length) {
-                                instance.jsFiles = js;
-                                instance.cssFiles = css;
-                                instance.svgFiles = svg;
-                                await instance.applyTransforms(processing);
-                            }
-                            hint = assets.filter(item => item.etag).length + ' assets';
-                        }
-                        case 'exists':
-                            if (hint || isHtmlOnly()) {
-                                this.formatMessage(4 /* LOG_TYPE.PROCESS */, 'HTML', ['No changes detected', 'incremental: ' + incremental], hint, { ...index_1.default.LOG_STYLE_NOTICE, messageBgColor: 'bgWhite', messageColor: 'black' });
-                                return super.finalize.call(this, instance);
-                            }
-                            break;
-                    }
-                }
-            }
-        }
-        instance.setInlinedAttributes(processing);
-        if (instance.editing.length) {
-            await instance.applyTransforms(processing);
-            if (instance.aborted) {
-                return Promise.reject((0, types_1.createAbortError)());
-            }
-        }
-        if (productionRelease) {
-            instance.setProductionAttributes(processing);
-        }
-        if (outHtml) {
-            await instance.rewriteHtml(processing);
-        }
-        return this.aborted ? Promise.reject((0, types_1.createAbortError)()) : super.finalize.call(this, instance);
-    }
-    static async cleanup(instance) {
-        if (instance.aborted) {
-            return Promise.reject((0, types_1.createAbortError)());
-        }
-        if (this.Watch) {
-            const related = instance.related;
-            let includes;
-            for (const asset of instance.assets) {
-                if (asset.watch && (includes = related.get(asset))) {
-                    if (!(0, types_1.isPlainObject)(asset.watch)) {
-                        asset.watch = {};
-                    }
-                    const items = new Set((asset.watch.assets || []));
-                    (function recurse(children) {
-                        for (const item of children) {
-                            if (!items.has(item)) {
-                                if (isWatched.call(instance, item)) {
-                                    item.flags |= 8 /* ASSET_FLAG.WATCH */;
-                                }
-                                items.add(item);
-                                const next = related.get(item);
-                                if (next) {
-                                    recurse(next);
-                                }
-                            }
-                        }
-                    })(includes);
-                    asset.watch.assets = Array.from(items);
-                }
-            }
-        }
-        let productionRelease = instance.productionRelease;
-        if ((0, types_1.isString)(productionRelease)) {
-            if (path.isAbsolute(productionRelease = path.normalize(productionRelease)) && isDir(productionRelease)) {
-                if (this.canWrite(productionRelease)) {
-                    const serverRoot = ChromeDocument.INTERNAL_SERVERROOT;
-                    const srcDir = path.join(this.baseDirectory, serverRoot);
-                    if (isDir(srcDir)) {
-                        const result = await index_1.default.copyDir(srcDir, productionRelease, !this.archiving);
-                        const failed = result.failed.map(value => this.removeCwd(value));
-                        for (const value of this.files) {
-                            if (value.startsWith(serverRoot)) {
-                                if (!failed.includes(value)) {
-                                    this.delete(value);
-                                }
-                                else {
-                                    instance.writeFail(["Unable to move file" /* ERR_MESSAGE.MOVE_FILE */, instance.moduleName], (0, types_1.errorMessage)('production', path.join(this.baseDirectory, value)), { fatal: true });
-                                }
-                            }
-                        }
-                    }
-                }
-                else {
-                    instance.writeFail(["Unable to write directory" /* ERR_MESSAGE.WRITE_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Access denied', productionRelease));
-                }
-            }
-            else {
-                instance.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Invalid directory', productionRelease), 32 /* LOG_TYPE.FILE */);
-            }
-        }
-    }
-    static sanitizeAssets(assets, exclusions = []) {
-        assets.forEach(item => {
-            if ((0, types_1.ignoreFlag)(item.flags)) {
-                return;
-            }
-            for (const attr in item) {
-                switch (attr) {
-                    case 'relativeUrl':
-                    case 'srcSet':
-                    case 'inlineUrl':
-                    case 'inlineUrlMap':
-                    case 'inlineUrlCloud':
-                    case 'inlineUrlCloudMap':
-                    case 'inlineBase64':
-                    case 'modified':
-                        if (!exclusions.includes(attr)) {
-                            delete item[attr];
-                        }
-                        break;
-                }
-            }
-        });
-    }
-    init(assets, config) {
-        assets.sort((a, b) => {
-            if (!(0, types_1.isEmpty)(a.bundleId) && a.bundleId === b.bundleId) {
-                return b.bundleIndex - a.bundleIndex;
-            }
-            return 0;
-        });
-        const cloud = [];
-        for (const item of assets) {
-            if ((0, types_1.ignoreFlag)(item.flags)) {
-                continue;
-            }
-            if (item.trailingContent) {
-                item.modified = true;
-            }
-            if (Array.isArray(item.cloudStorage)) {
-                cloud.push(item.cloudStorage);
-            }
-            if (item.editing) {
-                switch (item.mimeType) {
-                    case 'text/html':
-                        if (!this.htmlFile) {
-                            this.htmlFile = item;
-                            item.editing = true;
-                            this._editing.push(item);
-                        }
-                        else {
-                            item.editing = false;
-                        }
-                        item.mimeType = 'text/html';
-                        break;
-                    case 'text/css':
-                        this.cssFiles.push(item);
-                        this._editing.push(item);
-                        item.editing = true;
-                        item.mimeType = 'text/css';
-                        break;
-                    case 'text/javascript':
-                    case 'application/javascript':
-                        this.jsFiles.push(item);
-                        this._editing.push(item);
-                        item.editing = true;
-                        item.mimeType = 'application/javascript';
-                        break;
-                }
-            }
-        }
-        this.cssFiles.sort((a, b) => {
-            if (a.bundleReplace) {
-                return -1;
-            }
-            if (b.bundleReplace) {
-                return 1;
-            }
-            return 0;
-        });
-        if (config) {
-            const { useUnsafeReplace, baseUrl, productionRelease, productionIncremental, templateMap, imports, cache } = config;
-            const target = this.config;
-            for (const attr in config) {
-                if (attr in target) {
-                    target[attr] = config[attr];
-                }
-            }
-            switch (useUnsafeReplace) {
-                case 'html':
-                    target.useUnsafeHtmlReplace = true;
-                    break;
-                case 'css':
-                    target.useUnsafeCssReplace = true;
-                    break;
-                default:
-                    if (typeof useUnsafeReplace === 'boolean') {
-                        target.useUnsafeHtmlReplace = useUnsafeReplace;
-                        target.useUnsafeCssReplace = useUnsafeReplace;
-                    }
-                    else if ((0, types_1.isArray)(useUnsafeReplace)) {
-                        target.useUnsafeHtmlReplace = useUnsafeReplace.includes('html');
-                        target.useUnsafeCssReplace = useUnsafeReplace.includes('css');
-                    }
-                    break;
-            }
-            if (baseUrl) {
-                try {
-                    const { origin, pathname } = new URL(this.baseUrl = baseUrl);
-                    this.baseDirectory = origin + pathname.substring(0, pathname.lastIndexOf('/') + 1);
-                }
-                catch {
-                }
-            }
-            if (productionRelease === true || (0, types_1.isString)(productionRelease)) {
-                this.productionRelease = productionRelease;
-            }
-            if (productionIncremental) {
-                this.productionIncremental = true;
-            }
-            if ((0, types_1.isObject)(templateMap)) {
-                this.templateMap = templateMap;
-            }
-            this.imports = (0, types_1.isPlainObject)(imports) ? { ...this.module.imports, ...imports } : this.module.imports;
-            if ((0, types_1.isObject)(cache) && 'transform' in cache) {
-                this.customize({ transform: cache.transform });
-            }
-        }
-        super.init(assets, config);
-        const mimeMap = this._mimeMap;
-        if (mimeMap && 'format' in mimeMap) {
-            const format = mimeMap.format;
-            if ((0, types_1.isObject)(format)) {
-                this.formatMap = 'pathname' in format || 'filename' in format || 'dictionary' in format ? { uuid: format } : format;
-            }
-            else {
-                this.formatMap = undefined;
-            }
-        }
-        for (const storage of cloud) {
-            for (const { service, upload, download } of storage) {
-                if (upload) {
-                    setLocationUUID.call(this, upload, null, service);
-                }
-                if (download) {
-                    setLocationUUID.call(this, download, null, service);
-                }
-            }
-        }
-        return this;
-    }
-    findConfig(data, name, type) {
-        if (type && this.hasEval('template')) {
-            const settings = this.templateMap[type];
-            for (const attr in settings) {
-                const item = settings[attr];
-                if ((0, types_1.isObject)(item) && name in item) {
-                    const options = this.loadConfig(item, name);
-                    if (options) {
-                        return [attr, options, this.loadConfig(item, name + '-output')];
-                    }
-                    break;
-                }
-            }
-        }
-        return super.findConfig(data, name, type);
-    }
-    forDb(item) {
-        switch (item.source) {
-            case 'cloud':
-            case 'uri':
-            case 'local':
-            case 'export':
-                return false;
-            default:
-                return !item.element;
-        }
-    }
-    restart() {
-        ChromeDocument.sanitizeAssets(this.assets);
-        this._elements = null;
-        this._dataSource = null;
-    }
-    async using(data) {
-        if (this.aborted) {
-            return Promise.reject((0, types_1.createAbortError)());
-        }
-        const file = data.file;
-        if (file.editing) {
-            return;
-        }
-        const host = data.host;
-        const productionRelease = this.productionRelease ? true : undefined;
-        const { localUri, mimeType, format } = file;
-        const hash = productionRelease && file.hash;
-        switch (mimeType) {
-            case 'text/html':
-                if (format) {
-                    const output = await this.transform('html', host.getUTF8String(file, localUri), format, transformOptions.call(this, file, mimeType));
-                    if (output) {
-                        file.modified = true;
-                        file.sourceUTF8 = output.code;
-                    }
-                }
-                break;
-            case 'text/css':
-                if (format) {
-                    const source = host.getUTF8String(file, localUri);
-                    const output = await this.transform('css', source, format, transformOptions.call(this, file, mimeType, source));
-                    if (output) {
-                        if (output.map) {
-                            const uri = writeSourceMap(localUri, output, { mimeType, hash, emptySources: productionRelease, inlineMap: hasSourceMap(file.metadata, 'inline') });
-                            if (uri) {
-                                host.add(uri, file, types_1.FILE_TYPE.SOURCEMAP);
-                            }
-                        }
-                        file.modified = true;
-                        file.sourceUTF8 = output.code;
-                    }
-                }
-                break;
-            case 'text/javascript':
-            case 'application/javascript': {
-                let source = host.getUTF8String(file, localUri);
-                if (!(file.bundleIndex >= 0)) {
-                    source = host.setAssetContent(file, source);
-                }
-                const bundle = host.getAssetContent(file);
-                if (bundle) {
-                    source += bundle;
-                    file.modified = true;
-                }
-                if (format) {
-                    const output = await this.transform('js', source, format, transformOptions.call(this, file, mimeType, source, host.contentToAppend.get(localUri)));
-                    if (output) {
-                        source = transformJs.call(this, host, file, output);
-                    }
-                }
-                file.sourceUTF8 = source;
-                break;
-            }
-            case 'image/svg+xml': {
-                const source = host.getUTF8String(file, localUri);
-                if (/\burl\(/i.test(source)) {
-                    file.editing = true;
-                    this.editing.push(file);
-                    this.svgFiles.push(file);
-                }
-                else if (format) {
-                    const output = await this.transform('html', source, format, transformOptions.call(this, file, mimeType, source));
-                    if (output) {
-                        file.modified = true;
-                        file.sourceUTF8 = output.code;
-                    }
-                }
-                break;
-            }
-            case 'font/ttf':
-            case 'font/otf':
-            case 'font/woff':
-            case 'font/woff2': {
-                const setFormat = (type) => {
-                    if (Array.isArray(format)) {
-                        file.format = format.filter(value => !isFont(value));
-                        if (type) {
-                            file.format.push(type);
-                        }
-                    }
-                    else {
-                        file.format = type;
-                    }
-                };
-                let to;
-                if (mimeType.includes('woff')) {
-                    if ((0, util_1.hasValue)(format, 'truetype')) {
-                        to = 'ttf';
-                    }
-                    else if ((0, util_1.hasValue)(format, 'opentype')) {
-                        to = 'otf';
-                    }
-                    else {
-                        return;
-                    }
-                }
-                else if ((0, util_1.hasValue)(format, 'woff')) {
-                    to = 'woff';
-                }
-                else if ((0, util_1.hasValue)(format, 'woff2')) {
-                    to = 'woff2';
-                }
-                else {
-                    return;
-                }
-                const instance = host.loadModule('compress');
-                const buffer = host.getBuffer(file);
-                if (instance && buffer) {
-                    await instance.tryFile(buffer, { format: to, filename: file.filename, etag: file.etag }, (err, result, ext) => {
-                        if (err) {
-                            setFormat();
-                            this.writeFail("Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, err, 8 /* LOG_TYPE.COMPRESS */);
-                        }
-                        else if (result) {
-                            if (ext) {
-                                setFormat(ext.startsWith('woff') ? ext : ext === 'otf' ? 'opentype' : 'truetype');
-                            }
-                            const output = (0, types_1.renameExt)(localUri, ext || (ext = to));
-                            file.mimeType = 'font/' + ext;
-                            fs.writeFile(output, result, error => {
-                                if (!error) {
-                                    file.buffer = result;
-                                    host.replace(file, output);
-                                }
-                                else {
-                                    this.writeFail("Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, error, 32 /* LOG_TYPE.FILE */);
-                                }
-                            });
-                        }
-                    });
-                }
-                break;
-            }
-        }
-    }
-    setLocalUri(file, replace) {
-        if (replace) {
-            let trailing = file.inlineFilename;
-            if (trailing) {
-                let index = trailing.indexOf('?');
-                if (index !== -1 || (index = trailing.indexOf('#')) !== -1) {
-                    trailing = trailing.substring(index);
-                }
-                else {
-                    trailing = '';
-                }
-            }
-            else {
-                trailing = '';
-            }
-            file.inlineFilename = file.filename + trailing;
-            this.replaced.push(file);
-        }
-        else {
-            setLocationUUID.call(this, file, file);
-        }
-        file.relativeUrl = getRelativeURL(file);
-    }
-    resolveUri(file, source, trailing) {
-        const host = this.host;
-        if (host) {
-            switch (file.mimeType) {
-                case 'text/javascript':
-                case 'application/javascript':
-                    if (file.imports) {
-                        [[file.uri, source], [this.baseUrl, trailing]].forEach(([uri, code], index) => {
-                            let localFile;
-                            if (uri && code && (localFile = this.findSourceRoot(uri))) {
-                                const { exported, bundleId } = file;
-                                const bundleMain = !(0, types_1.isEmpty)(bundleId) && this.assets.find(item => item.bundleId === bundleId && item.bundleIndex === 0);
-                                let output;
-                                if ((index === 1 || exported) && Array.isArray(file.imports)) {
-                                    output = this.resolveImports(file, code, bundleMain || file);
-                                }
-                                else if (index === 0 && !exported) {
-                                    if (!isDir(localFile)) {
-                                        localFile = path.dirname(localFile);
-                                    }
-                                    let mainFile, pathname, match;
-                                    const ignorePath = bundleMain && (mainFile = this.findSourceRoot(bundleMain.uri)) && (isDir(mainFile) || (mainFile = path.dirname(mainFile))) && mainFile === localFile;
-                                    while (match = REGEXP_IMPORTMODULE.exec(code)) {
-                                        const value = match[1] || match[2] || match[4];
-                                        const assert = match[3] || match[5];
-                                        const from = trimQuote(value);
-                                        const relative = /^\.{0,2}\//.test(from);
-                                        if (assert && /\btype\s*:\s*(["'`])css\1/.test(assert)) {
-                                            try {
-                                                const asset = host.findAsset(relative ? new URL(from, uri) : from);
-                                                if (asset) {
-                                                    const [relativeUrl, sameDir] = getSrcURL.call(this, bundleMain || file, asset);
-                                                    if (relativeUrl) {
-                                                        const quote = value[0];
-                                                        output = (output || code).replace(value, quote + (sameDir ? './' : '') + relativeUrl + quote);
-                                                    }
-                                                }
-                                            }
-                                            catch {
-                                            }
-                                            continue;
-                                        }
-                                        if (relative) {
-                                            if (ignorePath) {
-                                                continue;
-                                            }
-                                            pathname = path.join(localFile, from);
-                                        }
-                                        else if (!(pathname = this.findSourceRoot(from)) || !isPath(pathname)) {
-                                            const asset = host.findAsset(from);
-                                            if (asset && !asset.invalid) {
-                                                pathname = asset.localUri;
-                                            }
-                                            else {
-                                                continue;
-                                            }
-                                        }
-                                        if (pathname && isPath(pathname)) {
-                                            const quote = value[0];
-                                            output = (output || code).replace(value, quote + pathname + quote);
-                                        }
-                                    }
-                                    REGEXP_IMPORTMODULE.lastIndex = 0;
-                                }
-                                if (output) {
-                                    if (index === 0) {
-                                        source = output;
-                                    }
-                                    else {
-                                        trailing = output;
-                                    }
-                                }
-                            }
-                        });
-                    }
-                    break;
-                case 'text/css':
-                    if (file.editing) {
-                        const htmlFile = this.htmlFile;
-                        const bundleId = file.bundleId;
-                        if (!(0, types_1.isEmpty)(bundleId)) {
-                            for (const asset of this.assets) {
-                                if (asset.bundleIndex === 0 && asset.bundleId === bundleId) {
-                                    const output = transformURL.call(this, host, file, 'css', source, asset);
-                                    if (output) {
-                                        source = output;
-                                        file.modified = true;
-                                    }
-                                    break;
-                                }
-                            }
-                        }
-                        if (trailing && htmlFile) {
-                            const output = transformURL.call(this, host, file, 'css', trailing, htmlFile);
-                            if (output) {
-                                trailing = output;
-                            }
-                        }
-                    }
-                    break;
-            }
-        }
-        return (trailing !== undefined ? [source, trailing] : source);
-    }
-    resolveImports(file, code, baseFile) {
-        var _a;
-        if (!Array.isArray(file.imports)) {
-            return;
-        }
-        let bundleMain, modified;
-        if ((0, types_1.isPlainObject)(baseFile)) {
-            bundleMain = baseFile;
-        }
-        else {
-            const bundleId = file.bundleId;
-            if (!(0, types_1.isEmpty)(bundleId)) {
-                bundleMain = this.assets.find(item => item.bundleId === bundleId && item.bundleIndex === 0);
-            }
-        }
-        const importMap = {};
-        for (const item of file.imports) {
-            (importMap[_a = item.placeholder] || (importMap[_a] = [])).push(item);
-        }
-        for (const placeholder in importMap) {
-            const items = importMap[placeholder];
-            for (let i = 0, length = items.length; i < length; ++i) {
-                const index = code.indexOf(placeholder);
-                if (index !== -1) {
-                    const { uri, original, type, dynamic } = items[i];
-                    let value;
-                    if (type === 'css') {
-                        const asset = this.host?.findAsset(uri);
-                        if (asset) {
-                            const [relativeUrl, sameDir] = getSrcURL.call(this, bundleMain || file, asset);
-                            if (relativeUrl) {
-                                value = (sameDir ? './' : '') + relativeUrl;
-                            }
-                        }
-                    }
-                    else if (!(dynamic && file.imported !== false)) {
-                        value = this.findSourceRoot(uri);
-                    }
-                    if (!value) {
-                        if (i < length - 1) {
-                            continue;
-                        }
-                        value = original;
-                    }
-                    code = spliceString(code, index, index + placeholder.length, value);
-                    modified = true;
-                    break;
-                }
-            }
-        }
-        if (modified) {
-            return code;
-        }
-    }
-    replaceContent(source, statement, mimeType) {
-        switch (mimeType) {
-            case 'text/css': {
-                const match = /^@import\s+(?:url\((?:[^)]|(?<=\\)\))+\)|"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(\s*layer(?:\(([^)]*)\)|\b))?(?:\s*supports\(((?:\([^(]+\(|\([^)]+\)|\)[^)]+\)|(?:(?!\))[^(])+|(?:(?!\()[^)])+)+)\))?(.*?);?$/.exec((typeof statement === 'string' ? statement : statement[0]).trim());
-                if (match) {
-                    const layer = match[1];
-                    const supports = match[3]?.trim();
-                    const query = match[4].trim();
-                    if (layer || supports || query) {
-                        const newline = (0, util_1.getNewline)(source);
-                        let result = supports ? `@supports (${match[1].trim()}) {` + newline : '';
-                        if (query) {
-                            result += `@media ${query} {` + newline;
-                        }
-                        if (layer) {
-                            let name = match[2];
-                            result += '@layer ' + (name && (name = name.trim()) ? name + ' ' : '') + `{${newline + source + newline}}` + (query ? newline + '}' : '');
-                        }
-                        else if (query) {
-                            result += source + newline + '}';
-                        }
-                        if (supports) {
-                            result += newline + '}';
-                        }
-                        return result;
-                    }
-                }
-                break;
-            }
-        }
-    }
-    removeServerRoot(value) {
-        return value.replace(new RegExp('(\\.\\./)*' + (0, types_1.escapePattern)(ChromeDocument.INTERNAL_SERVERROOT), 'g'), '');
-    }
-    addCopy(data, saveAs) {
-        if (data.command && this.host) {
-            const match = REGEXP_SRCSETSIZE.exec(data.command);
-            if (match) {
-                return (0, types_1.renameExt)(this.host.getLocalUri(data), match[1] + match[2].toLowerCase() + '.' + saveAs);
-            }
-        }
-    }
-    writeImage(data) {
-        const { file, output, command } = data;
-        if (output && command && file.element?.outerXml) {
-            const match = REGEXP_SRCSETSIZE.exec(command);
-            if (match) {
-                (file.srcSet || (file.srcSet = [])).push(toPosix(data.baseDirectory ? output.substring(data.baseDirectory.length + 1) : output), match[1] + match[2].toLowerCase());
-                file.modified = true;
-                return true;
-            }
-        }
-        return false;
-    }
-    cloudInit({ instance }) {
-        this._cloudUrlMap = Object.create(null);
-        this._cloudUploaded = new Set();
-        this._cloudEndpoint = null;
-        if (this.htmlFile) {
-            const endpoint = instance.getStorage('upload', this.htmlFile.cloudStorage)?.upload?.endpoint;
-            if (endpoint) {
-                this._cloudEndpoint = new RegExp((0, types_1.escapePattern)(toPosix(endpoint)) + '/', 'g');
-            }
-        }
-    }
-    cloudObject(state, file) {
-        if (file.inlineUrlCloud) {
-            this._cloudUrlMap[file.inlineUrlCloud] = file;
-        }
-        return this.editing.includes(file);
-    }
-    cloudUpload({ host }, file, url, active) {
-        if (active) {
-            const endpoint = this._cloudEndpoint;
-            const inlineUrlCloud = file.inlineUrlCloud;
-            const cloudUrl = endpoint ? url.replace(endpoint, '') : url;
-            file.cloudUrl = cloudUrl;
-            if (inlineUrlCloud) {
-                const htmlFile = this.htmlFile;
-                const pattern = new RegExp((0, types_1.escapePattern)(inlineUrlCloud), 'g');
-                for (const item of this.editing) {
-                    if (item.inlineUrlCloudMap?.[inlineUrlCloud]) {
-                        const source = host.getUTF8String(item);
-                        const output = source.replace(pattern, endpoint && item !== htmlFile && cloudUrl.indexOf('/') !== -1 ? url : cloudUrl);
-                        if (source !== output) {
-                            item.sourceUTF8 = output;
-                            item.modified = true;
-                        }
-                    }
-                }
-                this._cloudUploaded.add(inlineUrlCloud);
-            }
-        }
-        return Promise.resolve(false);
-    }
-    async cloudFinalize(state) {
-        if (this.aborted) {
-            return Promise.reject((0, types_1.createAbortError)());
-        }
-        const { host, instance, localStorage } = state;
-        const htmlFile = this.htmlFile;
-        const tasks = [];
-        const checkDocument = (item) => {
-            if (item.inlineUrlCloudMap) {
-                const source = host.getUTF8String(item);
-                let output;
-                for (const id in this._cloudUrlMap) {
-                    const inlineUrlCloud = item.inlineUrlCloudMap[id];
-                    if (inlineUrlCloud && !this._cloudUploaded.has(id)) {
-                        output = (output || source).replace(new RegExp((0, types_1.escapePattern)(id), 'g'), inlineUrlCloud);
-                        localStorage.delete(this._cloudUrlMap[id]);
-                    }
-                }
-                if (output && output !== source) {
-                    try {
-                        fs.writeFileSync(item.localUri, output, item.encoding || (item.encoding = 'utf-8'));
-                        item.sourceUTF8 = output;
-                    }
-                    catch (err) {
-                        host.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(item.localUri)], err, 32 /* LOG_TYPE.FILE */);
-                    }
-                }
-            }
-        };
-        const mimeUsed = new Set();
-        for (const files of [this.cssFiles, this.jsFiles, this.svgFiles]) {
-            for (const item of files) {
-                checkDocument(item);
-                if (item.cloudStorage) {
-                    if (item.compress) {
-                        await host.compressFile(item);
-                    }
-                    const mimeType = item.mimeType;
-                    if (mimeType) {
-                        mimeUsed.add(mimeType);
-                    }
-                    tasks.push(...cloud_1.default.uploadAsset(state, item, mimeType));
-                }
-            }
-        }
-        if (tasks.length) {
-            await Promise.all(tasks);
-            if (this.aborted) {
-                return Promise.reject((0, types_1.createAbortError)());
-            }
-        }
-        if (htmlFile) {
-            checkDocument(htmlFile);
-            const cloudStorage = htmlFile.cloudStorage;
-            if ((0, types_1.isArray)(cloudStorage)) {
-                for (const storage of cloudStorage) {
-                    if (instance.hasCredential('storage', storage)) {
-                        const { service, admin, bucket, upload } = storage;
-                        const website = admin?.configBucket?.website;
-                        if ((0, types_1.isPlainObject)(website) && bucket && upload) {
-                            let filename = joinPath(upload.pathname, upload.filename || path.basename(htmlFile.localUri));
-                            if (website.indexPage === true) {
-                                website.indexPage = filename;
-                                filename = '';
-                            }
-                            if (website.errorPage === true) {
-                                website.errorPage = filename;
-                                filename = '';
-                            }
-                            if (website.indexPath === true) {
-                                website.indexPath = filename;
-                                filename = '';
-                            }
-                            if (website.errorPath === true) {
-                                website.errorPath = filename;
-                            }
-                            instance.setBucketWebsite(service, instance.getCredential(storage), bucket, website);
-                        }
-                    }
-                }
-                if (htmlFile.compress) {
-                    await host.compressFile(htmlFile);
-                }
-                return Promise.all(cloud_1.default.uploadAsset(state, htmlFile, 'text/html', true));
-            }
-        }
-        return [];
-    }
-    watchInit(watch, assets, sanitize) {
-        if (watch.captured || watch.aborted) {
-            return;
-        }
-        const main = watch.main;
-        let result;
-        if (main?.editing && main.mimeType === 'text/html') {
-            const inlineUrlCloudMap = main.inlineUrlCloudMap || {};
-            const using = [];
-            let found;
-            for (let i = 0, length = assets.length, current, upload; i < length; ++i) {
-                const asset = assets[i];
-                if (asset.element && isUnedited(asset)) {
-                    continue;
-                }
-                if (!found && (0, asset_1.isEqual)(main, asset)) {
-                    found = true;
-                    using.push(asset);
-                }
-                else if (isWatched.call(this, asset) ||
-                    (0, types_1.watchFlag)(asset.flags) ||
-                    asset.base64 && watch.related.find(item => (0, asset_1.isEqual)(item, asset)) ||
-                    (0, types_1.isArray)(asset.cloudStorage) && asset.cloudStorage.some(item => (upload = item.upload) && upload.active)) {
-                    using.push(asset);
-                }
-                else if (current = watch.assets.find(item => (0, asset_1.isEqual)(item, asset))) {
-                    const { inlineUrlCloud: inlineUrlCloud, initialValue = {} } = current;
-                    if (inlineUrlCloud && inlineUrlCloudMap[inlineUrlCloud] || path.join(initialValue.pathname || asset.pathname, initialValue.filename || asset.filename).indexOf(ChromeDocument.INTERNAL_ASSIGNUUID) !== -1) {
-                        using.push(asset);
-                    }
-                }
-            }
-            if (found) {
-                result = { using };
-            }
-        }
-        if (sanitize) {
-            ChromeDocument.sanitizeAssets(assets);
-        }
-        return result;
-    }
-    watchModified(watch, assets) {
-        return (files, errors, status) => {
-            if (!watch.server || watch.captured || watch.aborted) {
-                return;
-            }
-            const asset = watch.bundleMain || watch.assets[0];
-            const pathname = (asset.cloudUrl || asset.relativeUrl || '').split('?')[0];
-            let next, value, search;
-            if (assets && (next = assets.find(item => (0, asset_1.isEqual)(item, asset)))) {
-                if (next.cloudUrl) {
-                    value = next.cloudUrl;
-                    asset.cloudUrl = value;
-                }
-                else if (next.relativeUrl) {
-                    value = next.relativeUrl;
-                    asset.relativeUrl = value;
-                }
-                if (next.url) {
-                    search = next.url.search;
-                }
-            }
-            search ?? (search = restoreSearchParams(asset.url?.search));
-            if (status) {
-                status = status.filter(item => item.type >= types_1.STATUS_TYPE.FATAL && item.type <= types_1.STATUS_TYPE.WARN);
-            }
-            watch.send(types_1.WATCH_EVENT.MODIFIED, {
-                action: pathname && watch.hot && !watch.main ? 'hot' : '',
-                type: asset.mimeType,
-                value,
-                url: { pathname, search },
-                errors,
-                status
-            });
-        };
-    }
-    setElementSrc(file, element, value) {
-        switch (element.tagName) {
-            case 'a':
-            case 'area':
-            case 'base':
-            case 'link':
-                element.setAttribute('href', value);
-                break;
-            case 'image':
-            case 'use':
-                element.setAttribute(element.hasAttribute('xlink:href') ? 'xlink:href' : 'href', value);
-                break;
-            case 'object':
-                element.setAttribute('data', value);
-                break;
-            case 'video':
-                element.setAttribute('poster', value);
-                break;
-            case 'img':
-            case 'source':
-                if ((0, util_1.hasValue)(file.format, 'srcset')) {
-                    const srcset = element.getAttribute('srcset');
-                    if (srcset) {
-                        const htmlFile = this.htmlFile;
-                        const uri = toPosix(file.uri);
-                        const items = new Set([uri]);
-                        const baseHref = getBaseURLs(htmlFile, this.baseUrl);
-                        const sameOrigin = hasSameOrigin(file.url || uri, ...baseHref);
-                        if (sameOrigin) {
-                            const src = element.getAttribute('src');
-                            for (const baseUri of baseHref) {
-                                let url;
-                                if (src && uri === resolvePath(url = toPosix(src), baseUri)) {
-                                    items.add(url);
-                                }
-                                items.add(uri.startsWith(this.baseDirectory) ? uri.substring(this.baseDirectory.length) : uri.replace(baseUri.origin, ''));
-                            }
-                        }
-                        let current = srcset, match;
-                        for (const url of items) {
-                            const resolve = sameOrigin && !index_1.default.isURL(url);
-                            const pathname = url.split(/[\\/]/).map(seg => (0, types_1.escapePattern)(seg)).join('[\\\\/]');
-                            const pattern = new RegExp(`(,?\\s*)(${(resolve && url[0] !== '.' ? `(?:\\.\\.[\\\\/])*\\.\\.${pathname}|` : '') + pathname})(` + (url.indexOf('?') === -1 ? '(?:(?!,)(?:[^?]|$)[^,]*)|(?!\\?)[^,]*)' : '[^,]*)'), 'g');
-                            while (match = pattern.exec(current)) {
-                                const partial = match[2];
-                                if (!resolve || baseHref.some(baseUri => uri === resolvePath(partial, baseUri))) {
-                                    current = replaceMatch(match, current, match[1] + value + match[3], pattern);
-                                }
-                            }
-                        }
-                        element.setAttribute('srcset', current);
-                    }
-                    break;
-                }
-            default:
-                element.setAttribute('src', value);
-                break;
-        }
-    }
-    findDataValue(name) {
-        if (this.hasEval('template')) {
-            return this.templateMap.data?.[name];
-        }
-    }
-    setInlinedAttributes({ host, startTime, hashed, contentMap, bufferMap, productionRelease }) {
-        const readBase64 = (item, uuid) => {
-            if (!contentMap[uuid]) {
-                try {
-                    contentMap[uuid] = `data:${item.mimeType};base64,${(item.buffer ? item.buffer.toString('base64') : fs.readFileSync(item.localUri, 'base64')).trim()}`;
-                    host.removeAsset(item);
-                }
-                catch (err) {
-                    this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, item.filename], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
-                    return false;
-                }
-            }
-            return true;
-        };
-        for (const item of this.assets) {
-            if (item.inlineBase64) {
-                readBase64(item, item.inlineBase64);
-            }
-            else if (!item.invalid && (0, util_1.hasValue)(item.format, 'base64')) {
-                const uuid = (0, types_1.generateUUID)();
-                if (readBase64(item, uuid)) {
-                    item.inlineBase64 = uuid;
-                }
-            }
-            if (productionRelease) {
-                const { imported, inlineUrl: inlineUrl, inlineUrlCloud: inlineUrlCloud } = item;
-                if (inlineUrl || inlineUrlCloud) {
-                    const filename = createHash(host, item, bufferMap);
-                    if (filename) {
-                        for (const hash of this.assets) {
-                            const url = inlineUrl ? hash.inlineUrlMap?.[inlineUrl] : hash.inlineUrlCloudMap?.[inlineUrlCloud];
-                            if (url) {
-                                const search = url.indexOf('?');
-                                const index = (search !== -1 ? url.substring(0, search) : url).lastIndexOf('/');
-                                let result = '';
-                                if (index !== -1) {
-                                    result = url.substring(0, index + 1);
-                                }
-                                result += filename;
-                                if (search !== -1) {
-                                    result += url.substring(search);
-                                }
-                                if (inlineUrl) {
-                                    hash.inlineUrlMap[inlineUrl] = result;
-                                }
-                                else {
-                                    hash.inlineUrlCloudMap[inlineUrlCloud] = result;
-                                }
-                            }
-                        }
-                    }
-                    hashed.add(item);
-                }
-                else if ((!item.editing || imported) && createHash(host, item, bufferMap)) {
-                    hashed.add(item);
-                }
-            }
-        }
-    }
-    async applyTransforms(processing) {
-        const { host, hashed, bufferMap, productionRelease } = processing;
-        const sanitizeSource = (item, source) => {
-            if (productionRelease) {
-                replaceCss.call(this, item);
-            }
-            const output = replaceHtml.call(this, source, processing, item.inlineUrlMap);
-            if (source !== output) {
-                item.modified = true;
-                return output;
-            }
-            return source;
-        };
-        const transforms = [];
-        const tasks = [];
-        for (const item of this.svgFiles) {
-            if (isIgnored(item)) {
-                continue;
-            }
-            let source = host.getUTF8String(item);
-            const output = transformURL.call(this, host, item, 'svg', source);
-            if (output) {
-                source = output;
-                item.modified = true;
-            }
-            source = sanitizeSource(item, source);
-            if (item.format) {
-                const result = await this.transform('html', source, item.format, transformOptions.call(this, item, 'image/svg+xml'));
-                if (result) {
-                    item.modified = true;
-                    source = result.code;
-                }
-            }
-            item.sourceUTF8 = source;
-            if (productionRelease && !hashed.has(item) && createHash(host, item, bufferMap)) {
-                hashed.add(item);
-            }
-        }
-        for (const item of this.cssFiles) {
-            if (isIgnored(item)) {
-                continue;
-            }
-            let source = host.getUTF8String(item), output;
-            if (!(item.bundleIndex >= 0)) {
-                source = host.setAssetContent(item, source);
-            }
-            if ((output = host.getAssetContent(item, source)) && output !== source) {
-                source = output;
-                item.modified = true;
-            }
-            if (!item.preserve && (output = this.removeUnusedStyles(source))) {
-                source = output;
-                item.modified = true;
-            }
-            if (output = transformURL.call(this, host, item, 'css', source)) {
-                source = output;
-                item.modified = true;
-            }
-            source = sanitizeSource(item, source);
-            item.sourceUTF8 = source;
-            if (item.format) {
-                transforms.push(item);
-                tasks.push(this.transform('css', source, item.format, transformOptions.call(this, item, 'text/css', source, host.contentToAppend.get(item.localUri))));
-            }
-        }
-        for (const item of this.jsFiles) {
-            if (isIgnored(item)) {
-                continue;
-            }
-            const { bundleIndex = -1, format } = item;
-            let source = host.getUTF8String(item), output;
-            if (!(bundleIndex >= 0)) {
-                source = host.setAssetContent(item, source);
-            }
-            if ((output = host.getAssetContent(item, source)) && output !== source) {
-                source = output;
-                item.modified = true;
-            }
-            if (output = transformURL.call(this, host, item, 'js', source)) {
-                source = output;
-                item.modified = true;
-            }
-            source = sanitizeSource(item, source);
-            item.sourceUTF8 = source;
-            if (format) {
-                transforms.push(item);
-                tasks.push(this.transform('js', source, format, transformOptions.call(this, item, 'application/javascript', source, host.contentToAppend.get(item.localUri))));
-            }
-        }
-        return Promise.allSettled(tasks).then(items => {
-            for (let i = 0, length = items.length, value; i < length; ++i) {
-                const item = items[i];
-                if (item.status === 'fulfilled' && (value = item.value)) {
-                    const target = transforms[i];
-                    if (value.type === 'css') {
-                        if (value.map && !target.bundleReplace) {
-                            const output = writeSourceMap(target.localUri, value, { mimeType: 'text/css', hash: productionRelease ? target.hash : undefined, emptySources: productionRelease, inlineMap: hasSourceMap(target.metadata, 'inline') });
-                            if (output) {
-                                host.add(output, target, types_1.FILE_TYPE.SOURCEMAP);
-                            }
-                        }
-                        target.modified = true;
-                        target.sourceUTF8 = value.code;
-                    }
-                    else {
-                        transformJs.call(this, host, target, value);
-                    }
-                }
-            }
-        });
-    }
-    async rewriteHtml(processing) {
-        const { host, startTime, cacheMiss, productionRelease } = processing;
-        const { moduleName, config } = this;
-        const htmlFile = this.htmlFile;
-        const localUri = htmlFile.localUri;
-        this.formatMessage(4 /* LOG_TYPE.PROCESS */, 'HTML', ['Rewriting content...', path.dirname(localUri)]);
-        let source = host.getUTF8String(htmlFile, localUri), output;
-        const domBase = new dom_1.DomWriter(moduleName, source, this.elements, { normalize: config.normalizeHtmlOutput, stripComments: config.stripCommentsAndCDATA, ignoreTagGroup: config.ignoreServerCodeBlocks, escapeEntities: config.escapeReservedCharacters });
-        if (config.useUnsafeHtmlReplace) {
-            domBase.ignoreFlag(dom_1.IGNORE_FLAG.INTERIOR);
-        }
-        if (this.watching) {
-            domBase.ignoreFlag(dom_1.IGNORE_FLAG.LOCATOR);
-        }
-        if ((0, types_1.isString)(config.useOriginalHtmlPage)) {
-            domBase.ignoreTag(config.useOriginalHtmlPage);
-        }
-        if ((0, types_1.isArray)(config.ignoreServerCodeBlocks)) {
-            domBase.ignoreTag(config.ignoreServerCodeBlocks);
-        }
-        if (productionRelease) {
-            replaceCss.call(this, htmlFile);
-        }
-        await this.setElementAttributes(processing, domBase);
-        await this.applyDataSource(processing, domBase);
-        for (const item of this.assets) {
-            if (item.element && isRemoved(item) && !(0, types_1.ignoreFlag)(item.flags)) {
-                const domElement = new dom_1.HtmlElement(moduleName, item.element, item.attributes);
-                domElement.remove = true;
-                if (!domBase.write(domElement)) {
-                    this.writeFail('Unable to exclude HTML element', errorHtml(item.element), 4 /* LOG_TYPE.PROCESS */);
-                }
-            }
-        }
-        source = removeNamespace(moduleName, domBase.modified ? domBase.close() : source, domBase.newline, domBase.getComments());
-        if (!htmlFile.preserve) {
-            let match;
-            while (match = REGEXP_STYLE.exec(source)) {
-                if (output = this.removeUnusedStyles(match[5])) {
-                    source = replaceMatch(match, source, match[1] + output + match[6], REGEXP_STYLE);
-                }
-            }
-            REGEXP_STYLE.lastIndex = 0;
-        }
-        if (output = transformURL.call(this, host, htmlFile, 'html', source)) {
-            source = output;
-        }
-        source = replaceHtml.call(this, source, processing, htmlFile.inlineUrlMap);
-        if ((0, types_1.isString)(config.stripCommentsAndCDATA)) {
-            source = dom_1.DomWriter.getCommentsAndCDATA(source, config.stripCommentsAndCDATA, true, true);
-        }
-        if (htmlFile.format) {
-            const result = await this.transform('html', source, htmlFile.format, {
-                pathname: path.dirname(localUri),
-                filename: htmlFile.filename,
-                mimeType: 'text/html',
-                metadata: Object.assign({ '__fromhtml__': true, ...this.config }, htmlFile.metadata),
-                cacheData: !productionRelease || this.productionIncremental ? { uri: htmlFile.uri, encoding: htmlFile.encoding } : undefined
-            });
-            if (result) {
-                source = result.code;
-            }
-        }
-        if (domBase.hasErrors()) {
-            const timeStamp = Date.now();
-            domBase.errors.forEach(err => this.addLog(types_1.STATUS_TYPE.WARN, 'dom-writer -> ' + err.message, timeStamp));
-        }
-        if (domBase.failCount > 0) {
-            this.writeFail(['Unable to update document', moduleName], (0, types_1.errorMessage)('html', 'DOM rewrite failed', domBase.failCount + ' errors'), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-        }
-        else {
-            this.writeTimeProcess('html', `dom-writer (${domBase.modifyCount} modified) -> ` + path.basename(localUri), startTime);
-            if (cacheMiss.length) {
-                const data = {};
-                const message = [];
-                cacheMiss.forEach(name => data[name] = (data[name] || 0) + 1);
-                for (const name in data) {
-                    message.push(name + `(${data[name]})`);
-                }
-                this.formatMessage(65536 /* LOG_TYPE.DB */, 'DB', ['Cache statistics', cacheMiss.length + ' missed'], message.join(' - '), { ...index_1.default.LOG_STYLE_NOTICE, hintBold: true });
-            }
-        }
-        htmlFile.modified = true;
-        htmlFile.sourceUTF8 = source;
-    }
-    async setElementAttributes({ host, startTime, productionRelease }, domBase) {
-        var _a;
-        const { moduleName, htmlFile } = this;
-        const cloud = host.Cloud;
-        const removeWatchReload = (item) => (0, types_1.isObject)(item.watch) && delete item.watch.reload;
-        for (const item of this.assets) {
-            const element = item.element;
-            if (!element || element.removed || isRemoved(item) || isUnedited(item) || (0, types_1.ignoreFlag)(item.flags) && !(0, types_1.processFlag)(item.flags)) {
-                continue;
-            }
-            const domElement = new dom_1.HtmlElement(moduleName, element, item.attributes);
-            if (item.inlineContent) {
-                let [innerXml, sourceMappingURL, inlineMap] = transform_1.SourceMap.removeSourceMappingURL(host.getUTF8String(item).trim());
-                if (sourceMappingURL && !inlineMap && item.localUri) {
-                    let mapUri = path.resolve(sourceMappingURL = decodeURIComponent(sourceMappingURL));
-                    if (!isPath(mapUri)) {
-                        mapUri = path.join(path.dirname(item.localUri), sourceMappingURL);
-                    }
-                    host.deleteFile(mapUri);
-                }
-                domElement.tagName = item.inlineContent;
-                domElement.innerXml = innerXml;
-                domElement.removeAttribute('src', 'href');
-            }
-            else {
-                let uri = item.relativeUrl;
-                if ((0, util_1.hasValue)(item.format, 'base64')) {
-                    if (item.invalid) {
-                        continue;
-                    }
-                    if (item.inlineBase64) {
-                        this.setElementSrc(item, domElement, item.inlineBase64);
-                        removeWatchReload(item);
-                        uri = '';
-                    }
-                }
-                if (uri && !(0, util_1.hasValue)(item.format, 'crossorigin') && item !== htmlFile) {
-                    if (cloud?.getStorage('upload', item.cloudStorage)) {
-                        const inlineUrlCloud = item.inlineUrlCloud || (item.inlineUrlCloud = (0, types_1.generateUUID)());
-                        ((_a = htmlFile).inlineUrlCloudMap || (_a.inlineUrlCloudMap = {}))[inlineUrlCloud] = productionRelease ? this.removeServerRoot(uri) : uri;
-                        uri = inlineUrlCloud;
-                    }
-                    if (!(0, util_1.hasValue)(item.format, 'webbundle')) {
-                        const { bundleIndex, srcSet } = item;
-                        if (bundleIndex === 0 || bundleIndex === -1) {
-                            switch (element.tagName) {
-                                case 'style':
-                                    domElement.tagName = 'link';
-                                case 'link':
-                                    domElement.setAttribute('rel', 'stylesheet');
-                                    break;
-                            }
-                            domElement.innerXml = '';
-                        }
-                        this.setElementSrc(item, domElement, uri);
-                        if (srcSet) {
-                            const length = srcSet.length;
-                            let src = domElement.getAttribute('srcset'), i = 0;
-                            while (i < length) {
-                                src += (src ? ', ' : '') + srcSet[i++] + ' ' + srcSet[i++];
-                            }
-                            domElement.setAttribute('srcset', src);
-                        }
-                    }
-                }
-                const detectWidth = domElement.getAttribute('width') === 'detect';
-                const detectHeight = domElement.getAttribute('height') === 'detect';
-                if (detectWidth || detectHeight) {
-                    let width = 0, height = 0, buffer = null;
-                    if (isImage(item.mimeType) && (buffer = host.getBuffer(item))) {
-                        let dimensions;
-                        try {
-                            dimensions = require('probe-image-size').sync(buffer);
-                        }
-                        catch {
-                        }
-                        if (dimensions) {
-                            ({ width, height } = dimensions);
-                        }
-                        else {
-                            try {
-                                ({ width, height } = (await require('jimp').read(buffer)).bitmap);
-                            }
-                            catch {
-                                const filename = item.localUri || item.filename;
-                                if (filename) {
-                                    this.addLog(types_1.STATUS_TYPE.WARN, `Could not detect image size (${path.basename(filename)})`);
-                                }
-                            }
-                        }
-                    }
-                    if (detectWidth) {
-                        if (width > 0) {
-                            domElement.setAttribute('width', width.toString());
-                        }
-                        else {
-                            domElement.removeAttribute('width');
-                        }
-                    }
-                    if (detectHeight) {
-                        if (height > 0) {
-                            domElement.setAttribute('height', height.toString());
-                        }
-                        else {
-                            domElement.removeAttribute('height');
-                        }
-                    }
-                }
-            }
-            if (!domBase.write(domElement)) {
-                this.writeFail(item.inlineContent ? 'Inline tag replacement' : 'Element attribute replacement', errorHtml(element), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-                delete item.inlineUrlCloud;
-            }
-            else if (item.inlineContent) {
-                host.removeAsset(item);
-                removeWatchReload(item);
-            }
-        }
-    }
-    async applyDataSource({ host, startTime, cacheMiss }, domBase) {
-        if (this.dataSource.length === 0) {
-            return;
-        }
-        const { moduleName, Db: db } = this;
-        const cloud = host.Cloud;
-        const sessionKey = (0, types_1.generateUUID)();
-        const cacheData = Object.create(null);
-        const dataItems = [];
-        const displayItems = [];
-        this.dataSource.forEach(item => item.type === 'display' ? displayItems.push(item) : dataItems.push(item));
-        const removeElement = (item, element) => {
-            if (item.removeEmpty || item.type === 'display') {
-                (element || (element = new dom_1.HtmlElement(moduleName, item.element))).remove = true;
-                if (!domBase.write(element)) {
-                    this.writeFail('Unable to remove element', errorHtml(item.element), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-                }
-            }
-        };
-        const errorCredential = (item, err) => {
-            removeElement(item);
-            const pkg = getPackageName(err, item.source);
-            if (!(pkg && this.checkPackage(err, pkg))) {
-                this.writeFail(["Invalid credentials" /* ERR_DB.CREDENTIALS */, item.source], err);
-            }
-        };
-        const checkObject = (item, data) => {
-            const { query, cascade } = item;
-            if ((0, types_1.isString)(cascade)) {
-                const result = data && (0, types_1.cascadeObject)(data, cascade, data);
-                if (result !== data) {
-                    data = result;
-                }
-                else if (item.fallback !== undefined) {
-                    data = item.fallback;
-                }
-                else if (!(0, types_1.isString)(query)) {
-                    return null;
-                }
-            }
-            if (data) {
-                if ((0, types_1.isString)(query) && item.source !== 'mongodb') {
-                    const pkg = query[0] === '$' ? 'jsonpath' : 'jmespath';
-                    try {
-                        if (pkg === 'jsonpath') {
-                            data = require(pkg).query(data, query);
-                        }
-                        else {
-                            data = require(pkg).search(data, query);
-                        }
-                    }
-                    catch (err) {
-                        this.abort(item.source);
-                        this.checkPackage(err, pkg, ["Unable to filter results" /* ERR_DB.FILTER_QUERY */, item.source]);
-                    }
-                }
-            }
-            return Array.isArray(data) ? data : (0, types_1.isObject)(data) ? [data] : null;
-        };
-        const setElements = async (sourceSet) => {
-            const batchMap = Object.create(null);
-            const batchGroup = [];
-            for (const item of sourceSet) {
-                if (!item.element) {
-                    this.addLog(types_1.STATUS_TYPE.WARN, `Missing target element {${JSON.stringify(item)}}`);
-                    continue;
-                }
-                const type = item.source;
-                switch (type) {
-                    case 'cloud': {
-                        const { service, credential } = item;
-                        if (cloud) {
-                            const key = service + '_' + (service === 'atlas' && item.uri || '') + '_' + asString(credential, true);
-                            (batchMap[key] || (batchMap[key] = [])).push(item);
-                        }
-                        else {
-                            errorCredential(item, (0, types_1.errorValue)("Cloud module not installed" /* ERR_CLOUD.MODULE_NOTFOUND */, service));
-                        }
-                        break;
-                    }
-                    case 'uri':
-                    case 'local':
-                    case 'export':
-                        batchGroup.push([item]);
-                        break;
-                    default:
-                        if (db?.hasSource(type)) {
-                            try {
-                                await db.setCredential(item);
-                                const credential = item.credential;
-                                let key;
-                                switch (type) {
-                                    case 'mongodb':
-                                        key = core_1.ClientDb.keyOfResult(item.uri || type, credential);
-                                        break;
-                                    case 'redis':
-                                        key = credential && (key = core_1.ClientDb.keyOfResult(type, credential, true)) ? key : JSON.stringify(item.options.client);
-                                        break;
-                                    default:
-                                        key = core_1.ClientDb.keyOfResult(type, credential);
-                                        break;
-                                }
-                                (batchMap[key] || (batchMap[key] = [])).push(item);
-                            }
-                            catch (err) {
-                                errorCredential(item, err);
-                            }
-                        }
-                        else {
-                            errorCredential(item, (0, types_1.errorValue)(db ? "Database provider not found" /* ERR_DB.PROVIDER_NOTFOUND */ : "Db module not installed" /* ERR_DB.MODULE_NOTFOUND */, type));
-                        }
-                        break;
-                }
-            }
-            for (const key in batchMap) {
-                batchGroup.push(batchMap[key]);
-            }
-            return this.allSettled(batchGroup.map(batch => {
-                return new Promise(async (resolve, reject) => {
-                    const errorRemove = (item, reason) => {
-                        removeElement(item);
-                        reject(reason);
-                    };
-                    const errorClient = (item, reason) => {
-                        removeElement(item);
-                        if (reason) {
-                            this.writeFail(["Unable to configure client" /* ERR_DB.CLIENT */, item.source], reason);
-                        }
-                        reject();
-                    };
-                    const length = batch.length;
-                    const current = batch[0];
-                    const type = current.source;
-                    let result = new Array(length);
-                    switch (type) {
-                        case 'cloud':
-                            result = await cloud.getDatabaseBatchRows(batch, true, sessionKey).catch(err => {
-                                this.abort(type);
-                                if (err instanceof Error) {
-                                    cloud.addLog(this.aborted ? types_1.STATUS_TYPE.ERROR : types_1.STATUS_TYPE.WARN, err);
-                                }
-                                return [];
-                            });
-                            break;
-                        case 'uri':
-                        case 'local': {
-                            const { ignoreCache, encoding = 'utf-8', options } = current;
-                            let content, target, data, cacheKey;
-                            const addDownload = () => typeof content === 'string' && host.addDownload(Buffer.byteLength(content, encoding));
-                            if (type === 'local') {
-                                let location;
-                                ({ pathname: target } = current);
-                                if (target && ((location = this.resolveDir('data', target)) || host.canRead(location = path.resolve(target), { ownPermissionOnly: true }))) {
-                                    if (!ignoreCache && CACHE_DBRESULT.has(location)) {
-                                        data = getCacheItem(CACHE_DBRESULT, location);
-                                    }
-                                    else {
-                                        if (ignoreCache === 1) {
-                                            CACHE_DBRESULT.delete(location);
-                                        }
-                                        if (!(data = cacheData[location])) {
-                                            try {
-                                                content = fs.readFileSync(location, encoding);
-                                                cacheKey = location;
-                                                addDownload();
-                                            }
-                                            catch (err) {
-                                                this.abort(type);
-                                                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(location)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
-                                                errorRemove(current);
-                                                return;
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    this.abort(type);
-                                    errorRemove(current, target ? errorDataSource('Not found', target) : errorDataSource('Not defined - ' + (this.settings.directory?.data ? 'file' : 'directory'), type));
-                                    return;
-                                }
-                            }
-                            else if (!(0, types_1.isString)(target = current.uri)) {
-                                this.abort(type);
-                                errorRemove(current, errorDataSource('Not defined', type));
-                                return;
-                            }
-                            else if (index_1.default.isURL(target, 'file')) {
-                                if (!ignoreCache && CACHE_DBRESULT.has(target)) {
-                                    data = getCacheItem(CACHE_DBRESULT, target);
-                                }
-                                else {
-                                    if (ignoreCache === 1) {
-                                        CACHE_DBRESULT.delete(target);
-                                    }
-                                    if (!(data = cacheData[target])) {
-                                        try {
-                                            content = await host.fetchBuffer(target, { encoding });
-                                            if (Buffer.isBuffer(content)) {
-                                                content = content.toString('utf-8');
-                                            }
-                                            cacheKey = target;
-                                        }
-                                        catch (err) {
-                                            this.abort(type);
-                                            this.writeFail(["Unable to download file" /* ERR_MESSAGE.DOWNLOAD_FILE */, target], err, { type: 1024 /* LOG_TYPE.HTTP */, startTime });
-                                            errorRemove(current);
-                                            return;
-                                        }
-                                    }
-                                }
-                            }
-                            else {
-                                const pathname = index_1.default.resolveFile(target);
-                                if (!ignoreCache && CACHE_DBRESULT.has(pathname)) {
-                                    data = getCacheItem(CACHE_DBRESULT, pathname);
-                                }
-                                else {
-                                    if (ignoreCache === 1) {
-                                        CACHE_DBRESULT.delete(pathname);
-                                    }
-                                    if (!(data = cacheData[pathname])) {
-                                        if (!host.canRead(pathname, { ownPermissionOnly: true })) {
-                                            this.abort(type);
-                                            errorRemove(current, errorDataSource('Access denied', pathname));
-                                            return;
-                                        }
-                                        try {
-                                            content = fs.readFileSync(pathname, encoding);
-                                            cacheKey = pathname;
-                                            addDownload();
-                                        }
-                                        catch (err) {
-                                            this.abort(type);
-                                            this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(pathname)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
-                                            errorRemove(current);
-                                            return;
-                                        }
-                                    }
-                                }
-                            }
-                            if ((0, types_1.isString)(content)) {
-                                const { format = path.extname(target).substring(1) } = current;
-                                try {
-                                    data = this.tryParse(content, format, options);
-                                }
-                                catch (err) {
-                                    this.abort(type);
-                                    this.writeFail(['Unable to parse data source', format], err, { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-                                    errorRemove(current);
-                                    return;
-                                }
-                                if (data && cacheKey) {
-                                    setCacheData.call(this, current, data, cacheKey, cacheData);
-                                }
-                            }
-                            if (!data) {
-                                this.abort(type);
-                                errorRemove(current, errorDataSource(content !== null ? 'Invalid response' : 'Empty response', target));
-                                return;
-                            }
-                            if ((result[0] = checkObject(current, data)) === null) {
-                                this.abort(type);
-                                errorRemove(current, errorDataSource('Invalid ' + (current.query ? 'query' : 'URI'), target));
-                                return;
-                            }
-                            if (this.settingsOf(type, 'coerce') === true) {
-                                (0, types_1.coerceObject)(result[0]);
-                            }
-                            break;
-                        }
-                        case 'export': {
-                            const ignoreCache = current.ignoreCache;
-                            const cacheKey = asString(current, true);
-                            if (!current.ignoreCache && CACHE_DBRESULT.has(cacheKey)) {
-                                result[0] = getCacheItem(CACHE_DBRESULT, cacheKey);
-                            }
-                            else {
-                                if (ignoreCache === 1) {
-                                    CACHE_DBRESULT.delete(cacheKey);
-                                }
-                                if (cacheKey in cacheData) {
-                                    result[0] = cacheData[cacheKey];
-                                }
-                                else {
-                                    let { pathname, execute, params } = current, data, target, getData, hint;
-                                    if (typeof execute === 'function') {
-                                        target = execute;
-                                    }
-                                    else if (typeof pathname === 'function') {
-                                        target = pathname;
-                                    }
-                                    else if ((0, types_1.isString)(pathname)) {
-                                        if ((pathname = pathname.trim()).startsWith('npm:')) {
-                                            target = pathname;
-                                            hint = pathname;
-                                        }
-                                        else if ((target = this.resolveDir(type, pathname)) && (getData = core_1.ClientDb.parseFunction(target, true))) {
-                                            hint = pathname;
-                                        }
-                                        else {
-                                            target = undefined;
-                                        }
-                                    }
-                                    if (!getData) {
-                                        const { settings, encoding, persist = true } = current;
-                                        if (!target) {
-                                            target = settings && this.settings.export?.[settings] || pathname;
-                                        }
-                                        if (typeof target === 'function') {
-                                            getData = target;
-                                            hint = target.name;
-                                        }
-                                        else if ((0, types_1.isString)(target)) {
-                                            getData = this.asSourceFile(target, { encoding, persist });
-                                            hint = target;
-                                        }
-                                    }
-                                    if (typeof getData !== 'function') {
-                                        errorRemove(current, target ? errorDataSource('Not a function', hint) : errorDataSource('Not defined - pathname | settings', type));
-                                        return;
-                                    }
-                                    try {
-                                        if (params && this.settingsOf(type, 'coerce') === true) {
-                                            (0, types_1.coerceObject)(params);
-                                        }
-                                        // @ts-ignore
-                                        if (getData["__cjs__" /* INTERNAL.CJS */]) {
-                                            data = await getData(params);
-                                        }
-                                        else {
-                                            const thisArg = index_1.default.enabled("node.process.inline" /* KEY_NAME.NODE_PROCESS_INLINE */) ? process : null;
-                                            const inline = index_1.default.enabled("node.require.inline" /* KEY_NAME.NODE_REQUIRE_INLINE */);
-                                            const args = [params];
-                                            if (getData.toString().startsWith('async')) {
-                                                if (inline) {
-                                                    args.push(require);
-                                                }
-                                                data = await getData.apply(thisArg, args);
-                                            }
-                                            else {
-                                                data = await new Promise(success => {
-                                                    args.push(success);
-                                                    if (inline) {
-                                                        args.push(require);
-                                                    }
-                                                    getData.apply(thisArg, args);
-                                                });
-                                            }
-                                        }
-                                        setCacheData.call(this, current, data, cacheKey, cacheData);
-                                    }
-                                    catch (err) {
-                                        this.abort(type);
-                                        this.writeFail(['Unable to retrieve data source', hint], err, { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-                                        errorRemove(current);
-                                        return;
-                                    }
-                                    if ((result[0] = checkObject(current, data)) === null) {
-                                        this.abort(type);
-                                        errorRemove(current, errorDataSource('Invalid ' + (current.query ? 'query' : 'params'), hint));
-                                        return;
-                                    }
-                                }
-                            }
-                            break;
-                        }
-                        default:
-                            if (db?.hasSource(type)) {
-                                switch (type) {
-                                    case 'mongodb':
-                                        for (let j = 0; j < length; ++j) {
-                                            const cmd = batch[j];
-                                            cmd.cacheObjectKey = typeof cmd.cascade === 'string' ? cmd.cascade : '';
-                                        }
-                                        break;
-                                    case 'redis':
-                                        for (let j = 0; j < length; ++j) {
-                                            const cmd = batch[j];
-                                            const { search, key, query, cascade } = cmd;
-                                            if ((0, types_1.isObject)(search) && typeof search.schema === 'string') {
-                                                const pathname = this.resolveDir('schema', search.schema);
-                                                if (pathname) {
-                                                    const ignoreCache = cmd.ignoreCache;
-                                                    if (!ignoreCache && CACHE_LOCALFILE.has(pathname)) {
-                                                        search.schema = getCacheItem(CACHE_LOCALFILE, pathname);
-                                                    }
-                                                    else {
-                                                        if (ignoreCache === 1) {
-                                                            CACHE_LOCALFILE.delete(pathname);
-                                                        }
-                                                        if (!(search.schema = cacheData[pathname])) {
-                                                            try {
-                                                                search.schema = loadLocalFile.call(this, current, pathname, cacheData, cmd.encoding);
-                                                            }
-                                                            catch (err) {
-                                                                this.writeFail(['Unable to parse document', path.basename(pathname)], err, { startTime });
-                                                                search.schema = undefined;
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                else {
-                                                    search.schema = undefined;
-                                                }
-                                            }
-                                            if (key) {
-                                                cmd.cacheObjectKey = ((0, types_1.isString)(cascade) ? cascade : '') + '_' + ((0, types_1.isString)(query) ? query : '');
-                                            }
-                                        }
-                                        break;
-                                    default:
-                                        if (db.hasSource(type, db.sourceType.SQL)) {
-                                            for (let j = 0; j < length; ++j) {
-                                                const cmd = batch[j];
-                                                const query = cmd.query;
-                                                if (typeof query === 'string' && query.endsWith('.sql')) {
-                                                    const pathname = this.resolveDir('sql', query);
-                                                    try {
-                                                        if (pathname) {
-                                                            const ignoreCache = cmd.ignoreCache;
-                                                            if (!ignoreCache && CACHE_LOCALFILE.has(pathname)) {
-                                                                cmd.query = getCacheItem(CACHE_LOCALFILE, pathname);
-                                                            }
-                                                            else {
-                                                                if (ignoreCache === 1) {
-                                                                    CACHE_LOCALFILE.delete(pathname);
-                                                                }
-                                                                if (!(cmd.query = cacheData[pathname])) {
-                                                                    const out = { content: '' };
-                                                                    try {
-                                                                        cmd.query = loadLocalFile.call(this, current, pathname, cacheData, cmd.encoding, out);
-                                                                    }
-                                                                    catch {
-                                                                        setCacheData.call(this, current, cmd.query = out.content, pathname, cacheData, true);
-                                                                    }
-                                                                }
-                                                            }
-                                                        }
-                                                        else {
-                                                            throw (0, types_1.errorMessage)(type, "File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, query);
-                                                        }
-                                                    }
-                                                    catch (err) {
-                                                        this.abort(type);
-                                                        this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, pathname ? path.basename(pathname) : query], err, { startTime });
-                                                        errorRemove(current);
-                                                        return;
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        break;
-                                }
-                                try {
-                                    let coerce, cache;
-                                    if (type === 'mongodb' || type === 'redis') {
-                                        coerce = this.settingsOf(type, 'coerce');
-                                        cache = this.settingsOf(type, 'cache');
-                                    }
-                                    const errorQuery = (err, data, commandType) => {
-                                        let message, aborting = true;
-                                        if (db.hasSource(type, db.sourceType.DOCUMENT)) {
-                                            message = (data.name ? data.name + ': ' : '') + (data.table || '');
-                                        }
-                                        else if (db.hasSource(type, db.sourceType.KEYVALUE)) {
-                                            aborting = commandType !== db.commandType.UPDATE;
-                                            message = asString(data.search || data.key);
-                                        }
-                                        else {
-                                            const credential = data.credential;
-                                            if ((0, types_1.isPlainObject)(credential)) {
-                                                message = credential.database;
-                                            }
-                                        }
-                                        if (data.willAbort) {
-                                            this.abort();
-                                        }
-                                        else if (aborting) {
-                                            this.abort(type);
-                                        }
-                                        if (err) {
-                                            this.writeFail(["Unable to execute query" /* ERR_DB.EXEC_QUERY */, message || "Unknown" /* ERR_MESSAGE.UNKNOWN */], err, { type: 65536 /* LOG_TYPE.DB */, startTime });
-                                        }
-                                        return this.aborted;
-                                    };
-                                    const options = { coerce, cache, checkObject, sessionKey, connectOnce: length > 1, outCacheMiss: cacheMiss, errorQuery };
-                                    result = await db.executeBatchQuery(batch, options, result);
-                                }
-                                catch (err) {
-                                    this.abort(type);
-                                    const pkg = getPackageName(err, type);
-                                    errorClient(current, pkg && this.checkPackage(err, pkg) ? null : err);
-                                }
-                                break;
-                            }
-                            errorRemove(current, errorDataSource('Not found', type || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
-                            return;
-                    }
-                    if (this.aborted) {
-                        resolve();
-                        return;
-                    }
-                    for (let i = 0, items; i < length; ++i) {
-                        const item = batch[i];
-                        const { index, limit, ignoreEmpty, postQuery, whenEmpty } = item;
-                        const empty = (items = result[i]) === null;
-                        if ((items || (items = [])).length === 0) {
-                            if (whenEmpty) {
-                                const data = await checkData.call(this, item, whenEmpty, items, row => Array.isArray(row));
-                                if (data) {
-                                    items = data;
-                                    item.transactionFail = false;
-                                }
-                            }
-                            if (ignoreEmpty && items.length === 0) {
-                                continue;
-                            }
-                        }
-                        if (index !== undefined) {
-                            const data = items[index];
-                            items = data ? [data] : [];
-                        }
-                        else if (limit !== undefined && limit > 0 && items.length > limit) {
-                            items = items.slice(0, limit);
-                        }
-                        if (postQuery) {
-                            const data = await checkData.call(this, item, postQuery, items = items.slice(0), row => Array.isArray(row));
-                            if (data) {
-                                items = data;
-                            }
-                        }
-                        if (items.length && !item.transactionFail) {
-                            const { element, preRender } = item;
-                            const domElement = new dom_1.HtmlElement(moduleName, element);
-                            let errors, value = '';
-                            const checkValue = async (name) => {
-                                const data = await checkData.call(this, item, name, value, row => typeof row === 'string');
-                                if (data) {
-                                    value = data;
-                                }
-                            };
-                            const valueAsString = (data, joinString) => Array.isArray(data) && !data.some(child => typeof child === 'object') ? data.join(joinString) : asString(data);
-                            if (item.template) {
-                                const pathname = this.resolveDir('template', item.template);
-                                if (pathname) {
-                                    const ignoreCache = item.ignoreCache;
-                                    if (!ignoreCache && CACHE_LOCALFILE.has(pathname)) {
-                                        item.value = getCacheItem(CACHE_LOCALFILE, pathname);
-                                    }
-                                    else {
-                                        if (ignoreCache === 1) {
-                                            CACHE_LOCALFILE.delete(pathname);
-                                        }
-                                        if (!(item.value = cacheData[pathname])) {
-                                            try {
-                                                item.value = fs.readFileSync(pathname, item.encoding || 'utf-8');
-                                                setCacheData.call(this, item, item.value, pathname, cacheData, true);
-                                            }
-                                            catch (err) {
-                                                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(pathname)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
-                                                errors = true;
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    errors = true;
-                                }
-                            }
-                            invalid: {
-                                switch (item.type) {
-                                    case 'text': {
-                                        const template = item.value || item.dynamic && element.innerXml || element.textContent || domElement.innerXml;
-                                        if (typeof template === 'string' && !domElement.tagVoid) {
-                                            if (item.viewEngine) {
-                                                const content = await this.parseTemplate(item.viewEngine, template, items);
-                                                if (content === null) {
-                                                    ++domBase.failCount;
-                                                    removeElement(item, domElement);
-                                                    if (length === 1) {
-                                                        resolve();
-                                                        return;
-                                                    }
-                                                    break invalid;
-                                                }
-                                                value = content;
-                                            }
-                                            else {
-                                                for (let j = 0, match; j < items.length; ++j) {
-                                                    const row = items[j];
-                                                    if ((0, types_1.isPlainObject)(row)) {
-                                                        row['__index__'] ?? (row['__index__'] = j + 1);
-                                                    }
-                                                    let segment = template;
-                                                    while (match = REGEXP_TEMPLATECONDITIONAL.exec(segment)) {
-                                                        const col = hasCondition(row, match[2]) ? 4 : hasCondition(row, match[5]) ? 7 : -1;
-                                                        segment = replaceMatch(match, segment, match[col] ? (!match[1] || match[col - 1].indexOf('\n') !== -1 ? '' : match[1]) + match[col - 1] + match[col] : '', REGEXP_TEMPLATECONDITIONAL);
-                                                    }
-                                                    REGEXP_TEMPLATECONDITIONAL.lastIndex = 0;
-                                                    const literal = segment.trim();
-                                                    if (literal[0] === '`' && literal[literal.length - 1] === '`') {
-                                                        if (!this.hasEval('function')) {
-                                                            errors = (0, types_1.errorMessage)('eval', "Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */, 'function');
-                                                            continue;
-                                                        }
-                                                        try {
-                                                            let content = new Function('return ' + literal + ';').call(row);
-                                                            if (segment[0] !== '`') {
-                                                                content = segment.substring(0, segment.indexOf('`')) + content;
-                                                            }
-                                                            if (segment[segment.length - 1] !== '`') {
-                                                                content += segment.substring(segment.lastIndexOf('`') + 1);
-                                                            }
-                                                            segment = content;
-                                                        }
-                                                        catch (err) {
-                                                            errors = err instanceof Error ? err : true;
-                                                            continue;
-                                                        }
-                                                    }
-                                                    else {
-                                                        const pattern = /\$\{\s*([^\s}]+)\s*\}/g;
-                                                        while (match = pattern.exec(segment)) {
-                                                            segment = replaceMatch(match, segment, match[1] === '__index__' && !(0, types_1.isObject)(row) ? (j + 1).toString() : valueAsString(getObjectValue(row, match[1]), ', '), pattern);
-                                                        }
-                                                    }
-                                                    value += trimTemplate(segment);
-                                                }
-                                            }
-                                            if (preRender) {
-                                                await checkValue(preRender);
-                                            }
-                                            domElement.innerXml = domBase.initOpts.normalize ? dom_1.DomWriter.normalize(value, { newline: domBase.newline, escapeEntities: domBase.initOpts.escapeEntities }) : value;
-                                        }
-                                        else {
-                                            errors = true;
-                                        }
-                                        break;
-                                    }
-                                    case 'attribute': {
-                                        const map = item.value;
-                                        if ((0, types_1.isPlainObject)(map)) {
-                                            for (const attr in map) {
-                                                value = '';
-                                                let segment = map[attr], valid;
-                                                if (item.viewEngine) {
-                                                    if (!(0, types_1.isString)(segment)) {
-                                                        errors = true;
-                                                        continue;
-                                                    }
-                                                    const content = await this.parseTemplate(item.viewEngine, segment, items);
-                                                    if (content === null) {
-                                                        errors = true;
-                                                        continue;
-                                                    }
-                                                    value = content;
-                                                    valid = true;
-                                                }
-                                                else {
-                                                    if ((0, types_1.isString)(segment)) {
-                                                        segment = [segment];
-                                                    }
-                                                    else if (!(0, types_1.isArray)(segment)) {
-                                                        errors = true;
-                                                        continue;
-                                                    }
-                                                    let joinString = ' ', match;
-                                                    for (const row of items) {
-                                                        for (let seg of segment) {
-                                                            seg = seg.trim();
-                                                            if (seg[0] === ':' && (match = /^:join\(([\S\s]*)\)$/i.exec(seg))) {
-                                                                joinString = match[1];
-                                                                continue;
-                                                            }
-                                                            if (match = REGEXP_TEMPLATECONDITIONAL.exec(seg)) {
-                                                                seg = (hasCondition(row, match[2]) ? match[4] : hasCondition(row, match[5]) ? match[7] : '').trim();
-                                                                valid = true;
-                                                            }
-                                                            if (seg) {
-                                                                if (match = /^:text\(([\S\s]*)\)$/i.exec(seg)) {
-                                                                    value += (value ? joinString : '') + match[1];
-                                                                    valid = true;
-                                                                }
-                                                                else {
-                                                                    const data = getObjectValue(row, seg);
-                                                                    if (data !== null) {
-                                                                        if (seg = valueAsString(data, joinString)) {
-                                                                            value += (value ? joinString : '') + seg;
-                                                                        }
-                                                                        valid = true;
-                                                                    }
-                                                                }
-                                                            }
-                                                            REGEXP_TEMPLATECONDITIONAL.lastIndex = 0;
-                                                        }
-                                                    }
-                                                }
-                                                if (valid) {
-                                                    if (preRender) {
-                                                        await checkValue(preRender);
-                                                    }
-                                                    domElement.setAttribute(attr, value);
-                                                }
-                                                else {
-                                                    errors = true;
-                                                }
-                                            }
-                                        }
-                                        else {
-                                            errors = true;
-                                        }
-                                        break;
-                                    }
-                                    case 'display': {
-                                        let template = item.value;
-                                        if (template) {
-                                            if (item.viewEngine) {
-                                                errors = true;
-                                                if ((0, types_1.isString)(template)) {
-                                                    const content = await this.parseTemplate(item.viewEngine, template, items);
-                                                    if (content !== null) {
-                                                        if ((0, types_1.isString)(content) && content.trim() === '') {
-                                                            domElement.remove = true;
-                                                        }
-                                                        errors = false;
-                                                    }
-                                                }
-                                            }
-                                            else {
-                                                if ((0, types_1.isString)(template)) {
-                                                    template = [template];
-                                                }
-                                                else if (!(0, types_1.isArray)(template)) {
-                                                    errors = true;
-                                                    continue;
-                                                }
-                                                let remove = true;
-                                                complete: {
-                                                    const row = items[0];
-                                                    let condition = NaN;
-                                                    for (let seg of template) {
-                                                        switch ((seg = seg.trim()).toLowerCase()) {
-                                                            case ':is(and)':
-                                                                if (condition === 0) {
-                                                                    remove = false;
-                                                                    break complete;
-                                                                }
-                                                                condition = NaN;
-                                                                continue;
-                                                            case ':is(or)':
-                                                                if (isNaN(condition)) {
-                                                                    condition = 0;
-                                                                }
-                                                                continue;
-                                                            default:
-                                                                if (condition > 0) {
-                                                                    continue;
-                                                                }
-                                                                break;
-                                                        }
-                                                        const match = REGEXP_TEMPLATECONDITIONAL.exec(seg);
-                                                        if (match) {
-                                                            seg = (hasCondition(row, match[2]) ? match[4] : hasCondition(row, match[5]) ? match[7] : '').trim();
-                                                        }
-                                                        REGEXP_TEMPLATECONDITIONAL.lastIndex = 0;
-                                                        const sign = seg[0];
-                                                        if (sign === '+' || sign === '-') {
-                                                            seg = seg.substring(1);
-                                                        }
-                                                        const data = getObjectValue(row, seg);
-                                                        let keep = true;
-                                                        if (data === undefined || data === null) {
-                                                            if (sign !== '+') {
-                                                                keep = false;
-                                                            }
-                                                        }
-                                                        else if (sign === '+') {
-                                                            if (data) {
-                                                                keep = false;
-                                                            }
-                                                        }
-                                                        else if (sign === '-' && !data) {
-                                                            keep = false;
-                                                        }
-                                                        if (!isNaN(condition)) {
-                                                            if (!keep) {
-                                                                ++condition;
-                                                            }
-                                                        }
-                                                        else if (keep) {
-                                                            remove = false;
-                                                            break;
-                                                        }
-                                                    }
-                                                    if (condition === 0) {
-                                                        remove = false;
-                                                    }
-                                                }
-                                                if (remove) {
-                                                    domElement.remove = true;
-                                                }
-                                            }
-                                            if (errors && item.removeEmpty) {
-                                                domElement.remove || (domElement.remove = true);
-                                            }
-                                        }
-                                        if (!domElement.remove) {
-                                            if (length === 1) {
-                                                resolve();
-                                                return;
-                                            }
-                                            break invalid;
-                                        }
-                                        break;
-                                    }
-                                    default:
-                                        removeElement(item, domElement);
-                                        if (length === 1) {
-                                            reject(errorDataSource('Invalid action', item.type || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
-                                            return;
-                                        }
-                                        break invalid;
-                                }
-                                if (!domBase.write(domElement) || errors) {
-                                    this.writeFail(item.type === 'display' ? domElement.remove ? errors ? 'Element was removed with errors' : 'Unable to remove element' : 'Unable to determine display conditional' : 'Unable to replace ' + item.type, errors instanceof Error ? errors : errorHtml(element), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
-                                }
-                            }
-                        }
-                        else {
-                            if (!empty && item.type !== 'display' || item.transactionFail) {
-                                const emptyResponse = (value, service = item.source) => errorDataSource(service + ' -> Empty', value || "Unknown" /* ERR_MESSAGE.UNKNOWN */);
-                                switch (item.source) {
-                                    case 'cloud': {
-                                        const { service, table, id, query } = item;
-                                        const queryString = (table ? 'table=' + table : '') + (id || query ? (table ? ';' : '') + (id ? 'id=' + id : 'query=' + asString(query)) : '');
-                                        (cloud || this).formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to execute query" /* ERR_DB.EXEC_QUERY */, queryString], emptyResponse(queryString, service), { ...cloud_1.default.LOG_CLOUD_FAIL, startTime });
-                                        break;
-                                    }
-                                    case 'uri': {
-                                        const { uri, format = uri && path.extname(uri).substring(1) } = item;
-                                        this.formatFail(4 /* LOG_TYPE.PROCESS */, format || 'URI', ['No records were found', uri], emptyResponse(uri), { startTime });
-                                        break;
-                                    }
-                                    case 'local': {
-                                        const { pathname, format = pathname && path.extname(pathname).substring(1) } = item;
-                                        this.formatFail(4 /* LOG_TYPE.PROCESS */, format || 'LOCAL', ['No records were found', pathname], emptyResponse(pathname), { startTime });
-                                        break;
-                                    }
-                                    case 'export': {
-                                        const { pathname, settings, execute } = item;
-                                        let target = execute || pathname || settings;
-                                        if (typeof target === 'function') {
-                                            target = target.name;
-                                        }
-                                        this.formatFail(4 /* LOG_TYPE.PROCESS */, 'EXPORT', ['No records were retrieved', target], emptyResponse(target), { startTime });
-                                        break;
-                                    }
-                                }
-                            }
-                            removeElement(item);
-                        }
-                    }
-                    resolve();
-                });
-            }), 'Element text or attribute replacement');
-        };
-        if (dataItems.length) {
-            await setElements(dataItems);
-        }
-        if (displayItems.length) {
-            await setElements(displayItems);
-        }
-    }
-    setProductionAttributes({ host, hashed, bufferMap, startTime }) {
-        for (const item of this.assets) {
-            if (isIgnored(item, true)) {
-                continue;
-            }
-            if (!hashed.has(item)) {
-                createHash(host, item, bufferMap);
-            }
-            switch (item.element?.tagName.toLowerCase()) {
-                case 'style':
-                    if (!item.content) {
-                        break;
-                    }
-                case 'link':
-                case 'script': {
-                    const attributes = item.attributes;
-                    if (attributes) {
-                        const algorithm = (0, types_1.isString)(attributes.integrity) ? attributes.integrity.trim().toLowerCase() : '';
-                        switch (algorithm) {
-                            case 'sha256':
-                            case 'sha384':
-                            case 'sha512':
-                                try {
-                                    const data = getBuffer(item);
-                                    let value;
-                                    if (data && (value = index_1.default.asHash(data, { algorithm, encoding: item.encoding, digest: 'base64' }))) {
-                                        attributes.integrity = algorithm + '-' + value;
-                                        attributes.crossorigin || (attributes.crossorigin = 'anonymous');
-                                        break;
-                                    }
-                                    throw (0, types_1.errorMessage)('hash', 'Source not found', item.filename);
-                                }
-                                catch (err) {
-                                    this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, item.filename], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
-                                }
-                            default:
-                                if (algorithm) {
-                                    delete attributes.integrity;
-                                }
-                                break;
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    removeUnusedStyles(source, { useUnsafeCssReplace, usedVariables, usedFontFace, usedKeyframes, unusedStyles, unusedMedia, unusedContainer, unusedSupports } = this.config) {
-        var _a;
-        if (!usedVariables && !usedFontFace && !usedKeyframes && !unusedStyles && !unusedMedia && !unusedContainer && !unusedSupports) {
-            return;
-        }
-        const selectorMap = this._selectorMap;
-        const replaceMap = [];
-        const getStringSome = () => useUnsafeCssReplace ? '\\s*' : PATTERN_STRING_SOME;
-        const getStringMany = () => useUnsafeCssReplace ? '\\s+' : PATTERN_STRING_MANY;
-        let current = source, modified, checkEmpty, match;
-        const parseSelector = (value) => {
-            const items = [];
-            const revised = value.replace(useUnsafeCssReplace ? REGEXP_NTHCHILD_UNSAFE : REGEXP_NTHCHILD, (...capture) => {
-                return '`%' + (items.push('\\(' + getStringSome() + (capture[1] === '-' ? '\\x2d' : '\\x2b?') + (capture[2] || '[01]?') + (capture[3] === '0' ? !capture[1] && !capture[2] && !capture[4] && !capture[5] ? '[+-]?0[nN]?' : '0' : '[nN]') + getStringSome() + (capture[5] ? (capture[4] === '-' ? '\\x2d' : '\\x2b') + getStringSome() + capture[5] : `(?:[+-]${getStringSome()}0)?`) + getStringSome() + '\\)') - 1) + '`';
-            });
-            let selector = '';
-            for (let i = 0, length = revised.length, casing = false, attr = false, quote = false; i < length; i++) {
-                let ch = revised[i], space = 0;
-                switch (ch) {
-                    case '.':
-                    case '#':
-                        if (!attr) {
-                            casing = true;
-                        }
-                        break;
-                    case '[':
-                        if (!quote) {
-                            attr = true;
-                            casing = false;
-                            space = 2;
-                        }
-                        break;
-                    case ']':
-                        if (!quote || attr && revised[i - 1] === '"' && revised[i - 2] === '\\') {
-                            if (quote) {
-                                selector = selector.substring(0, selector.length - 1) + '`%%%`';
-                                quote = false;
-                            }
-                            attr = false;
-                            casing = false;
-                            space = 1;
-                        }
-                        break;
-                    case '=':
-                        if (attr && !quote) {
-                            casing = true;
-                            space = 3;
-                        }
-                        break;
-                    case '\\':
-                        ch = '`%%%%`';
-                        break;
-                    case '"':
-                        if (attr) {
-                            if (!quote) {
-                                ch = '`%%%`';
-                                quote = true;
-                            }
-                            else if (revised[i - 1] !== '\\') {
-                                ch = '`%%%`';
-                                quote = false;
-                                casing = false;
-                            }
-                        }
-                        break;
-                    case '~':
-                    case '^':
-                    case '$':
-                    case '*':
-                    case '|':
-                        if (attr && !quote) {
-                            space = 1;
-                        }
-                        break;
-                    case ' ':
-                        if (attr && !quote) {
-                            ch = '`%%`';
-                            break;
-                        }
-                    case ':':
-                    case ',':
-                        if (!attr) {
-                            casing = false;
-                        }
-                        break;
-                }
-                selector += (space & 1 ? '`%%`' : '') + (!casing && ch >= 'a' && ch <= 'z' ? '`' + ch + ch.toUpperCase() + '`' : ch) + (space & 2 ? '`%%`' : '');
-            }
-            selector = (0, types_1.escapePattern)(selector)
-                .replace(/\s*(>|~(?!=)|\\\+|\\\*(?!=)])\s*/g, (...capture) => getStringSome() + capture[1] + getStringSome())
-                .replace(/`([a-z][A-Z]|%{2,4})`/g, (...capture) => {
-                switch (capture[1]) {
-                    case '%%':
-                        return getStringSome();
-                    case '%%%':
-                        return `(?:["']|${getStringSome()})`;
-                    case '%%%%':
-                        return '\\\\{0,}';
-                    default:
-                        return `[${capture[1]}]`;
-                }
-            });
-            for (let i = 0; i < items.length; ++i) {
-                selector = selector.replace('`%' + i + '`', items[i]);
-            }
-            return selector.replace(/[ ]+/g, getStringMany()) + getStringSome();
-        };
-        const replaceUnunsed = (name, items) => {
-            for (let value of items) {
-                const key = name + '_' + (value = value.trim()) + (useUnsafeCssReplace ? '_1' : '');
-                let [pattern] = selectorMap[key] || [], selector = '', rule;
-                if (!pattern) {
-                    let flags = 'gi', revised;
-                    if (name === 'container') {
-                        for (let i = 0, length = value.length, casing = true; i < length; i++) {
-                            let ch = value[i];
-                            if (!casing) {
-                                ch = ch.toLowerCase();
-                            }
-                            else if (ch === '(') {
-                                casing = false;
-                            }
-                            if (casing || ch < 'a' || ch > 'z') {
-                                selector += value[i];
-                                if (selector.endsWith(' not ')) {
-                                    selector = selector.replace(/ not $/, ' `nN``oO``tT` ');
-                                }
-                            }
-                            else {
-                                selector += '`' + ch + ch.toUpperCase() + '`';
-                            }
-                        }
-                        flags = 'g';
-                    }
-                    else if (name === 'supports' && /^selector\(/i.test(value)) {
-                        const startIndex = value.indexOf('(');
-                        const endIndex = value.lastIndexOf(')');
-                        if (startIndex !== -1 && endIndex !== -1) {
-                            selector = '[sS][eE][lL][eE][cC][tT][oO][rR]\\(' + getStringSome() + parseSelector(value.substring(startIndex + 1, endIndex)) + '\\)';
-                            flags = 'g';
-                            revised = true;
-                        }
-                    }
-                    if (!revised) {
-                        selector = (0, types_1.escapePattern)(selector || value)
-                            .replace(/\s*(\\[()])\s*/g, (...capture) => getStringSome() + capture[1] + getStringSome())
-                            .replace(/:\s+/g, getStringSome() + ':' + getStringSome())
-                            .replace(/\s+([<>/]|<=|>=|\\\*)\s+/g, (...capture) => getStringSome() + capture[1] + getStringSome())
-                            .replace(/[ ]+/g, getStringMany());
-                        if (flags === 'g') {
-                            selector = selector.replace(/`([a-z][A-Z])`/g, (...capture) => `[${capture[1]}]`);
-                        }
-                    }
-                    pattern = new RegExp('(\\s*)@' + (flags === 'g' ? name.split('').map(ch => `[${ch + ch.toUpperCase()}]`).join('') : name) + getStringMany() + selector + getStringSome() + '{', flags);
-                }
-                else {
-                    pattern.lastIndex = 0;
-                }
-                while (rule = pattern.exec(current)) {
-                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(rule));
-                    if (endIndex !== -1) {
-                        current = spliceSource(current, rule.index, endIndex, pattern, rule[1], trailing);
-                        (checkEmpty || (checkEmpty = {}))[name] = true;
-                        modified = true;
-                    }
-                }
-                if (selector) {
-                    selectorMap[key] = [pattern];
-                }
-            }
-        };
-        if (!useUnsafeCssReplace) {
-            const replaceBracket = (pattern, opening) => {
-                let bracket;
-                while (bracket = pattern.exec(current)) {
-                    const segment = bracket[0];
-                    if (segment.indexOf('}') !== -1 || opening && segment.indexOf('{') !== -1) {
-                        const placeholder = '`' + (0, types_1.generateUUID)() + '`';
-                        replaceMap.push([placeholder, segment]);
-                        current = replaceMatch(bracket, current, placeholder, pattern);
-                    }
-                }
-                pattern.lastIndex = 0;
-            };
-            replaceBracket(REGEXP_COMMENT, true);
-            replaceBracket(REGEXP_CONTENT, false);
-            const values = (0, util_1.splitEnclosing)(current, /\burl/gi);
-            for (let i = 0, length = values.length; i < length; ++i) {
-                const seg = values[i];
-                if (seg[seg.length - 1] === ')' && seg.indexOf('}') !== -1 && /^url\(/i.test(seg)) {
-                    replaceMap.push([values[i] = (0, types_1.generateUUID)(), seg]);
-                }
-            }
-            if (replaceMap.length) {
-                current = values.join('');
-            }
-        }
-        if (unusedMedia) {
-            replaceUnunsed('media', unusedMedia);
-        }
-        if (unusedSupports) {
-            replaceUnunsed('supports', unusedSupports);
-        }
-        if (unusedContainer) {
-            replaceUnunsed('container', unusedContainer);
-        }
-        if (unusedStyles) {
-            for (const value of unusedStyles) {
-                const key = value + (useUnsafeCssReplace ? '_1' : '');
-                let [single, group] = selectorMap[key] || [], selector;
-                if (!single || !group) {
-                    single = new RegExp(`(}|^)(${getStringSome()})(?<!@[^}]*)${selector = parseSelector(value)}\\{[^}]*\\}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'g');
-                    group = new RegExp(`((?:}|^)[^{]*?)((?:,${getStringSome()}|(?<!@[^}]*))${selector})(,[^{]*)?\\{`, 'g');
-                }
-                else {
-                    single.lastIndex = 0;
-                    group.lastIndex = 0;
-                }
-                while (match = single.exec(current)) {
-                    current = spliceSource(current, match.index, getEndIndex(match), single, match[2], match[3], match[1] || '');
-                    modified = true;
-                }
-                while (match = group.exec(current)) {
-                    const middle = match[2][0] === ',';
-                    const leading = middle ? match[1].trimEnd() : match[1];
-                    const trailing = match[3];
-                    const segment = trailing ? (!middle ? (!isSpace(leading[leading.length - 1]) ? ' ' : '') + trailing.substring(1).trimStart() : trailing).trimEnd() : '';
-                    current = replaceMatch(match, current, leading + segment + ' {');
-                    group.lastIndex = match.index;
-                    modified = true;
-                }
-                if (selector) {
-                    selectorMap[key] = [single, group];
-                }
-            }
-        }
-        if (usedVariables) {
-            const pattern = useUnsafeCssReplace ? REGEXP_VARIABLES_UNSAFE : REGEXP_VARIABLES;
-            while (match = pattern.exec(current)) {
-                if (!usedVariables.includes(match[2])) {
-                    current = replaceMatch(match, current, match[3] === ';' ? getNewlineString(match[1], match[4]) : '', pattern);
-                    modified = true;
-                }
-            }
-            pattern.lastIndex = 0;
-        }
-        if (usedFontFace) {
-            const fontFace = useUnsafeCssReplace ? REGEXP_FONTFACE_UNSAFE : REGEXP_FONTFACE;
-            const fontFamily = useUnsafeCssReplace ? REGEXP_FONTFAMILY_UNSAFE : REGEXP_FONTFAMILY;
-            while (match = fontFace.exec(current)) {
-                const font = fontFamily.exec(match[0]);
-                if (font && !usedFontFace.includes(font[1].trim().replace(/^(["'])([\S\s]+)\1$/, (...content) => content[2]))) {
-                    current = spliceSource(current, match.index, getEndIndex(match), fontFace, match[1], match[3]);
-                    modified = true;
-                }
-            }
-            fontFace.lastIndex = 0;
-        }
-        if (usedKeyframes) {
-            const pattern = useUnsafeCssReplace ? REGEXP_KEYFRAMES_UNSAFE : REGEXP_KEYFRAMES;
-            while (match = pattern.exec(current)) {
-                if (!usedKeyframes.includes(match[2].trim())) {
-                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match));
-                    if (endIndex !== -1) {
-                        current = spliceSource(current, match.index, endIndex, pattern, match[1], trailing);
-                        modified = true;
-                    }
-                }
-            }
-            pattern.lastIndex = 0;
-        }
-        if (modified) {
-            for (const name in checkEmpty) {
-                const pattern = CACHE_ATRULES[_a = name + (useUnsafeCssReplace ? '_1' : '')] || (CACHE_ATRULES[_a] = new RegExp(`(\\s*)@${name}[^{]*{${getStringSome()}}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi'));
-                while (match = pattern.exec(current)) {
-                    current = spliceSource(current, match.index, getEndIndex(match), pattern, match[1], match[2]);
-                }
-                pattern.lastIndex = 0;
-            }
-            if (replaceMap.length) {
-                for (const [placeholder, content] of replaceMap.reverse()) {
-                    current = current.replace(placeholder, content);
-                }
-            }
-            return current;
-        }
-    }
-    get elements() {
-        const result = this._elements;
-        if (result) {
-            return result;
-        }
-        const elements = new Set();
-        const host = this.host;
-        const restartable = host ? host.restartable || this.watching : false;
-        const idMap = this._idMap;
-        this.assets.forEach(item => {
-            const { element, id, flags } = item;
-            if (element) {
-                if (restartable && id && !(0, types_1.cloneFlag)(flags)) {
-                    const backup = idMap[id];
-                    if (backup) {
-                        elements.add(item.element = (0, types_1.cloneObject)(backup, true));
-                        return;
-                    }
-                    idMap[id] = (0, types_1.cloneObject)(element, true);
-                }
-                elements.add(element);
-            }
-        });
-        this.dataSource.forEach(item => elements.add(item.element));
-        return this._elements = Array.from(elements);
-    }
-    get editing() {
-        return this._editing;
-    }
-    set dataSource(value) {
-        this._dataSource = value;
-    }
-    get dataSource() {
-        const result = this._dataSource;
-        if (result) {
-            return result;
-        }
-        const host = this.host;
-        if (host) {
-            try {
-                const items = host.getDataSourceItems(this);
-                return this._dataSource = host.restartable || this.watching ? items.map(item => (0, types_1.cloneObject)(item, true)) : items;
-            }
-            catch {
-            }
-        }
-        return [];
-    }
-    get settings() {
-        var _a;
-        return (_a = this.module).settings || (_a.settings = {});
-    }
-}
-ChromeDocument.INTERNAL_ASSIGNUUID = '__assign__';
-ChromeDocument.INTERNAL_SERVERROOT = '__serverroot__';
-exports.default = ChromeDocument;
-
-if (exports.default) {
-    module.exports = exports.default;
-    module.exports.default = exports.default;
-}