@e-mc/document 0.0.1

package/chrome/index.js

@@ -0,0 +1,3546 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const jimp = require("jimp");
+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 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;
+}