@pi-r/chrome 0.7.2 → 0.8.0

package/index.js

@@ -1,11 +1,12 @@
 "use strict";
 const path = require("path");
 const fs = require("fs");
-const asset_1 = require("@e-mc/document/asset");
-const util_1 = require("@e-mc/document/util");
-const types_1 = require("@e-mc/types");
+const crypto_1 = require("crypto");
 const core_1 = require("@e-mc/core");
 const Cloud = require("@e-mc/cloud");
+const types_1 = require("@e-mc/types");
+const asset_1 = require("@e-mc/document/asset");
+const util_1 = require("@e-mc/document/util");
 const dom_1 = require("@e-mc/document/parse/dom");
 const transform_1 = require("@e-mc/document/transform");
 const Document = require('@e-mc/document');
@@ -14,6 +15,8 @@ const CACHE_LOCALFILE = new Map();
 const CACHE_QUERY = new Map();
 const CACHE_SELECTOR = new Map();
 const CACHE_ETAG = new Map();
+const CACHE_CONTENT = new Map();
+const CACHE_FORMAT = new Map();
 const CACHE_DATASET = {};
 const CACHE_ATRULES = {};
 let CACHE_TOTAL = 0;
@@ -30,10 +33,10 @@ const [REGEXP_NTHCHILD, REGEXP_NTHCHILD_UNSAFE, REGEXP_REPLACECSS] = (function (
     ];
 })();
 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_TEMPLATECONDITIONAL = /(\n\s+)?\{\{if\s+((?:[^}]|}(?!}))+?)\}\}(\s*)(.*?)(?:\s*\{\{else(?:\s+if\s+((?:[^}]|}(?!}))+?))?\}\}(\s*)(.*?)\s*)?\s*\{\{end\}\}/gs;
 const REGEXP_TEMPLATECOMPARISON = /\s*\(\s*(?:\b(eq|ne|lt|le|gt|ge)\s+)?("[^"]+"|'[^']+'|[^\s)]+)(?:\s+("[^"]+"|'[^']+'|[^\s)]+))?\s*\)/g;
 const REGEXP_TEMPLATEMATCH = new RegExp(`^(?:\\b(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_IMPORTMODULE = /(?:(?:^|[\n;]+)\s*import\s+(?:("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')|.+?from\s+("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(?:[ \t]+assert[ \t]+\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]*{|{[^}]*}|}[^}]*}|[^"'`]+)+)\})?)|\bimport\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*(?:,\s*\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]*{|{[^}]*}|}[^}]*}|[^"'`]+)+)\}\s*)?\))/gd;
 const REGEXP_BLOCKEXCLUDE = new RegExp(`(\\s*)<!--\\s*exclude\\s*:\\s*(?:start|end)\\s*-->` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
 const REGEXP_COMMENT = new RegExp(dom_1.DomWriter.PATTERN_COMMENT, 'g');
 const REGEXP_QUOTEDVALUE = new RegExp(`\\b(?:@import${PATTERN_STRING_MANY}|content${PATTERN_STRING_SOME}:${PATTERN_STRING_SOME})(?:"[^"]*"|'[^']*')`, 'gi');
@@ -56,7 +59,8 @@ const REGEXP_URL = /(?:\b[Uu][Rr][Ll]\(|@import\s+(["'])|\b([Hh][Rr][Ee][Ff])\s*
 const REGEXP_URL_JS = /\bimport\(/g;
 const REGEXP_URL_SVG = /(?:\b[Uu][Rr][Ll]\(|@import\s+(["'])|\b([Hh][Rr][Ee][Ff])\s*=)/g;
 const REGEXP_IMAGESET = /\b(?:-webkit-)?image-set\(/gi;
-const REGEXP_IMAGESET_URL = /(?:^|[^(])\s*("(\s*[^)][^"]*)"|'(\s*[^)][^"]*)')\s*(?:,|$|[^)][^,]*,?)/g;
+const REGEXP_IMAGESET_URL = /(?:^|[^(])\s*("(\s*[^)][^"]*)"|'(\s*[^)][^"]*)')\s*(?:,|$|[^)][^,]*,?)/gd;
+const REGEXP_SANITIZEALL = new RegExp(`(?:\\s+|\\b)data-(?:pathname|filename|intl-locales|(?:use|exclude)-[^=\\s]+)\\s*${dom_1.DomWriter.PATTERN_ATTRVALUE}(?=(?:[^"<]+"[^"]*"|[^'<]+'[^']*')*[^<>]*>)`, 'g');
 function removeNamespace(name, source, newline, comments) {
     if (source.includes('-' + name)) {
         const [a, b, c, d, e] = CACHE_DATASET[name] ||= [
@@ -166,7 +170,9 @@ function addCacheItem(map, key, data, timeout) {
     map.set(key, [
         Date.now(),
         data,
-        setTimeout(() => deleteCacheItem(map, key), timeout * 1000)
+        setTimeout(() => {
+            deleteCacheItem(map, key);
+        }, timeout * 1000)
     ]);
 }
 function deleteCacheItem(map, key) {
@@ -181,8 +187,17 @@ function spliceSource(source, startIndex, endIndex, pattern, leading = '', trail
     if (leading || trailing) {
         content += getNewlineString(leading, trailing);
     }
-    pattern.lastIndex = startIndex + content.length;
-    return spliceString(source, startIndex, endIndex, content);
+    return (0, util_1.spliceString)(source, startIndex, endIndex, content, pattern);
+}
+function parseArg(data, value) {
+    if (!isNaN(+value)) {
+        return +value;
+    }
+    const match = /^(["'])(.*)\1$/s.exec(value);
+    if (match) {
+        return match[2];
+    }
+    return getObjectValue(data, value);
 }
 function hasCondition(data, condition) {
     if (!condition) {
@@ -195,7 +210,7 @@ function hasCondition(data, condition) {
             const join = match[1];
             const items = [];
             while (match = REGEXP_TEMPLATECOMPARISON.exec(comparison)) {
-                if (items.length && !isSpace(match[0][0])) {
+                if (items.length > 0 && !isSpace(match[0][0])) {
                     return false;
                 }
                 items.push([match[1], match[2], match[3]]);
@@ -205,15 +220,6 @@ function hasCondition(data, condition) {
             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];
@@ -222,22 +228,22 @@ function hasCondition(data, condition) {
                 if (arg2) {
                     switch (item[0]) {
                         case 'eq':
-                            valid = parseArg(arg1) == parseArg(arg2);
+                            valid = parseArg(data, arg1) == parseArg(data, arg2);
                             break;
                         case 'ne':
-                            valid = parseArg(arg1) != parseArg(arg2);
+                            valid = parseArg(data, arg1) != parseArg(data, arg2);
                             break;
                         case 'lt':
-                            valid = parseArg(arg1) < parseArg(arg2);
+                            valid = parseArg(data, arg1) < parseArg(data, arg2);
                             break;
                         case 'le':
-                            valid = parseArg(arg1) <= parseArg(arg2);
+                            valid = parseArg(data, arg1) <= parseArg(data, arg2);
                             break;
                         case 'gt':
-                            valid = parseArg(arg1) > parseArg(arg2);
+                            valid = parseArg(data, arg1) > parseArg(data, arg2);
                             break;
                         case 'ge':
-                            valid = parseArg(arg1) >= parseArg(arg2);
+                            valid = parseArg(data, arg1) >= parseArg(data, arg2);
                             break;
                         default:
                             return false;
@@ -298,7 +304,11 @@ function hasSameOrigin(value, ...other) {
 function restoreSearchParams(value, prefix = '__sqd') {
     if (value?.includes(prefix)) {
         const params = new URLSearchParams(value);
-        params.forEach((_, key) => key.startsWith(prefix) && params.delete(key));
+        params.forEach((_, key) => {
+            if (key.startsWith(prefix)) {
+                params.delete(key);
+            }
+        });
         if (value = params.toString()) {
             return '?' + value;
         }
@@ -307,7 +317,7 @@ function restoreSearchParams(value, prefix = '__sqd') {
 }
 function getBaseURLs(asset, baseUrl) {
     const result = [];
-    let parentUrl = asset ? asset.url || asset.uri : undefined;
+    let parentUrl = asset ? asset.url || asset.uri : null;
     try {
         if (parentUrl) {
             if (typeof parentUrl === 'string') {
@@ -318,15 +328,18 @@ function getBaseURLs(asset, baseUrl) {
         }
     }
     catch {
-        parentUrl = undefined;
+        parentUrl = null;
     }
     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);
+        else {
+            const { href, origin } = parentUrl;
+            if (origin !== url.origin) {
+                result.push(new URL(href.replace(origin, url.origin)), url);
+            }
         }
     }
     return result;
@@ -338,7 +351,7 @@ function createHash(host, file, hash, bufferMap) {
         if (buffer) {
             const [algorithm, length] = (0, util_1.getHashData)(hash);
             let value;
-            if (algorithm && (value = Document.asHash(buffer, { algorithm, encoding: file.encoding }))) {
+            if (algorithm && (value = Document.asHash(buffer, algorithm, { encoding: file.encoding }))) {
                 if (localUri) {
                     bufferMap[localUri] = buffer;
                 }
@@ -352,8 +365,8 @@ function createHash(host, file, hash, bufferMap) {
         host.writeFail(["Unable to read file", filename], err, 32);
     }
 }
-function getSrcURL(parent, file) {
-    const relativeUrl = file.relativeUrl || this.host.removeCwd(file.localUri) && getRelativeURL(file);
+function getSrcURL(instance, parent, file) {
+    const relativeUrl = file.relativeUrl || instance.host.removeCwd(file.localUri) && getRelativeURL(file);
     if (!relativeUrl) {
         return [''];
     }
@@ -361,12 +374,12 @@ function getSrcURL(parent, file) {
         return [relativeUrl];
     }
     let parentDir = parent.pathname, assetDir = file.pathname;
-    if (!this.productionRelease) {
+    if (!instance.productionRelease) {
         if (parent.moveTo) {
-            parentDir = joinPath(parent.moveTo, parentDir);
+            parentDir = Document.joinPath(parent.moveTo, parentDir);
         }
         if (file.moveTo) {
-            assetDir = joinPath(file.moveTo, assetDir);
+            assetDir = Document.joinPath(file.moveTo, assetDir);
         }
     }
     if (parentDir === assetDir) {
@@ -376,16 +389,16 @@ function getSrcURL(parent, file) {
     const prefix = splitPath(parentDir);
     const suffix = splitPath(assetDir);
     let found;
-    while (prefix.length && suffix.length && prefix[0] === suffix[0]) {
+    while (prefix.length > 0 && suffix.length > 0 && prefix[0] === suffix[0]) {
         prefix.shift();
         suffix.shift();
         found = true;
     }
-    return [found ? joinPath('../'.repeat(prefix.length), suffix.join('/'), file.filename) : '../'.repeat(prefix.length) + relativeUrl];
+    return [found ? Document.joinPath('../'.repeat(prefix.length), suffix.join('/'), file.filename) : '../'.repeat(prefix.length) + relativeUrl];
 }
-function transformURL(host, parent, type, source, importFile) {
+function transformURL(instance, host, parent, type, source, importFile) {
     const related = [];
-    const baseHref = getBaseURLs(importFile || parent, this.baseUrl);
+    const baseHref = getBaseURLs(importFile || parent, instance.baseUrl);
     const isHtml = type === 'html';
     const isJs = type === 'js';
     const pattern = isJs ? REGEXP_URL_JS : type === 'svg' ? REGEXP_URL_SVG : REGEXP_URL;
@@ -399,15 +412,15 @@ function transformURL(host, parent, type, source, importFile) {
             continue;
         }
         REGEXP_IMAGESET_URL.lastIndex = 0;
-        const original = source.substring(startIndex, endIndex);
-        let content = original, url;
-        while (url = REGEXP_IMAGESET_URL.exec(original)) {
+        let content = source.substring(startIndex, endIndex), url;
+        while (url = REGEXP_IMAGESET_URL.exec(content)) {
             const quote = url[2] ? '"' : "'";
-            content = content.replace(url[1], `url(${quote + (url[2] || url[3]).trim() + quote})`);
+            const [a, b] = url.indices[1];
+            content = (0, util_1.spliceString)(content, a, b, `url(${quote + (url[2] || url[3]).trim() + quote})`, REGEXP_IMAGESET_URL);
             modified = true;
         }
         if (modified) {
-            source = spliceString(source, startIndex, REGEXP_IMAGESET.lastIndex = endIndex, content);
+            source = (0, util_1.spliceString)(source, startIndex, endIndex, content, REGEXP_IMAGESET);
             modified = false;
         }
     }
@@ -476,12 +489,12 @@ function transformURL(host, parent, type, source, importFile) {
             if (asset) {
                 if (!asset.inlineBase64) {
                     if (host.Cloud?.getStorage('upload', asset.cloudStorage)) {
-                        const inlineUrlCloud = asset.inlineUrlCloud ||= (0, types_1.generateUUID)();
+                        const inlineUrlCloud = asset.inlineUrlCloud ||= (0, crypto_1.randomUUID)();
                         (parent.inlineUrlCloudMap ||= {})[inlineUrlCloud] = value;
                         value = inlineUrlCloud;
                     }
-                    else if (asset.hash && this.productionRelease) {
-                        const inlineUrl = asset.inlineUrl ||= (0, types_1.generateUUID)();
+                    else if (asset.hash && instance.productionRelease) {
+                        const inlineUrl = asset.inlineUrl ||= (0, crypto_1.randomUUID)();
                         (parent.inlineUrlMap ||= {})[inlineUrl] = value;
                         value = inlineUrl;
                     }
@@ -533,9 +546,8 @@ function transformURL(host, parent, type, source, importFile) {
                 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);
+            source = (0, util_1.spliceString)(source, startIndex, i + 1, revised, pattern);
             length = source.length;
-            pattern.lastIndex = startIndex + revised.length;
             modified = true;
         };
         let url;
@@ -558,18 +570,18 @@ function transformURL(host, parent, type, source, importFile) {
         if (url.startsWith('data:')) {
             const base64 = url.split(',')[1]?.trim();
             if (base64) {
-                for (const item of this.assets) {
+                for (const item of instance.assets) {
                     if (item.base64 === base64) {
-                        setOutputURL(getSrcURL.call(this, parent, item)[0], item);
+                        setOutputURL(getSrcURL(instance, parent, item)[0], item);
                         break;
                     }
                 }
             }
         }
-        else if (baseHref.length) {
+        else if (baseHref.length > 0) {
             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)) {
+                if (asset = host.findAsset(fullUrl = Document.resolvePath(url, parentUrl), { replaced: true }) || (instance.related.has(parent) ? host.findAsset(fullUrl, { assets: Array.from(instance.related.get(parent)), replaced: true }) : undefined)) {
                     break;
                 }
             }
@@ -593,13 +605,13 @@ function transformURL(host, parent, type, source, importFile) {
                                     break;
                                 }
                             }
-                            const layer = this.replaceContent(revised, source.substring(k, l + 1), 'text/css');
+                            const layer = instance.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);
+                            revised = transformURL(instance, host, parent, type, instance.removeServerRoot(revised), asset) || revised;
+                            source = (0, util_1.spliceString)(source, k, l + 1, revised, pattern);
                             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;
@@ -616,7 +628,7 @@ function transformURL(host, parent, type, source, importFile) {
                     }
                     if (hasSameOrigin(asset.url || fullUrl, ...baseHref)) {
                         let sameDir;
-                        [fullUrl, sameDir] = getSrcURL.call(this, parent, asset);
+                        [fullUrl, sameDir] = getSrcURL(instance, parent, asset);
                         if (sameDir && isJs) {
                             fullUrl = './' + fullUrl;
                         }
@@ -628,7 +640,7 @@ function transformURL(host, parent, type, source, importFile) {
                     }
                 }
                 else if (!asset.invalid) {
-                    fullUrl = asset.inlineBase64 ||= (0, types_1.generateUUID)();
+                    fullUrl = asset.inlineBase64 ||= (0, crypto_1.randomUUID)();
                 }
                 if (url !== fullUrl) {
                     setOutputURL(fullUrl, asset);
@@ -640,34 +652,33 @@ function transformURL(host, parent, type, source, importFile) {
         }
     }
     if (modified) {
-        if (related.length) {
-            const previous = this.related.get(parent);
+        if (related.length > 0) {
+            const previous = instance.related.get(parent);
             if (previous) {
-                related.forEach(item => previous.add(item));
+                for (const item of related) {
+                    previous.add(item);
+                }
             }
             else {
-                this.related.set(parent, new Set(related));
+                instance.related.set(parent, new Set(related));
             }
         }
         return source;
     }
 }
-function getFormatUUID(attr, ext) {
-    const format = 'formatMap' in this ? this.formatMap : this.module.format;
+function getFormatUUID(instance, attr, ext) {
+    const format = 'formatMap' in instance ? instance.formatMap : instance.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)();
+    return (0, types_1.isObject)(format) && (0, types_1.isObject)(pattern = ext && ext in format ? format[ext] : format.uuid) && pattern[attr] ? (0, types_1.randomString)(pattern[attr], pattern.dictionary) : (0, crypto_1.randomUUID)();
 }
-function setLocationUUID(data, file, ext) {
+function setLocationUUID(instance, data, file, ext) {
     const { pathname, filename } = data;
     const assignUUID = ChromeDocument.INTERNAL_ASSIGNUUID;
     let index, modified;
     if (filename) {
         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));
+            data.filename = (0, util_1.spliceString)(filename, index, index + assignUUID.length, getFormatUUID(instance, 'filename', ext));
             if (file) {
                 file.inlineFilename = data.filename;
             }
@@ -675,7 +686,7 @@ function setLocationUUID(data, file, ext) {
         }
     }
     if (pathname && (index = pathname.indexOf(assignUUID)) !== -1) {
-        data.pathname = spliceString(pathname, index, index + assignUUID.length, getFormatUUID.call(this, 'pathname', ext));
+        data.pathname = (0, util_1.spliceString)(pathname, index, index + assignUUID.length, getFormatUUID(instance, 'pathname', ext));
         modified = true;
     }
     if (file && modified) {
@@ -685,14 +696,14 @@ function setLocationUUID(data, file, ext) {
         }
     }
 }
-function transformOptions(file, mimeType, code, bundleContent) {
+function transformOptions(instance, file, mimeType, code, bundleContent) {
     const { uri, localUri, exported } = file;
-    const metadata = { userAgentData: this.userAgentData };
+    const metadata = { userAgentData: instance.userAgentData };
     switch (mimeType) {
-        case 'text/html':
+        case "text/html":
             metadata.__fromhtml__ = true;
-        case 'text/css':
-            Object.assign(metadata, this.config);
+        case "text/css":
+            Object.assign(metadata, instance.config);
         default:
             if ((0, types_1.isObject)(file.metadata)) {
                 Object.assign(metadata, file.metadata);
@@ -701,35 +712,35 @@ function transformOptions(file, mimeType, code, bundleContent) {
     }
     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);
+    const sourceFile = !exported && uri && instance.findSourceRoot(uri);
     if (sourceFile) {
-        if (isPath(sourceFile)) {
+        if (Document.isPath(sourceFile)) {
             options.sourceFile = sourceFile;
         }
         options.sourceName = path.basename(sourceFile);
         options.sourcesRelativeTo = path.dirname(sourceFile);
-        options.getMainFile = this.resolveSourceFile(file);
+        options.getMainFile = instance.resolveSourceFile(file);
         if (code) {
-            options.getSourceFiles = this.locateSourceFiles(file, code, bundleContent);
+            options.getSourceFiles = instance.locateSourceFiles(file, code, bundleContent);
         }
     }
-    if ((!this.productionRelease || this.productionIncremental) && !(0, types_1.modifiedFlag)(file.flags)) {
+    if ((!instance.productionRelease || instance.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) {
+function transformJs(instance, host, file, output) {
     const { sourceFiles, chunks, map } = output;
     const localUri = file.localUri;
-    const emptySources = !!this.productionRelease;
+    const emptySources = !!instance.productionRelease;
     let uri;
-    if (map && (uri = writeSourceMap(localUri, output, { hash: file.hash, emptySources, inlineMap: hasSourceMap(file.metadata, 'inline') }))) {
+    if (map && (uri = Document.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 elements = instance.elements;
         const localDir = path.dirname(localUri);
-        const relativeDir = joinPath(file.moveTo, file.pathname);
+        const relativeDir = Document.joinPath(file.moveTo, file.pathname);
         const element = file.element;
         let order = 0, index, appending;
         if (element) {
@@ -744,11 +755,11 @@ function transformJs(host, file, output) {
         for (const chunk of chunks) {
             let chunkName = chunk.filename;
             if (!chunkName) {
-                chunkName = getFormatUUID.call(this, 'filename', 'js') + path.extname(localUri);
+                chunkName = getFormatUUID(instance, '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') }))) {
+            if (chunk.map && (uri = Document.writeSourceMap(chunkUri, chunk, { emptySources, inlineMap: hasSourceMap(file.metadata, 'inline') }))) {
                 host.add(uri, file, types_1.FILE_TYPE.SOURCEMAP);
             }
             try {
@@ -756,7 +767,7 @@ function transformJs(host, file, output) {
                 host.add(chunkUri, file);
                 if (chunk.entryPoint) {
                     if (element) {
-                        const attributes = { ...file.attributes, src: joinPath(relativeDir, chunkName) };
+                        const attributes = { ...file.attributes, src: Document.joinPath(relativeDir, chunkName) };
                         if (file.imports && file.imported !== false) {
                             attributes.type ||= 'module';
                         }
@@ -767,15 +778,17 @@ function transformJs(host, file, output) {
                         });
                     }
                     else {
-                        this.writeFail(['Unable to create script entry point', path.basename(chunkUri)], (0, types_1.errorMessage)('js', 'Element not found', chunkUri), 4);
+                        instance.writeFail(['Unable to create script entry point', path.basename(chunkUri)], (0, types_1.errorMessage)('js', 'Element not found', chunkUri), 4);
                     }
                 }
             }
             catch (err) {
-                this.writeFail(["Unable to write file", path.basename(chunkUri)], err, 32);
+                instance.writeFail(["Unable to write file", path.basename(chunkUri)], err, 32);
             }
         }
-        appending?.forEach(item => item.order += order);
+        appending?.forEach(item => {
+            item.order += order;
+        });
     }
     if ((0, types_1.isArray)(sourceFiles)) {
         file.sourceFiles = sourceFiles;
@@ -783,41 +796,40 @@ function transformJs(host, file, output) {
     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]);
-        }
-    };
-    const { inlineUrlMap, inlineUrlCloudMap } = file;
-    if (inlineUrlMap) {
-        sanitize(inlineUrlMap);
+function replaceCss(instance, file) {
+    if (file.inlineUrlMap) {
+        sanitizeCss(instance, file.inlineUrlMap);
     }
-    if (inlineUrlCloudMap) {
-        sanitize(inlineUrlCloudMap);
+    if (file.inlineUrlCloudMap) {
+        sanitizeCss(instance, file.inlineUrlCloudMap);
     }
 }
-function replaceHtml(source, { productionRelease, contentMap }, cssMap) {
-    const finalize = (value, data) => {
-        for (const id in data) {
-            value = value.replace(new RegExp((0, types_1.escapePattern)(id), 'g'), data[id]);
-        }
-        return value;
-    };
+function sanitizeCss(instance, map) {
+    for (const id in map) {
+        map[id] = instance.removeServerRoot(map[id]);
+    }
+}
+function replaceHtml(instance, source, { productionRelease, contentMap }, cssMap) {
     if (cssMap) {
-        source = finalize(source, cssMap);
+        source = finalizeHtml(source, cssMap);
     }
-    source = finalize(source, contentMap);
-    return productionRelease ? this.removeServerRoot(source) : source;
+    source = finalizeHtml(source, contentMap);
+    return productionRelease ? instance.removeServerRoot(source) : source;
 }
-function isWatched(file) {
+function finalizeHtml(value, data) {
+    for (const id in data) {
+        value = value.replace(new RegExp((0, types_1.escapePattern)(id), 'g'), data[id]);
+    }
+    return value;
+}
+function isWatched(instance, 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'))) {
+    if (file.imported || file.bundleReplace || file.inlineContent || file.inlineBase64 || instance.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) {
+function loadLocalFile(instance, item, pathname, cacheData, encoding, out) {
     let content;
     encoding = (0, types_1.getEncoding)(encoding);
     if (out) {
@@ -829,15 +841,15 @@ function loadLocalFile(item, pathname, cacheData, encoding, out) {
         return require(pathname);
     }
     content ||= fs.readFileSync(pathname, encoding);
-    const result = this.tryParse(content, ext);
+    const result = instance.tryParse(content, ext);
     if (result !== undefined && result !== null) {
-        setCacheData.call(this, item, result, pathname, cacheData, true);
+        setCacheData(instance, item, result, pathname, cacheData, true);
         return result;
     }
 }
-function setCacheData(item, data, dataKey, cacheData, template) {
+function setCacheData(instance, 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');
+        const cache = instance.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);
@@ -847,11 +859,11 @@ function setCacheData(item, data, dataKey, cacheData, template) {
         }
     }
 }
-async function checkData(item, name, result, validate) {
+async function checkData(instance, item, name, result, validate) {
     let callback;
     if (typeof name === 'string') {
-        const template = this.findDataValue(name) || name;
-        callback = this.hasEval('userconfig') ? Document.parseFunction(template, this.hasEval('absolute')) : (0, types_1.asFunction)(template);
+        const template = instance.findDataValue(name) || name;
+        callback = instance.hasEval('userconfig') ? Document.parseFunction(template, instance.hasEval('absolute')) : (0, types_1.asFunction)(template);
     }
     else {
         callback = name;
@@ -871,32 +883,41 @@ async function checkData(item, name, result, validate) {
             }
         }
         catch (err) {
-            this.writeFail(["Unable to parse inline method", name], err);
+            instance.writeFail(["Unable to parse inline method", name], err);
         }
     }
 }
-const getNewlineString = dom_1.DomWriter.getNewlineString.bind(dom_1.DomWriter);
+function removeElement(instance, domBase, item, element) {
+    if (item.removeEmpty || item.type === 'display') {
+        (element ||= new dom_1.HtmlElement(instance.moduleName, item.element)).remove = true;
+        if (!domBase.write(element)) {
+            instance.writeFail('Unable to remove element', errorHtml(item.element), { type: 4 });
+        }
+    }
+}
+function errorCredential(instance, domBase, item, err) {
+    removeElement(instance, domBase, item);
+    const pkg = getPackageName(err);
+    if (!(pkg && instance.checkPackage(err, pkg))) {
+        instance.writeFail(["Invalid credentials", item.source], err);
+    }
+}
 const isSpace = dom_1.DomWriter.isSpace.bind(dom_1.DomWriter);
 const replaceMatch = dom_1.DomWriter.replaceMatch.bind(dom_1.DomWriter);
-const joinPath = Document.joinPath.bind(Document);
-const isPath = Document.isPath.bind(Document);
-const writeSourceMap = Document.writeSourceMap.bind(Document);
-const asString = Document.asString.bind(Document);
-const resolvePath = Document.resolvePath.bind(Document);
-const toPosix = Document.toPosix.bind(Document);
-const isDir = Document.isDir.bind(Document);
-const getBuffer = (item, localUri) => item.sourceUTF8 || item.buffer || ((localUri ||= item.localUri) && isPath(localUri) ? fs.readFileSync(localUri, item.encoding) : null);
+const getNewlineString = dom_1.DomWriter.getNewlineString.bind(dom_1.DomWriter);
+const getBuffer = (item, localUri) => item.sourceUTF8 || item.buffer || ((localUri ||= item.localUri) && Document.isPath(localUri) ? fs.readFileSync(localUri, item.encoding) : null);
 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 isImage = (value) => typeof value === 'string' && value.startsWith('image/') && value !== "image/svg+xml";
 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 getRelativeURL = (file) => Document.joinPath(file.moveTo, file.pathname, file.inlineFilename || file.filename) + (!file.static ? restoreSearchParams(file.url?.search) : '');
+const validateDir = (value) => path.isAbsolute(value) && Document.isDir(value) ? value : '';
+const valueAsString = (value, delimiter) => Array.isArray(value) && !value.some(child => typeof child === 'object') ? value.join(delimiter) : Document.asString(value);
 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);
 const isHtmlOnly = (assets, items, htmlFile) => !items.find(item => item !== htmlFile && assets.includes(item));
@@ -934,6 +955,8 @@ class ChromeDocument extends Document {
             CACHE_QUERY.clear();
             CACHE_SELECTOR.clear();
             CACHE_ETAG.clear();
+            CACHE_CONTENT.clear();
+            CACHE_FORMAT.clear();
         }
         return result + (parent && result > 0 ? await super.purgeMemory(typeof parent === 'number' && parent > 0 ? parent : percent, limit, true) : 0);
     }
@@ -960,17 +983,27 @@ class ChromeDocument extends Document {
                             if (outHtml) {
                                 const { etag, initialValue } = htmlFile;
                                 let buffer;
-                                if (!initialValue || !(etag && initialValue.etag === etag && (buffer = initialValue.buffer)) || fetched.find(item => item !== htmlFile && item.etag && CACHE_ETAG.get(item.localUri) !== item.etag && (item.inlineContent || item.bundleReplace && (!(0, types_1.isArray)(item.from) || item.from.includes('style'))))) {
-                                    fetched.forEach(item => {
-                                        if (item.etag && item !== htmlFile && !item.invalid) {
+                                if (!initialValue || !(etag && initialValue.etag === etag && (buffer = initialValue.buffer)) || fetched.find(item => item !== htmlFile && item.etag && CACHE_ETAG.get(item.localUri) !== item.etag && (item.inlineContent || item.bundleReplace && (!Array.isArray(item.from) || item.from.includes('style'))))) {
+                                    const isValid = (item) => !!item.localUri && item !== htmlFile && !item.invalid;
+                                    for (const item of fetched) {
+                                        if (item.etag && !item.content && isValid(item)) {
                                             CACHE_ETAG.set(item.localUri, item.etag);
                                         }
-                                    });
+                                    }
+                                    for (const item of instance.assets) {
+                                        if (isValid(item)) {
+                                            if (item.content) {
+                                                CACHE_CONTENT.set(item.localUri, item.content);
+                                            }
+                                            if (item.format) {
+                                                CACHE_FORMAT.set(item.localUri, item.format.toString());
+                                            }
+                                        }
+                                    }
                                     break;
                                 }
                                 try {
-                                    const { localUri, encoding } = htmlFile;
-                                    fs.writeFileSync(localUri, buffer, (0, types_1.getEncoding)(encoding));
+                                    fs.writeFileSync(htmlFile.localUri, buffer, (0, types_1.getEncoding)(htmlFile.encoding));
                                     htmlFile.buffer = buffer;
                                     htmlFile.sourceUTF8 = undefined;
                                 }
@@ -978,13 +1011,40 @@ class ChromeDocument extends Document {
                                     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) {
+                            const wasModified = (item) => {
+                                const localUri = item.localUri;
+                                let result = fetched.includes(item) || Array.isArray(item.from) && item.from.includes('style');
+                                if (localUri) {
+                                    if (item.etag && !item.content && !item.invalid) {
+                                        CACHE_ETAG.set(localUri, item.etag);
+                                    }
+                                    else {
+                                        CACHE_ETAG.delete(localUri);
+                                    }
+                                    if (!item.content || item.invalid) {
+                                        CACHE_CONTENT.delete(localUri);
+                                    }
+                                    else if (CACHE_CONTENT.get(localUri) !== item.content || !item.inlineContent && !Document.isPath(localUri)) {
+                                        CACHE_CONTENT.set(localUri, item.content);
+                                        result = true;
+                                    }
+                                    if (!item.format || item.invalid) {
+                                        CACHE_FORMAT.delete(localUri);
+                                    }
+                                    else {
+                                        const format = item.format.toString();
+                                        if (CACHE_FORMAT.get(localUri) !== format || !item.inlineContent && !Document.isPath(localUri)) {
+                                            CACHE_FORMAT.set(localUri, format);
+                                            result = true;
+                                        }
+                                    }
+                                }
+                                return result || this.copiedAssets.includes(item) && (!(0, types_1.isEmpty)(item.bundleId) || !(0, types_1.isEmpty)(item.trailingContent));
+                            };
+                            const js = instance.jsFiles.filter(item => wasModified(item) || !!item.imports);
+                            const css = instance.cssFiles.filter(wasModified);
+                            const svg = instance.svgFiles.filter(wasModified);
+                            if (js.length > 0 || css.length > 0 || svg.length > 0) {
                                 instance.jsFiles = js;
                                 instance.cssFiles = css;
                                 instance.svgFiles = svg;
@@ -1003,7 +1063,7 @@ class ChromeDocument extends Document {
             }
         }
         instance.setInlinedAttributes(processing);
-        if (instance.editing.length) {
+        if (instance.editing.length > 0) {
             await instance.applyTransforms(processing);
             if (instance.aborted) {
                 return (0, types_1.createAbortError)(true);
@@ -1033,7 +1093,7 @@ class ChromeDocument extends Document {
                     (function recurse(children) {
                         for (const item of children) {
                             if (!items.has(item)) {
-                                if (isWatched.call(instance, item)) {
+                                if (isWatched(instance, item)) {
                                     item.flags |= 8;
                                 }
                                 items.add(item);
@@ -1048,40 +1108,126 @@ class ChromeDocument extends Document {
                 }
             }
         }
-        let productionRelease = instance.productionRelease;
+        const 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 Document.copyDir(srcDir, productionRelease, this.incremental !== 'staging');
+            const errorDirectory = (value) => {
+                instance.writeFail(["Unable to read directory", instance.moduleName], (0, types_1.errorMessage)('production', 'Invalid directory', value), 32);
+            };
+            const errorAccess = (value) => {
+                instance.writeFail(["Unable to write directory", instance.moduleName], (0, types_1.errorMessage)('production', "Unsupported access", value), 8192);
+            };
+            const errorMove = (err) => {
+                instance.writeFail(["Unable to move file", instance.moduleName], err, { type: 32, fatal: true });
+            };
+            const outputDir = validateDir(productionRelease);
+            if (outputDir) {
+                if (this.canWrite(outputDir)) {
+                    const srcDir = path.join(this.baseDirectory, ChromeDocument.INTERNAL_SERVERROOT);
+                    if (Document.isDir(srcDir)) {
+                        const serverRootMapping = instance.serverRootMapping;
+                        const mapped = [];
+                        for (const localDir in serverRootMapping) {
+                            const subDir = serverRootMapping[localDir];
+                            const destDir = validateDir(Document.normalizePath(/[\\/]$/.test(subDir) ? path.join(outputDir, subDir, localDir) : path.join(outputDir, subDir), true));
+                            if (destDir.startsWith(outputDir)) {
+                                if (this.canWrite(destDir)) {
+                                    mapped.push([Document.normalizePath(localDir, true), destDir, 0]);
+                                }
+                                else {
+                                    errorAccess(localDir);
+                                    return;
+                                }
+                            }
+                            else {
+                                errorDirectory(localDir);
+                                return;
+                            }
+                        }
+                        if (mapped.length > 0) {
+                            const emptyDir = new Set();
+                            for (const value of this.files) {
+                                if (value.startsWith(ChromeDocument.INTERNAL_SERVERROOT)) {
+                                    const subDir = value.split(path.sep).slice(1);
+                                    const start = subDir.length - 1;
+                                    for (let i = start; i > 0; --i) {
+                                        const localDir = subDir.slice(0, i).join(path.sep) + path.sep;
+                                        const target = mapped.find(item => item[0] === localDir);
+                                        if (target) {
+                                            const src = path.join(this.baseDirectory, value);
+                                            try {
+                                                let destDir = target[1];
+                                                if (i !== start && !Document.createDir(destDir = path.join(destDir, ...subDir.slice(i, start)))) {
+                                                    throw (0, types_1.errorMessage)('production', destDir, 'create');
+                                                }
+                                                const dest = path.join(destDir, subDir[subDir.length - 1]);
+                                                Document.renameFile(src, dest);
+                                                instance.addLog(types_1.STATUS_TYPE.INFO, `production: ${dest} (mapped)`, instance.moduleName, subDir.join(path.sep));
+                                                emptyDir.add(path.dirname(src));
+                                                if (i !== start) {
+                                                    for (let j = 0; j < i; ++j) {
+                                                        emptyDir.add(path.join(this.baseDirectory, ChromeDocument.INTERNAL_SERVERROOT, ...subDir.slice(0, j + 1)));
+                                                    }
+                                                }
+                                                ++target[2];
+                                            }
+                                            catch (err) {
+                                                errorMove(err);
+                                                if (Document.isPath(src)) {
+                                                    fs.unlink(src, error => {
+                                                        if (error) {
+                                                            instance.addLog(types_1.STATUS_TYPE.WARN, error);
+                                                        }
+                                                    });
+                                                }
+                                            }
+                                            finally {
+                                                this.delete(value);
+                                            }
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            for (const item of mapped) {
+                                if (item[2] === 0) {
+                                    instance.addLog(types_1.STATUS_TYPE.INFO, `production: ${item[1]} (mapped: 0)`, instance.moduleName, item[0]);
+                                }
+                            }
+                            for (const pathname of Array.from(emptyDir).sort((a, b) => b.length - a.length)) {
+                                try {
+                                    fs.rmdirSync(pathname);
+                                }
+                                catch {
+                                }
+                            }
+                        }
+                        const result = await Document.copyDir(srcDir, outputDir, this.incremental !== 'staging');
                         const failed = result.failed.map(value => this.removeCwd(value));
                         for (const value of this.files) {
-                            if (value.startsWith(serverRoot)) {
+                            if (value.startsWith(ChromeDocument.INTERNAL_SERVERROOT)) {
                                 if (!failed.includes(value)) {
                                     this.delete(value);
                                 }
                                 else {
-                                    instance.writeFail(["Unable to move file", instance.moduleName], (0, types_1.errorMessage)('production', path.join(this.baseDirectory, value)), { fatal: true });
+                                    errorMove((0, types_1.errorMessage)('production', path.join(this.baseDirectory, value), 'move'));
                                 }
                             }
                         }
                     }
                 }
                 else {
-                    instance.writeFail(["Unable to write directory", instance.moduleName], (0, types_1.errorMessage)('production', "Unsupported access", productionRelease));
+                    errorAccess(productionRelease);
                 }
             }
             else {
-                instance.writeFail(["Unable to read directory", instance.moduleName], (0, types_1.errorMessage)('production', 'Invalid directory', productionRelease), 32);
+                errorDirectory(productionRelease);
             }
         }
     }
     static sanitizeAssets(assets, exclusions = []) {
-        assets.forEach(item => {
+        for (const item of assets) {
             if ((0, types_1.ignoreFlag)(item.flags)) {
-                return;
+                continue;
             }
             for (const attr in item) {
                 switch (attr) {
@@ -1099,7 +1245,8 @@ class ChromeDocument extends Document {
                         break;
                 }
             }
-        });
+        }
+        return assets;
     }
     config = {
         usedVariables: undefined,
@@ -1128,6 +1275,8 @@ class ChromeDocument extends Document {
     baseUrl = '';
     productionRelease = false;
     productionIncremental = false;
+    serverRootMapping = undefined;
+    sanitizeFramework = undefined;
     templateMap = {};
     userAgentData = {};
     related = new Map();
@@ -1141,7 +1290,7 @@ class ChromeDocument extends Document {
     _cloudUrlMap;
     _cloudUploaded;
     _cloudEndpoint;
-    _idMap = Object.create(null);
+    _idMap = {};
     _editing = [];
     _queryMap = new Map();
     _selectorMap = new Map();
@@ -1165,7 +1314,7 @@ class ChromeDocument extends Document {
             }
             if (item.editing) {
                 switch (item.mimeType) {
-                    case 'text/html':
+                    case "text/html":
                         if (!this.htmlFile) {
                             this.htmlFile = item;
                             item.editing = true;
@@ -1175,15 +1324,15 @@ class ChromeDocument extends Document {
                             item.editing = false;
                         }
                         break;
-                    case 'text/css':
+                    case "text/css":
                         this.cssFiles.push(item);
                         this._editing.push(item);
                         break;
-                    case 'text/javascript':
-                    case 'application/javascript':
+                    case "text/javascript":
+                        item.mimeType = "application/javascript";
+                    case "application/javascript":
                         this.jsFiles.push(item);
                         this._editing.push(item);
-                        item.mimeType = 'application/javascript';
                         break;
                 }
             }
@@ -1199,7 +1348,7 @@ class ChromeDocument extends Document {
         });
         let imports;
         if (config) {
-            const { useUnsafeReplace, baseUrl, productionRelease, productionIncremental, templateMap, userAgentData, cache } = config;
+            const { useUnsafeReplace, baseUrl, productionRelease, productionIncremental, serverRootMapping, templateMap, sanitizeFramework, userAgentData, cache } = config;
             const target = this.config;
             for (const attr in config) {
                 if (attr in target) {
@@ -1232,12 +1381,31 @@ class ChromeDocument extends Document {
                 catch {
                 }
             }
-            if (productionRelease === true || (0, types_1.isString)(productionRelease)) {
-                this.productionRelease = productionRelease;
+            if ((0, types_1.isString)(productionRelease)) {
+                this.productionRelease = Document.normalizePath(productionRelease, 2);
+                const baseDir = Document.normalizePath(this.productionRelease, 1 | 2);
+                let baseMap;
+                found: {
+                    for (const map of [this.getUserSettings()?.server_root, this.settings.server_root]) {
+                        for (const pathname in map) {
+                            if (Document.normalizePath(pathname, 1 | 2) === baseDir && (0, types_1.isObject)(map[pathname])) {
+                                baseMap = map[pathname];
+                                break found;
+                            }
+                        }
+                    }
+                }
+                this.serverRootMapping = (0, types_1.isObject)(serverRootMapping) ? baseMap ? Object.assign(baseMap, serverRootMapping) : serverRootMapping : baseMap;
+            }
+            else if (productionRelease) {
+                this.productionRelease = true;
             }
             if (productionIncremental) {
                 this.productionIncremental = true;
             }
+            if ((0, types_1.isArray)(sanitizeFramework)) {
+                this.sanitizeFramework = sanitizeFramework;
+            }
             if ((0, types_1.isObject)(templateMap)) {
                 this.templateMap = templateMap;
             }
@@ -1278,10 +1446,10 @@ class ChromeDocument extends Document {
         for (const storage of cloud) {
             for (const { service, upload, download } of storage) {
                 if (upload) {
-                    setLocationUUID.call(this, upload, null, service);
+                    setLocationUUID(this, upload, null, service);
                 }
                 if (download) {
-                    setLocationUUID.call(this, download, null, service);
+                    setLocationUUID(this, download, null, service);
                 }
             }
         }
@@ -1333,22 +1501,22 @@ class ChromeDocument extends Document {
         const { localUri, mimeType, format } = file;
         const hash = productionRelease && file.hash;
         switch (mimeType) {
-            case 'text/html':
+            case "text/html":
                 if (format) {
-                    const output = await this.transform('html', host.getUTF8String(file, localUri), format, transformOptions.call(this, file, mimeType));
+                    const output = await this.transform('html', host.getUTF8String(file, localUri), format, transformOptions(this, file, mimeType));
                     if (output) {
                         file.modified = true;
                         file.sourceUTF8 = output.code;
                     }
                 }
                 break;
-            case 'text/css':
+            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));
+                    const output = await this.transform('css', source, format, transformOptions(this, file, mimeType, source));
                     if (output) {
                         if (output.map) {
-                            const uri = writeSourceMap(localUri, output, { mimeType, hash, emptySources: productionRelease, inlineMap: hasSourceMap(file.metadata, 'inline') });
+                            const uri = Document.writeSourceMap(localUri, output, { mimeType, hash, emptySources: productionRelease, inlineMap: hasSourceMap(file.metadata, 'inline') });
                             if (uri) {
                                 host.add(uri, file, types_1.FILE_TYPE.SOURCEMAP);
                             }
@@ -1358,8 +1526,8 @@ class ChromeDocument extends Document {
                     }
                 }
                 break;
-            case 'text/javascript':
-            case 'application/javascript': {
+            case "text/javascript":
+            case "application/javascript": {
                 let source = host.getUTF8String(file, localUri);
                 if (!(file.bundleIndex >= 0)) {
                     source = host.setAssetContent(file, source);
@@ -1370,15 +1538,15 @@ class ChromeDocument extends Document {
                     file.modified = true;
                 }
                 if (format) {
-                    const output = await this.transform('js', source, format, transformOptions.call(this, file, mimeType, source, host.contentToAppend.get(localUri)));
+                    const output = await this.transform('js', source, format, transformOptions(this, file, mimeType, source, host.contentToAppend.get(localUri)));
                     if (output) {
-                        source = transformJs.call(this, host, file, output);
+                        source = transformJs(this, host, file, output);
                     }
                 }
                 file.sourceUTF8 = source;
                 break;
             }
-            case 'image/svg+xml': {
+            case "image/svg+xml": {
                 const source = host.getUTF8String(file, localUri);
                 if (/\burl\(/i.test(source)) {
                     file.editing = true;
@@ -1386,7 +1554,7 @@ class ChromeDocument extends Document {
                     this.svgFiles.push(file);
                 }
                 else if (format) {
-                    const output = await this.transform('html', source, format, transformOptions.call(this, file, mimeType, source));
+                    const output = await this.transform('html', source, format, transformOptions(this, file, mimeType, source));
                     if (output) {
                         file.modified = true;
                         file.sourceUTF8 = output.code;
@@ -1482,7 +1650,7 @@ class ChromeDocument extends Document {
             this.replaced.push(file);
         }
         else {
-            setLocationUUID.call(this, file, file);
+            setLocationUUID(this, file, file);
         }
         file.relativeUrl = getRelativeURL(file);
     }
@@ -1490,8 +1658,8 @@ class ChromeDocument extends Document {
         const host = this.host;
         if (host) {
             switch (file.mimeType) {
-                case 'text/javascript':
-                case 'application/javascript':
+                case "text/javascript":
+                case "application/javascript":
                     if (file.imports) {
                         [[file.uri, source], [this.baseUrl, trailing]].forEach(([uri, code], index) => {
                             let localFile;
@@ -1503,24 +1671,26 @@ class ChromeDocument extends Document {
                                     output = this.resolveImports(file, code, bundleMain || file);
                                 }
                                 else if (index === 0 && !exported) {
-                                    if (!isDir(localFile)) {
+                                    if (!Document.isDir(localFile)) {
                                         localFile = path.dirname(localFile);
                                     }
+                                    output = code;
                                     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 ignorePath = bundleMain && (mainFile = this.findSourceRoot(bundleMain.uri)) && (Document.isDir(mainFile) || (mainFile = path.dirname(mainFile))) && mainFile === localFile;
+                                    while (match = REGEXP_IMPORTMODULE.exec(output)) {
                                         const assert = match[3] || match[5];
-                                        const from = trimQuote(value);
+                                        const idx = match[1] ? 1 : match[2] ? 2 : 4;
+                                        const [a, b] = match.indices[idx];
+                                        const from = trimQuote(match[idx]);
+                                        const quote = output[a];
                                         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);
+                                                    const [relativeUrl, sameDir] = getSrcURL(this, bundleMain || file, asset);
                                                     if (relativeUrl) {
-                                                        const quote = value[0];
-                                                        output = (output || code).replace(value, quote + (sameDir ? './' : '') + relativeUrl + quote);
+                                                        output = (0, util_1.spliceString)(output, a, b, quote + (sameDir ? './' : '') + relativeUrl + quote, REGEXP_IMPORTMODULE);
                                                     }
                                                 }
                                             }
@@ -1534,23 +1704,20 @@ class ChromeDocument extends Document {
                                             }
                                             pathname = path.join(localFile, from);
                                         }
-                                        else if (!(pathname = this.findSourceRoot(from)) || !isPath(pathname)) {
+                                        else if (!(pathname = this.findSourceRoot(from)) || !Document.isPath(pathname)) {
                                             const asset = host.findAsset(from);
-                                            if (asset && !asset.invalid) {
-                                                pathname = asset.localUri;
-                                            }
-                                            else {
+                                            if (!asset || asset.invalid) {
                                                 continue;
                                             }
+                                            pathname = asset.localUri;
                                         }
-                                        if (pathname && isPath(pathname)) {
-                                            const quote = value[0];
-                                            output = (output || code).replace(value, quote + pathname + quote);
+                                        if (pathname && Document.isPath(pathname)) {
+                                            output = (0, util_1.spliceString)(output, a, b, quote + pathname + quote, REGEXP_IMPORTMODULE);
                                         }
                                     }
                                     REGEXP_IMPORTMODULE.lastIndex = 0;
                                 }
-                                if (output) {
+                                if (output && output !== code) {
                                     if (index === 0) {
                                         source = output;
                                     }
@@ -1562,14 +1729,14 @@ class ChromeDocument extends Document {
                         });
                     }
                     break;
-                case 'text/css':
+                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);
+                                    const output = transformURL(this, host, file, 'css', source, asset);
                                     if (output) {
                                         source = output;
                                         file.modified = true;
@@ -1579,7 +1746,7 @@ class ChromeDocument extends Document {
                             }
                         }
                         if (trailing && htmlFile) {
-                            const output = transformURL.call(this, host, file, 'css', trailing, htmlFile);
+                            const output = transformURL(this, host, file, 'css', trailing, htmlFile);
                             if (output) {
                                 trailing = output;
                             }
@@ -1620,7 +1787,7 @@ class ChromeDocument extends Document {
                     if (hosted) {
                         const asset = this.host?.findAsset(uri);
                         if (asset) {
-                            const [relativeUrl, sameDir] = getSrcURL.call(this, bundleMain || file, asset);
+                            const [relativeUrl, sameDir] = getSrcURL(this, bundleMain || file, asset);
                             if (relativeUrl) {
                                 value = (sameDir ? './' : '') + relativeUrl;
                             }
@@ -1636,7 +1803,7 @@ class ChromeDocument extends Document {
                         }
                         value = found || original;
                     }
-                    code = spliceString(code, index, index + placeholder.length, value);
+                    code = (0, util_1.spliceString)(code, index, index + placeholder.length, value);
                     modified = true;
                     break;
                 }
@@ -1648,7 +1815,7 @@ class ChromeDocument extends Document {
     }
     replaceContent(source, statement, mimeType) {
         switch (mimeType) {
-            case 'text/css': {
+            case "text/css": {
                 const match = REGEXP_REPLACECSS.exec((typeof statement === 'string' ? statement : statement[0]).trim());
                 if (match) {
                     const layer = match[1];
@@ -1693,7 +1860,7 @@ class ChromeDocument extends Document {
         if (output && command && file.element?.outerXml) {
             const match = REGEXP_SRCSETSIZE.exec(command);
             if (match) {
-                (file.srcSet ||= []).push(toPosix(data.baseDirectory ? output.substring(data.baseDirectory.length + 1) : output), match[1] + match[2].toLowerCase());
+                (file.srcSet ||= []).push(Document.toPosix(data.baseDirectory ? output.substring(data.baseDirectory.length + 1) : output), match[1] + match[2].toLowerCase());
                 file.modified = true;
                 return true;
             }
@@ -1708,7 +1875,7 @@ class ChromeDocument extends Document {
         if (htmlFile) {
             const endpoint = instance.getStorage('upload', htmlFile.cloudStorage)?.upload?.endpoint;
             if (endpoint) {
-                this._cloudEndpoint = new RegExp((0, types_1.escapePattern)(toPosix(endpoint)) + '/', 'g');
+                this._cloudEndpoint = new RegExp((0, types_1.escapePattern)(Document.toPosix(endpoint)) + '/', 'g');
             }
         }
     }
@@ -1793,7 +1960,7 @@ class ChromeDocument extends Document {
                         const { 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));
+                            let filename = Document.joinPath(upload.pathname, upload.filename || path.basename(htmlFile.localUri));
                             if (website.indexPage === true) {
                                 website.indexPage = filename;
                                 filename = '';
@@ -1809,14 +1976,14 @@ class ChromeDocument extends Document {
                             if (website.errorPath === true) {
                                 website.errorPath = filename;
                             }
-                            instance.setBucketWebsite(storage.service, instance.getCredential(storage), bucket, website);
+                            void instance.setBucketWebsite(storage.service, instance.getCredential(storage), bucket, website);
                         }
                     }
                 }
                 if (htmlFile.compress) {
                     await host.compressFile(htmlFile);
                 }
-                return Promise.all(Cloud.uploadAsset(state, htmlFile, { preferBuffer, contentType: 'text/html', ignoreProcess: true }));
+                return Promise.all(Cloud.uploadAsset(state, htmlFile, { preferBuffer, contentType: "text/html", ignoreProcess: true }));
             }
         }
         return [];
@@ -1827,7 +1994,7 @@ class ChromeDocument extends Document {
         }
         const main = watch.main;
         let result;
-        if (main?.editing && main.mimeType === 'text/html') {
+        if (main?.editing && main.mimeType === "text/html") {
             const inlineUrlCloudMap = main.inlineUrlCloudMap || {};
             const using = [];
             let found;
@@ -1840,7 +2007,7 @@ class ChromeDocument extends Document {
                     found = true;
                     using.push(asset);
                 }
-                else if (isWatched.call(this, asset) ||
+                else if (isWatched(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)) {
@@ -1869,8 +2036,9 @@ class ChromeDocument extends Document {
             }
             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)))) {
+            const next = assets?.find(item => (0, asset_1.isEqual)(item, asset));
+            let value, search;
+            if (next) {
                 if (next.cloudUrl) {
                     value = next.cloudUrl;
                     asset.cloudUrl = value;
@@ -1919,7 +2087,7 @@ class ChromeDocument extends Document {
                     const srcset = element.getAttribute('srcset');
                     if (srcset) {
                         const htmlFile = this.htmlFile;
-                        const uri = toPosix(file.uri);
+                        const uri = Document.toPosix(file.uri);
                         const items = new Set([uri]);
                         const baseHref = getBaseURLs(htmlFile, this.baseUrl);
                         const sameOrigin = hasSameOrigin(file.url || uri, ...baseHref);
@@ -1927,7 +2095,7 @@ class ChromeDocument extends Document {
                             const src = element.getAttribute('src');
                             for (const baseUri of baseHref) {
                                 let url;
-                                if (src && uri === resolvePath(url = toPosix(src), baseUri)) {
+                                if (src && uri === Document.resolvePath(url = Document.toPosix(src), baseUri)) {
                                     items.add(url);
                                 }
                                 items.add(uri.startsWith(this.baseDirectory) ? uri.substring(this.baseDirectory.length) : uri.replace(baseUri.origin, ''));
@@ -1940,7 +2108,7 @@ class ChromeDocument extends Document {
                             const pattern = new RegExp(`(,?\\s*)(${(resolve && !url.startsWith('.') ? `(?:\\.\\.[\\\\/])*\\.\\.${pathname}|` : '') + pathname})(` + (!url.includes('?') ? '(?:(?!,)(?:[^?]|$)[^,]*)|(?!\\?)[^,]*)' : '[^,]*)'), 'g');
                             while (match = pattern.exec(current)) {
                                 const partial = match[2];
-                                if (!resolve || baseHref.some(baseUri => uri === resolvePath(partial, baseUri))) {
+                                if (!resolve || baseHref.some(baseUri => uri === Document.resolvePath(partial, baseUri))) {
                                     current = replaceMatch(match, current, match[1] + value + match[3], pattern);
                                 }
                             }
@@ -1978,7 +2146,7 @@ class ChromeDocument extends Document {
                 readBase64(item, item.inlineBase64);
             }
             else if (!item.invalid && (0, util_1.hasValue)(item.format, 'base64')) {
-                const uuid = (0, types_1.generateUUID)();
+                const uuid = (0, crypto_1.randomUUID)();
                 if (readBase64(item, uuid)) {
                     item.inlineBase64 = uuid;
                 }
@@ -2022,9 +2190,9 @@ class ChromeDocument extends Document {
         const { host, hashed, bufferMap, productionRelease } = processing;
         const sanitizeSource = (item, source) => {
             if (productionRelease) {
-                replaceCss.call(this, item);
+                replaceCss(this, item);
             }
-            const output = replaceHtml.call(this, source, processing, item.inlineUrlMap);
+            const output = replaceHtml(this, source, processing, item.inlineUrlMap);
             if (source !== output) {
                 item.modified = true;
                 return output;
@@ -2053,7 +2221,7 @@ class ChromeDocument extends Document {
                 continue;
             }
             let source = host.getUTF8String(item);
-            const output = transformURL.call(this, host, item, 'svg', source);
+            const output = transformURL(this, host, item, 'svg', source);
             if (output) {
                 source = output;
                 item.modified = true;
@@ -2061,7 +2229,7 @@ class ChromeDocument extends Document {
             source = sanitizeSource(item, source);
             const format = item.format;
             if (format) {
-                const result = await this.transform('html', source, format, transformOptions.call(this, item, 'image/svg+xml'));
+                const result = await this.transform('html', source, format, transformOptions(this, item, "image/svg+xml"));
                 if (result) {
                     item.modified = true;
                     source = result.code;
@@ -2088,7 +2256,7 @@ class ChromeDocument extends Document {
                 source = output;
                 item.modified = true;
             }
-            if (output = transformURL.call(this, host, item, 'css', source)) {
+            if (output = transformURL(this, host, item, 'css', source)) {
                 source = output;
                 item.modified = true;
             }
@@ -2096,7 +2264,7 @@ class ChromeDocument extends Document {
             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))));
+                tasks.push(this.transform('css', source, item.format, transformOptions(this, item, "text/css", source, host.contentToAppend.get(item.localUri))));
             }
         }
         for (const item of this.jsFiles) {
@@ -2112,7 +2280,7 @@ class ChromeDocument extends Document {
                 source = output;
                 item.modified = true;
             }
-            if (output = transformURL.call(this, host, item, 'js', source)) {
+            if (output = transformURL(this, host, item, 'js', source)) {
                 source = output;
                 item.modified = true;
             }
@@ -2120,7 +2288,7 @@ class ChromeDocument extends Document {
             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))));
+                tasks.push(this.transform('js', source, format, transformOptions(this, item, "application/javascript", source, host.contentToAppend.get(item.localUri))));
             }
         }
         return Promise.allSettled(tasks).then(items => {
@@ -2130,7 +2298,7 @@ class ChromeDocument extends Document {
                     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') });
+                            const output = Document.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);
                             }
@@ -2139,7 +2307,7 @@ class ChromeDocument extends Document {
                         target.sourceUTF8 = value.code;
                     }
                     else {
-                        transformJs.call(this, host, target, value);
+                        transformJs(this, host, target, value);
                     }
                 }
             }
@@ -2166,7 +2334,7 @@ class ChromeDocument extends Document {
             domBase.ignoreTag(config.ignoreServerCodeBlocks);
         }
         if (productionRelease) {
-            replaceCss.call(this, htmlFile);
+            replaceCss(this, htmlFile);
         }
         await this.setElementAttributes(processing, domBase);
         await this.applyDataSource(processing, domBase);
@@ -2181,6 +2349,11 @@ class ChromeDocument extends Document {
             }
         }
         source = removeNamespace(moduleName, domBase.modified ? domBase.close() : source, domBase.newline, domBase.getComments());
+        if (this.sanitizeFramework) {
+            for (const name of this.sanitizeFramework) {
+                source = source.replace(name === '*' ? REGEXP_SANITIZEALL : new RegExp(`(?:\\s+|\\b)data-(?:${(0, types_1.escapePattern)(name)}-[^=\\s]+|.+?-${(0, types_1.escapePattern)(name)})\\s*${dom_1.DomWriter.PATTERN_ATTRVALUE}(?=(?:[^"<]+"[^"]*"|[^'<]+'[^']*')*[^<>]*>)`, 'g'), '');
+            }
+        }
         if (!htmlFile.preserve) {
             let match;
             while (match = REGEXP_STYLE.exec(source)) {
@@ -2190,10 +2363,10 @@ class ChromeDocument extends Document {
             }
             REGEXP_STYLE.lastIndex = 0;
         }
-        if (output = transformURL.call(this, host, htmlFile, 'html', source)) {
+        if (output = transformURL(this, host, htmlFile, 'html', source)) {
             source = output;
         }
-        source = replaceHtml.call(this, source, processing, htmlFile.inlineUrlMap);
+        source = replaceHtml(this, source, processing, htmlFile.inlineUrlMap);
         if ((0, types_1.isString)(config.stripCommentsAndCDATA)) {
             source = dom_1.DomWriter.getCommentsAndCDATA(source, config.stripCommentsAndCDATA, true, true);
         }
@@ -2203,7 +2376,7 @@ class ChromeDocument extends Document {
             const result = await this.transform('html', source, format, {
                 pathname: path.dirname(localUri),
                 filename,
-                mimeType: 'text/html',
+                mimeType: "text/html",
                 metadata: Object.assign({ '__fromhtml__': true, ...this.config }, metadata),
                 cacheData: !productionRelease || this.productionIncremental ? { uri, encoding } : undefined
             });
@@ -2213,17 +2386,21 @@ class ChromeDocument extends Document {
         }
         if (domBase.hasErrors()) {
             const timeStamp = Date.now();
-            domBase.errors.forEach(err => this.addLog(types_1.STATUS_TYPE.WARN, 'dom-writer -> ' + err.message, timeStamp));
+            for (const err of domBase.errors) {
+                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, startTime });
         }
         else {
-            this.writeTimeProcess('html', `dom-writer (${domBase.modifyCount} modified) -> ` + path.basename(localUri), startTime);
-            if (cacheMiss.length) {
+            this.writeTimeProcess('html', `dom-writer: ${domBase.modifyCount} modified > ` + path.basename(localUri), startTime);
+            if (cacheMiss.length > 0) {
                 const data = {};
                 const message = [];
-                cacheMiss.forEach(name => data[name] = (data[name] || 0) + 1);
+                for (const name of cacheMiss) {
+                    data[name] = (data[name] || 0) + 1;
+                }
                 for (const name in data) {
                     message.push(name + `(${data[name]})`);
                 }
@@ -2247,7 +2424,7 @@ class ChromeDocument extends Document {
                 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)) {
+                    if (!Document.isPath(mapUri)) {
                         mapUri = path.join(path.dirname(item.localUri), sourceMappingURL);
                     }
                     host.deleteFile(mapUri);
@@ -2270,7 +2447,7 @@ class ChromeDocument extends Document {
                 }
                 if (uri && !(0, util_1.hasValue)(item.format, 'crossorigin') && item !== htmlFile) {
                     if (cloud?.getStorage('upload', item.cloudStorage)) {
-                        const inlineUrlCloud = item.inlineUrlCloud ||= (0, types_1.generateUUID)();
+                        const inlineUrlCloud = item.inlineUrlCloud ||= (0, crypto_1.randomUUID)();
                         (htmlFile.inlineUrlCloudMap ||= {})[inlineUrlCloud] = productionRelease ? this.removeServerRoot(uri) : uri;
                         uri = inlineUrlCloud;
                     }
@@ -2301,7 +2478,9 @@ class ChromeDocument extends Document {
                 const detectHeight = domElement.getAttribute('height') === 'detect';
                 if (detectWidth || detectHeight) {
                     let width = 0, height = 0, buffer = null, packageName;
-                    const addLog = (dimension) => this.addLog(types_1.STATUS_TYPE.WARN, 'Could not detect image ' + dimension, packageName || this.moduleName, item.localUri ? path.basename(item.localUri) : item.filename);
+                    const addLog = (dimension) => {
+                        this.addLog(types_1.STATUS_TYPE.WARN, 'Could not detect image ' + dimension, packageName || this.moduleName, item.localUri ? path.basename(item.localUri) : item.filename);
+                    };
                     if (isImage(item.mimeType) && (buffer = host.getBuffer(item))) {
                         try {
                             ({ width, height } = require(packageName = 'image-size').imageSize(buffer));
@@ -2358,29 +2537,20 @@ class ChromeDocument extends Document {
         if (this.dataSource.length === 0) {
             return;
         }
-        const { moduleName, Db: db } = this;
+        const db = this.Db;
         const cloud = host.Cloud;
-        const sessionKey = (0, types_1.generateUUID)();
+        const sessionKey = (0, crypto_1.randomUUID)();
         const cacheData = Object.create(null);
-        const coerceMap = {};
         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 ||= new dom_1.HtmlElement(moduleName, item.element)).remove = true;
-                if (!domBase.write(element)) {
-                    this.writeFail('Unable to remove element', errorHtml(item.element), { type: 4, startTime });
-                }
+        for (const item of this.dataSource) {
+            if (item.type === 'display') {
+                displayItems.push(item);
             }
-        };
-        const errorCredential = (item, err) => {
-            removeElement(item);
-            const pkg = getPackageName(err);
-            if (!(pkg && this.checkPackage(err, pkg))) {
-                this.writeFail(["Invalid credentials", item.source], err);
+            else {
+                dataItems.push(item);
             }
-        };
+        }
         const checkObject = (item, data, type) => {
             const { query, cascade } = item;
             if ((0, types_1.isString)(cascade)) {
@@ -2411,7 +2581,7 @@ class ChromeDocument extends Document {
                         this.checkPackage(err, pkg, ["Unable to filter results", item.source]);
                     }
                 }
-                if (type && !item.ignoreCoerce && (coerceMap[type] ??= this.settingsOf(type, 'coerce') === true)) {
+                if (type && !item.ignoreCoerce && this.settingsOf(type, 'coerce') === true) {
                     (0, types_1.coerceObject)(data);
                 }
             }
@@ -2422,7 +2592,7 @@ class ChromeDocument extends Document {
             const batchGroup = [];
             for (const item of sourceSet) {
                 if (!item.element) {
-                    this.addLog(types_1.STATUS_TYPE.WARN, `Missing target element {${JSON.stringify(item)}}`);
+                    this.addLog(types_1.STATUS_TYPE.WARN, `dom-writer: Missing target element {${JSON.stringify(item)}}`);
                     continue;
                 }
                 const type = item.source;
@@ -2430,11 +2600,11 @@ class ChromeDocument extends Document {
                     case 'cloud': {
                         const { service, credential } = item;
                         if (cloud) {
-                            const key = service + '_' + (service === 'atlas' && item.uri || '') + '_' + asString(credential, true);
+                            const key = service + '_' + (service === 'atlas' && item.uri || '') + '_' + Document.asString(credential, true);
                             (batchMap[key] ||= []).push(item);
                         }
                         else {
-                            errorCredential(item, (0, types_1.errorValue)("Cloud module not installed", service));
+                            errorCredential(this, domBase, item, (0, types_1.errorValue)("Cloud module not installed", service));
                         }
                         break;
                     }
@@ -2464,11 +2634,11 @@ class ChromeDocument extends Document {
                                 (batchMap[key] ||= []).push(item);
                             }
                             catch (err) {
-                                errorCredential(item, err);
+                                errorCredential(this, domBase, item, err);
                             }
                         }
                         else {
-                            errorCredential(item, (0, types_1.errorValue)(db ? "Database provider not found" : "Db module not installed", type));
+                            errorCredential(this, domBase, item, (0, types_1.errorValue)(db ? "Database provider not found" : "Db module not installed", type));
                         }
                         break;
                 }
@@ -2479,11 +2649,11 @@ class ChromeDocument extends Document {
             return this.allSettled(batchGroup.map(async (batch) => {
                 return new Promise(async (resolve, reject) => {
                     const errorRemove = (item, reason) => {
-                        removeElement(item);
+                        removeElement(this, domBase, item);
                         reject(reason);
                     };
                     const errorClient = (item, reason) => {
-                        removeElement(item);
+                        removeElement(this, domBase, item);
                         if (reason) {
                             this.writeFail(["Unable to configure client", item.source], reason);
                         }
@@ -2535,7 +2705,7 @@ class ChromeDocument extends Document {
                                         }
                                         catch (err) {
                                             this.abort(type);
-                                            this.writeFail(["Unable to read file", path.basename(location)], err, { type: 32, startTime });
+                                            this.writeFail(["Unable to read file", path.basename(location)], err, 32);
                                             errorRemove(current);
                                             return;
                                         }
@@ -2605,7 +2775,7 @@ class ChromeDocument extends Document {
                                         }
                                         catch (err) {
                                             this.abort(type);
-                                            this.writeFail(["Unable to read file", path.basename(pathname)], err, { type: 32, startTime });
+                                            this.writeFail(["Unable to read file", path.basename(pathname)], err, 32);
                                             errorRemove(current);
                                             return;
                                         }
@@ -2622,7 +2792,7 @@ class ChromeDocument extends Document {
                                 }
                                 catch (err) {
                                     this.abort(type);
-                                    this.writeFail(["Unable to parse inline object", format], err, { type: 4, startTime });
+                                    this.writeFail(["Unable to parse inline object", format], err, 4);
                                     errorRemove(current);
                                     return;
                                 }
@@ -2637,7 +2807,7 @@ class ChromeDocument extends Document {
                                 return;
                             }
                             if (cacheKey) {
-                                setCacheData.call(this, current, data, cacheKey, cacheData);
+                                setCacheData(this, current, data, cacheKey, cacheData);
                             }
                             if ((result[0] = checkObject(current, data, type)) === null) {
                                 this.abort(type);
@@ -2647,7 +2817,7 @@ class ChromeDocument extends Document {
                             break;
                         }
                         case 'export': {
-                            const cacheKey = asString(current, true);
+                            const cacheKey = Document.asString(current, true);
                             if (!current.ignoreCache && CACHE_DBRESULT.has(cacheKey)) {
                                 result[0] = getCacheItem(CACHE_DBRESULT, cacheKey);
                             }
@@ -2672,7 +2842,7 @@ class ChromeDocument extends Document {
                                             target = pathname;
                                             hint = pathname;
                                         }
-                                        else if ((target = this.resolveDir(type, pathname)) && (getData = core_1.ClientDb.parseFunction(target, true))) {
+                                        else if ((target = this.resolveDir(type, pathname)) && (getData = Document.parseFunction(target, true))) {
                                             hint = pathname;
                                         }
                                         else {
@@ -2722,7 +2892,7 @@ class ChromeDocument extends Document {
                                                 });
                                             }
                                         }
-                                        setCacheData.call(this, current, data, cacheKey, cacheData);
+                                        setCacheData(this, current, data, cacheKey, cacheData);
                                     }
                                     catch (err) {
                                         this.abort(type);
@@ -2767,10 +2937,10 @@ class ChromeDocument extends Document {
                                                     }
                                                     if (!(search.schema = cacheData[pathname])) {
                                                         try {
-                                                            search.schema = loadLocalFile.call(this, current, pathname, cacheData, cmd.encoding);
+                                                            search.schema = loadLocalFile(this, current, pathname, cacheData, cmd.encoding);
                                                         }
                                                         catch (err) {
-                                                            this.writeFail(['Unable to parse document', path.basename(pathname)], err instanceof Error ? errors = err : err, { startTime });
+                                                            this.writeFail(['Unable to parse document', path.basename(pathname)], err instanceof Error ? errors = err : err, 32);
                                                             search.schema = undefined;
                                                         }
                                                     }
@@ -2804,10 +2974,10 @@ class ChromeDocument extends Document {
                                                             if (!(cmd.query = cacheData[pathname])) {
                                                                 const out = { content: '' };
                                                                 try {
-                                                                    cmd.query = loadLocalFile.call(this, current, pathname, cacheData, cmd.encoding, out);
+                                                                    cmd.query = loadLocalFile(this, current, pathname, cacheData, cmd.encoding, out);
                                                                 }
                                                                 catch {
-                                                                    setCacheData.call(this, current, cmd.query = out.content, pathname, cacheData, true);
+                                                                    setCacheData(this, current, cmd.query = out.content, pathname, cacheData, true);
                                                                 }
                                                             }
                                                         }
@@ -2818,7 +2988,7 @@ class ChromeDocument extends Document {
                                                 }
                                                 catch (err) {
                                                     this.abort(type);
-                                                    this.writeFail(["Unable to read file", pathname ? path.basename(pathname) : query], err, { startTime });
+                                                    this.writeFail(["Unable to read file", pathname ? path.basename(pathname) : query], err, 32);
                                                     errorRemove(current);
                                                     return;
                                                 }
@@ -2835,7 +3005,7 @@ class ChromeDocument extends Document {
                                     }
                                     else if (db.hasSource(type, db.sourceType.KEYVALUE)) {
                                         aborting = commandType !== db.commandType.UPDATE;
-                                        message = asString(data.search || data.key);
+                                        message = Document.asString(data.search || data.key);
                                     }
                                     else {
                                         const credential = data.credential;
@@ -2874,7 +3044,7 @@ class ChromeDocument extends Document {
                         const empty = (items = result[i]) === null;
                         if ((items ||= []).length === 0) {
                             if (whenEmpty) {
-                                const data = await checkData.call(this, item, whenEmpty, items, row => Array.isArray(row));
+                                const data = await checkData(this, item, whenEmpty, items, row => Array.isArray(row));
                                 if (data) {
                                     items = data;
                                     item.transactionFail = false;
@@ -2892,22 +3062,21 @@ class ChromeDocument extends Document {
                             items = items.slice(0, limit);
                         }
                         if (postQuery) {
-                            const data = await checkData.call(this, item, postQuery, items = items.slice(0), row => Array.isArray(row));
+                            const data = await checkData(this, item, postQuery, items = items.slice(0), row => Array.isArray(row));
                             if (data) {
                                 items = data;
                             }
                         }
-                        if (items.length && !item.transactionFail) {
+                        if (items.length > 0 && !item.transactionFail) {
                             const { element, preRender } = item;
-                            const domElement = new dom_1.HtmlElement(moduleName, element);
+                            const domElement = new dom_1.HtmlElement(this.moduleName, element);
                             let value = '';
                             const checkValue = async (name) => {
-                                const data = await checkData.call(this, item, name, value, row => typeof row === 'string');
+                                const data = await checkData(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) {
@@ -2921,10 +3090,10 @@ class ChromeDocument extends Document {
                                         if (!(item.value = cacheData[pathname])) {
                                             try {
                                                 item.value = fs.readFileSync(pathname, item.encoding || 'utf-8');
-                                                setCacheData.call(this, item, item.value, pathname, cacheData, true);
+                                                setCacheData(this, item, item.value, pathname, cacheData, true);
                                             }
                                             catch (err) {
-                                                this.writeFail(["Unable to read file", path.basename(pathname)], err, { type: 32, startTime });
+                                                this.writeFail(["Unable to read file", path.basename(pathname)], err, 32);
                                                 errors = true;
                                             }
                                         }
@@ -2943,7 +3112,7 @@ class ChromeDocument extends Document {
                                                 const content = await this.parseTemplate(item.viewEngine, template, items);
                                                 if (content === null) {
                                                     ++domBase.failCount;
-                                                    removeElement(item, domElement);
+                                                    removeElement(this, domBase, item, domElement);
                                                     if (length === 1) {
                                                         resolve();
                                                         return;
@@ -2971,7 +3140,7 @@ class ChromeDocument extends Document {
                                                             continue;
                                                         }
                                                         try {
-                                                            let content = new Function('return ' + literal + ';').call(row);
+                                                            let content = new Function('return ' + literal + ';')(row);
                                                             if (!segment.startsWith('`')) {
                                                                 content = segment.substring(0, segment.indexOf('`')) + content;
                                                             }
@@ -3042,7 +3211,7 @@ class ChromeDocument extends Document {
                                                     for (const row of items) {
                                                         for (let seg of segment) {
                                                             seg = seg.trim();
-                                                            if (seg.startsWith(':') && (match = /^:join\(([\S\s]*)\)$/i.exec(seg))) {
+                                                            if (seg.startsWith(':') && (match = /^:join\((.*)\)$/is.exec(seg))) {
                                                                 joinString = match[1];
                                                                 continue;
                                                             }
@@ -3051,7 +3220,7 @@ class ChromeDocument extends Document {
                                                                 valid = true;
                                                             }
                                                             if (seg) {
-                                                                if (match = /^:text\(([\S\s]*)\)$/i.exec(seg)) {
+                                                                if (match = /^:text\((.*)\)$/is.exec(seg)) {
                                                                     value += (value ? joinString : '') + match[1];
                                                                     valid = true;
                                                                 }
@@ -3188,7 +3357,7 @@ class ChromeDocument extends Document {
                                         break;
                                     }
                                     default:
-                                        removeElement(item, domElement);
+                                        removeElement(this, domBase, item, domElement);
                                         if (length === 1) {
                                             reject(errorDataSource('Invalid action', item.type || "Unknown"));
                                             return;
@@ -3209,18 +3378,18 @@ class ChromeDocument extends Document {
                                 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)) : '');
+                                        const queryString = (table ? 'table=' + table : '') + (id || query ? (table ? ';' : '') + (id ? 'id=' + id : 'query=' + Document.asString(query)) : '');
                                         (cloud || this).formatFail(64, service, ["Unable to execute query", queryString], emptyResponse(queryString, service), { ...Cloud.LOG_CLOUD_FAIL, startTime });
                                         break;
                                     }
                                     case 'uri': {
                                         const { uri, format = uri && path.extname(uri).substring(1) } = item;
-                                        this.formatFail(4, format || 'URI', ['No records were found', uri], emptyResponse(uri), { startTime });
+                                        this.formatFail(4, format || 'URI', ['No records were found', uri], emptyResponse(uri));
                                         break;
                                     }
                                     case 'local': {
                                         const { pathname, format = pathname && path.extname(pathname).substring(1) } = item;
-                                        this.formatFail(4, format || 'LOCAL', ['No records were found', pathname], emptyResponse(pathname), { startTime });
+                                        this.formatFail(4, format || 'LOCAL', ['No records were found', pathname], emptyResponse(pathname));
                                         break;
                                     }
                                     case 'export': {
@@ -3229,22 +3398,22 @@ class ChromeDocument extends Document {
                                         if (typeof target === 'function') {
                                             target = target.name;
                                         }
-                                        this.formatFail(4, 'EXPORT', ['No records were retrieved', target], emptyResponse(target), { startTime });
+                                        this.formatFail(4, 'EXPORT', ['No records were retrieved', target], emptyResponse(target));
                                         break;
                                     }
                                 }
                             }
-                            removeElement(item);
+                            removeElement(this, domBase, item);
                         }
                     }
                     resolve();
                 });
             }), 'Element text or attribute replacement');
         };
-        if (dataItems.length) {
+        if (dataItems.length > 0) {
             await setElements(dataItems);
         }
-        if (displayItems.length) {
+        if (displayItems.length > 0) {
             await setElements(displayItems);
         }
     }
@@ -3486,7 +3655,7 @@ class ChromeDocument extends Document {
                 while (bracket = pattern.exec(current)) {
                     const segment = bracket[0];
                     if (/[{}]/.test(segment)) {
-                        const placeholder = '`' + (0, types_1.generateUUID)() + '`';
+                        const placeholder = '`' + (0, crypto_1.randomUUID)() + '`';
                         replaceMap.push([placeholder, segment]);
                         current = replaceMatch(bracket, current, placeholder, pattern);
                     }
@@ -3498,11 +3667,11 @@ class ChromeDocument extends Document {
             const values = (0, util_1.splitEnclosing)(current, /\burl/gi);
             for (let i = 0, length = values.length; i < length; ++i) {
                 const seg = values[i];
-                if (/^url\([^{}]*[{}][\S\s]*\)$/i.test(seg)) {
-                    replaceMap.push([values[i] = (0, types_1.generateUUID)(), seg]);
+                if (/^url\([^{}]*[{}].*\)$/is.test(seg)) {
+                    replaceMap.push([values[i] = (0, crypto_1.randomUUID)(), seg]);
                 }
             }
-            if (replaceMap.length) {
+            if (replaceMap.length > 0) {
                 current = values.join('');
             }
         }
@@ -3571,7 +3740,7 @@ class ChromeDocument extends Document {
                                     invalid = 1;
                                     break;
                                 }
-                                else if (leading !== -1 && empty[1] === ';') {
+                                if (leading !== -1 && empty[1] === ';') {
                                     content = target.substring(index, found).substring(0, leading).replace(/[^\n;]+$/, '');
                                     invalid = 1;
                                     break;
@@ -3647,7 +3816,7 @@ class ChromeDocument extends Document {
             const fontFamily = useUnsafeCssReplace ? REGEXP_FONTFAMILY_UNSAFE : REGEXP_FONTFAMILY;
             while (match = pattern.exec(current)) {
                 const font = fontFamily.exec(match[0]);
-                if (font && !usedFontFace.includes(font[1].trim().replace(/^(["'])([\S\s]+)\1$/, (...content) => content[2]))) {
+                if (font && !usedFontFace.includes(font[1].trim().replace(/^(["'])(.+)\1$/s, (...content) => content[2]))) {
                     current = spliceSource(current, match.index, getEndIndex(match), pattern, match[1], match[3]);
                     modified = true;
                 }
@@ -3675,7 +3844,7 @@ class ChromeDocument extends Document {
                 }
                 pattern.lastIndex = 0;
             }
-            if (replaceMap.length) {
+            if (replaceMap.length > 0) {
                 for (const [placeholder, content] of replaceMap.reverse()) {
                     current = current.replace(placeholder, content);
                 }
@@ -3692,21 +3861,23 @@ class ChromeDocument extends Document {
         const host = this.host;
         const restartable = host ? host.restartable || this.watching : false;
         const idMap = this._idMap;
-        this.assets.forEach(item => {
+        for (const item of this.assets) {
             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;
+                        continue;
                     }
                     idMap[id] = (0, types_1.cloneObject)(element, true);
                 }
                 elements.add(element);
             }
-        });
-        this.dataSource.forEach(item => elements.add(item.element));
+        }
+        for (const item of this.dataSource) {
+            elements.add(item.element);
+        }
         return this._elements = Array.from(elements);
     }
     get editing() {
@@ -3718,18 +3889,13 @@ class ChromeDocument extends Document {
         }
     }
     get dataSource() {
-        const result = this._dataSource;
-        if (result) {
-            return result;
+        if (this._dataSource) {
+            return this._dataSource;
         }
         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 {
-            }
+            const items = host.getDataSourceItems(this);
+            return this._dataSource = host.restartable || this.watching ? items.map(item => (0, types_1.cloneObject)(item, true)) : items;
         }
         return [];
     }