@pi-r/chrome 0.2.2 → 0.5.0

package/index.js

@@ -12,6 +12,8 @@ const transform_1 = require("@e-mc/document/transform");
 const Document = require('@e-mc/document');
 const CACHE_DBRESULT = new Map();
 const CACHE_LOCALFILE = new Map();
+const CACHE_QUERY = new Map();
+const CACHE_SELECTOR = new Map();
 const CACHE_DATASET = {};
 const CACHE_ATRULES = {};
 let CACHE_TOTAL = 0;
@@ -19,11 +21,11 @@ const REGEXP_SRCSETSIZE = /~\s*([\d.]+)\s*([wx])/i;
 const REGEXP_TEMPLATECONDITIONAL = /(\n\s+)?\{\{if\s+((?:[^}]|}(?!}))+?)\}\}(\s*)([\S\s]*?)(?:\s*\{\{else(?:\s+if\s+((?:[^}]|}(?!}))+?))?\}\}(\s*)([\S\s]*?)\s*)?\s*\{\{end\}\}/g;
 const REGEXP_TEMPLATECOMPARISON = /\s*\(\s*(?:(eq|ne|lt|le|gt|ge)\s+)?("[^"]+"|'[^']+'|[^\s)]+)(?:\s+("[^"]+"|'[^']+'|[^\s)]+))?\s*\)/g;
 const REGEXP_TEMPLATEMATCH = new RegExp(`^(?:(and|or|not)\\s+)?((?:${REGEXP_TEMPLATECOMPARISON.source})+)|(!|not\\s+)?([^\\s][\\S\\s]*)$`);
-const REGEXP_IMPORTMODULE = /(?:(?:^|[\n;]+)\s*import\s+(?:("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')|.+?from\s+("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(?:[ \t]+assert[ \t]+\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]+{|{[^}]+}|}[^}]+}|(?![{}])[^"'`])+)\})?)|\bimport\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*(?:,\s*\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]+{|{[^}]+}|}[^}]+}|(?![{}])[^"'`])+)\}\s*)?\))/g;
+const REGEXP_IMPORTMODULE = /(?:(?:^|[\n;]+)\s*import\s+(?:("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')|.+?from\s+("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(?:[ \t]+assert[ \t]+\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]*{|{[^}]*}|}[^}]*}|(?![{}])[^"'`])+)\})?)|\bimport\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*(?:,\s*\{((?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|`(?:[^`]|(?<=\\)`)+`|{[^{]*{|{[^}]*}|}[^}]*}|(?![{}])[^"'`])+)\}\s*)?\))/g;
 const REGEXP_BLOCKEXCLUDE = new RegExp(`(\\s*)<!--\\s*exclude\\s*:\\s*(?:start|end)\\s*-->` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
 const [PATTERN_STRING_SOME, PATTERN_STRING_MANY] = (function () {
-    const pattern = '(?:\\s|' + dom_1.DomWriter.PATTERN_COMMENT + '|`[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}`)';
-    return [pattern + '*', pattern + '+'];
+    const grouping = '(?:\\s|' + dom_1.DomWriter.PATTERN_COMMENT + '|`[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}`)';
+    return [grouping + '*', grouping + '+'];
 })();
 const REGEXP_COMMENT = new RegExp(dom_1.DomWriter.PATTERN_COMMENT, 'g');
 const REGEXP_CONTENT = new RegExp(`\\bcontent${PATTERN_STRING_SOME}:${PATTERN_STRING_SOME}(?:"[^"]*"|'[^']*')`, 'gi');
@@ -32,15 +34,27 @@ const REGEXP_VARIABLES = new RegExp(`(\\s*)(--[^\\s:]*)${PATTERN_STRING_SOME}:[^
 const REGEXP_FONTFACE = new RegExp(`(\\s*)@font-face${PATTERN_STRING_SOME}{([^}]+)}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
 const REGEXP_FONTFAMILY = new RegExp(`font-family${PATTERN_STRING_SOME}:([^;}]+)`, 'i');
 const REGEXP_KEYFRAMES = new RegExp(`(\\s*)@keyframes${PATTERN_STRING_MANY}([^{]+){`, 'gi');
+const REGEXP_PROPERTY = new RegExp(`(\\s*)@property${PATTERN_STRING_MANY}(--[^\\s]+)${PATTERN_STRING_SOME}{`, 'gi');
 const REGEXP_NTHCHILD = new RegExp(`\\(${PATTERN_STRING_SOME}([+-])?(?:(\\d*)[nN]|(0))${PATTERN_STRING_SOME}([+-])?${PATTERN_STRING_SOME}(\\d*)${PATTERN_STRING_SOME}\\)`, 'g');
 const REGEXP_VARIABLES_UNSAFE = new RegExp(`(\\s*)(--[^\\s:]*)\\s*:[^;}]*([;}])` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'g');
 const REGEXP_FONTFACE_UNSAFE = new RegExp(`(\\s*)@font-face\\s*{([^}]+)}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi');
 const REGEXP_FONTFAMILY_UNSAFE = /font-family\s*:([^;}]+)/i;
 const REGEXP_KEYFRAMES_UNSAFE = /(\s*)@keyframes\s+([^{]+){/gi;
+const REGEXP_PROPERTY_UNSAFE = /(\s*)@property\s+(--[^\s]+)\s*{/gi;
 const REGEXP_NTHCHILD_UNSAFE = /\(\s*([+-])?(?:(\d*)[nN]|(0))\s*([+-])?\s*(\d*)\s*\)/g;
+const REGEXP_OBJECT_NAME = /([^[.\s]+)((?:\s*\[[^\]]+\]\s*)+)?\s*\.?\s*/g;
+const REGEXP_OBJECT_SUBSCRIPT = /\[\s*(["'])?(.+?)\1\s*\]/g;
+const REGEXP_TEMPLATE_LEADING = /\s*\{\{- \s*((?:[^}]|}(?!}))+?)\}\}/g;
+const REGEXP_TEMPLATE_TRAILING = /\{\{((?:[^}]|}(?!}))+?)\s*? -\}\}\s*/g;
+const REGEXP_URL = /(?:\b[Uu][Rr][Ll]\(|@import\s+(["'])|\b([Hh][Rr][Ee][Ff])\s*=)/g;
+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 = /(?:-webkit-)?image-set\(/gi;
+const REGEXP_IMAGESET_URL = /(?:^|[^(])\s*("(\s*[^)][^"]*)"|'(\s*[^)][^"]*)')\s*(?:,|$|[^)][^,]*,?)/g;
+const REGEXP_REPLACECSS = /^@import\s+(?:url\((?:[^)]|(?<=\\)\))+\)|"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(\s*layer(?:\(([^)]*)\)|\b))?(?:\s*supports\(((?:\([^(]+\(|\([^)]+\)|\)[^)]+\)|(?:(?!\))[^(])+|(?:(?!\()[^)])+)+)\))?(.*?);?$/;
 function removeNamespace(name, source, newline, comments) {
     if (source.indexOf('-' + name) !== -1) {
-        const dataset = CACHE_DATASET[name] || (CACHE_DATASET[name] = [
+        const [a, b, c, d, e] = CACHE_DATASET[name] || (CACHE_DATASET[name] = [
             new RegExp(`(\\s*)<(script|style)(${dom_1.DomWriter.PATTERN_TAGOPEN}+)>[\\S\\s]*?<\\/\\2\\s*>` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi'),
             new RegExp(`(\\s*)<link(${dom_1.DomWriter.PATTERN_TAGOPEN}+)>` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'gi'),
             new RegExp(`\\s+data-${name}-[a-z-]+\\s*` + dom_1.DomWriter.PATTERN_ATTRVALUE, 'g'),
@@ -48,24 +62,26 @@ function removeNamespace(name, source, newline, comments) {
             new RegExp(`data-${name}-template\\s*` + dom_1.DomWriter.PATTERN_ATTRVALUE)
         ]);
         source = source
-            .replace(dataset[0], (...capture) => dataset[3].test(capture[3]) || dataset[4].test(capture[3]) ? getNewlineString(capture[1], capture[7], newline) : capture[0])
-            .replace(dataset[1], (...capture) => dataset[3].test(capture[2]) ? getNewlineString(capture[1], capture[6], newline) : capture[0])
-            .replace(dataset[2], '');
+            .replace(a, (...capture) => d.test(capture[3]) || e.test(capture[3]) ? getNewlineString(capture[1], capture[7], newline) : capture[0])
+            .replace(b, (...capture) => d.test(capture[2]) ? getNewlineString(capture[1], capture[6], newline) : capture[0])
+            .replace(c, '');
     }
     return (0, types_1.isArray)(comments) ? source.replace(REGEXP_BLOCKEXCLUDE, (...capture) => getNewlineString(capture[1], capture[2], newline)) : source;
 }
 function getObjectValue(value, key) {
-    const pattern = /([^[.\s]+)((?:\s*\[[^\]]+\]\s*)+)?\s*\.?\s*/g;
+    REGEXP_OBJECT_NAME.lastIndex = 0;
     let found, match;
-    while (match = pattern.exec(key)) {
+    while (match = REGEXP_OBJECT_NAME.exec(key)) {
         if ((0, types_1.isObject)(value)) {
             value = value[match[1]];
-            if (match[2]) {
-                const subscript = /\[\s*(["'])?(.+?)\1\s*\]/g;
+            const name = match[2];
+            if (name) {
+                REGEXP_OBJECT_SUBSCRIPT.lastIndex = 0;
                 let index;
-                while (index = subscript.exec(match[2])) {
-                    const attr = index[1] ? index[2] : index[2].trim();
-                    if (index[1] && (0, types_1.isObject)(value) || /^\d+$/.test(attr) && (typeof value === 'string' || (0, types_1.isObject)(value))) {
+                while (index = REGEXP_OBJECT_SUBSCRIPT.exec(name)) {
+                    const quote = index[1];
+                    const attr = quote ? index[2] : index[2].trim();
+                    if (quote && (0, types_1.isObject)(value) || /^\d+$/.test(attr) && (typeof value === 'string' || (0, types_1.isObject)(value))) {
                         value = value[attr];
                     }
                     else {
@@ -83,14 +99,14 @@ function getObjectValue(value, key) {
     return found ? value : null;
 }
 function trimTemplate(value) {
-    const leading = /\s*\{\{- \s*((?:[^}]|}(?!}))+?)\}\}/g;
+    REGEXP_TEMPLATE_LEADING.lastIndex = 0;
     let match;
-    while (match = leading.exec(value)) {
-        value = replaceMatch(match, value, 1, leading);
+    while (match = REGEXP_TEMPLATE_LEADING.exec(value)) {
+        value = replaceMatch(match, value, 1, REGEXP_TEMPLATE_LEADING);
     }
-    const trailing = /\{\{((?:[^}]|}(?!}))+?)\s*? -\}\}\s*/g;
-    while (match = trailing.exec(value)) {
-        value = replaceMatch(match, value, 1, trailing);
+    REGEXP_TEMPLATE_TRAILING.lastIndex = 0;
+    while (match = REGEXP_TEMPLATE_TRAILING.exec(value)) {
+        value = replaceMatch(match, value, 1, REGEXP_TEMPLATE_TRAILING);
     }
     return value;
 }
@@ -100,15 +116,18 @@ function trimQuote(value) {
     const last = value[value.length - 1];
     return first === last && (first === '"' || first === "'") ? value.substring(1, value.length - 1).trim() : value;
 }
-function findClosingIndex(source, lastIndex) {
-    const pattern = /[{}]/g;
+function findClosingIndex(source, lastIndex, char) {
+    const pattern = char === '{' ? /[{}]/g : /[()]/g;
     pattern.lastIndex = lastIndex;
     let opened = 1, closed = 0, endIndex = -1, trailing = '', match;
     while (match = pattern.exec(source)) {
-        if (match[0] === '{') {
+        if (match[0] === char) {
             ++opened;
         }
         else if (++closed === opened) {
+            if (char === '(') {
+                return match.index;
+            }
             endIndex = match.index + 1;
             let ch;
             while (isSpace(ch = source[endIndex])) {
@@ -123,23 +142,9 @@ function findClosingIndex(source, lastIndex) {
     }
     return [endIndex, trailing];
 }
-function getPackageName(err, value) {
+function getPackageName(err) {
     if (err instanceof Error && err.code === types_1.ERR_CODE.MODULE_NOT_FOUND) {
-        switch (value) {
-            case 'mongodb':
-            case 'redis':
-                return value;
-            case 'mysql':
-                return 'mysql2';
-            case 'postgres':
-                return 'pg';
-            case 'oracle':
-                return 'oracledb';
-            case 'mssql':
-                return 'tedious';
-            default:
-                return (0, util_1.getModuleName)(err);
-        }
+        return (0, util_1.getModuleName)(err);
     }
 }
 function getCacheItem(map, key) {
@@ -182,9 +187,9 @@ function hasCondition(data, condition) {
     }
     let match = REGEXP_TEMPLATEMATCH.exec(condition.trim());
     if (match) {
-        if (match[2]) {
+        const comparison = match[2];
+        if (comparison) {
             const join = match[1];
-            const comparison = match[2];
             const items = [];
             while (match = REGEXP_TEMPLATECOMPARISON.exec(comparison)) {
                 if (items.length && !isSpace(match[0][0])) {
@@ -269,37 +274,33 @@ function isTruthy(data, attr, falsey) {
 }
 function hasSameOrigin(value, ...other) {
     for (let url of other) {
-        if (!url) {
-            continue;
-        }
-        try {
-            if (typeof value === 'string') {
-                value = new URL(value);
-            }
-            if (typeof url === 'string') {
-                url = new URL(url);
+        if (url) {
+            try {
+                if (typeof value === 'string') {
+                    value = new URL(value);
+                }
+                if (typeof url === 'string') {
+                    url = new URL(url);
+                }
+                if (value.origin === url.origin) {
+                    return true;
+                }
             }
-            if (value.origin === url.origin) {
-                return true;
+            catch {
             }
         }
-        catch {
-        }
     }
     return false;
 }
 function restoreSearchParams(value, prefix = '__sqd') {
-    if (value) {
-        if (value.indexOf(prefix) !== -1) {
-            const params = new URLSearchParams(value);
-            params.forEach((_, key) => key.startsWith(prefix) && params.delete(key));
-            if (value = params.toString()) {
-                return '?' + value;
-            }
+    if (value?.indexOf(prefix) !== -1) {
+        const params = new URLSearchParams(value);
+        params.forEach((_, key) => key.startsWith(prefix) && params.delete(key));
+        if (value = params.toString()) {
+            return '?' + value;
         }
-        return value;
     }
-    return '';
+    return value || '';
 }
 function getBaseURLs(asset, baseUrl) {
     const result = [];
@@ -327,28 +328,25 @@ function getBaseURLs(asset, baseUrl) {
     }
     return result;
 }
-function createHash(host, file, bufferMap) {
-    const hash = file.hash;
-    if (hash) {
-        try {
-            const localUri = file.localUri;
-            const buffer = localUri && bufferMap[localUri] || getBuffer(file);
-            if (buffer) {
-                const [algorithm, length] = (0, util_1.getHashData)(hash);
-                let value;
-                if (algorithm && (value = Document.asHash(buffer, { algorithm, encoding: file.encoding }))) {
-                    if (localUri) {
-                        bufferMap[localUri] = buffer;
-                    }
-                    host.rename(file, (0, util_1.appendSuffix)(file.filename, length ? value.substring(0, length) : value));
-                    return file.filename;
+function createHash(host, file, hash, bufferMap) {
+    const { filename, localUri } = file;
+    try {
+        const buffer = localUri && bufferMap[localUri] || getBuffer(file, localUri);
+        if (buffer) {
+            const [algorithm, length] = (0, util_1.getHashData)(hash);
+            let value;
+            if (algorithm && (value = Document.asHash(buffer, { algorithm, encoding: file.encoding }))) {
+                if (localUri) {
+                    bufferMap[localUri] = buffer;
                 }
+                host.rename(file, (0, util_1.appendSuffix)(filename, length ? value.substring(0, length) : value));
+                return file.filename;
             }
-            throw (0, types_1.errorMessage)('hash', 'Source not found', file.filename);
-        }
-        catch (err) {
-            host.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, file.filename], err, 32 /* LOG_TYPE.FILE */);
         }
+        throw (0, types_1.errorMessage)('hash', 'Source not found', filename);
+    }
+    catch (err) {
+        host.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, filename], err, 32 /* LOG_TYPE.FILE */);
     }
 }
 function getSrcURL(parent, file) {
@@ -387,8 +385,29 @@ function transformURL(host, parent, type, source, importFile) {
     const baseHref = getBaseURLs(importFile || parent, this.baseUrl);
     const isHtml = type === 'html';
     const isJs = type === 'js';
-    const pattern = isJs ? /\bimport\(/g : type === 'svg' ? /(?:\b[Uu][Rr][Ll]\(|@import\s+(["'])|\b([Hh][Rr][Ee][Ff])\s*=)/g : /\b[Uu][Rr][Ll]\(|@import\s+(["'])/g;
+    const pattern = isJs ? REGEXP_URL_JS : type === 'svg' ? REGEXP_URL_SVG : REGEXP_URL;
+    pattern.lastIndex = 0;
+    REGEXP_IMAGESET.lastIndex = 0;
     let length = source.length, modified, match;
+    while (match = REGEXP_IMAGESET.exec(source)) {
+        const startIndex = match.index + match[0].length;
+        const endIndex = findClosingIndex(source, startIndex, '(');
+        if (endIndex === -1) {
+            continue;
+        }
+        REGEXP_IMAGESET_URL.lastIndex = 0;
+        const original = source.substring(startIndex, endIndex);
+        let content = original, url;
+        while (url = REGEXP_IMAGESET_URL.exec(original)) {
+            const quote = url[2] ? '"' : "'";
+            content = content.replace(url[1], `url(${quote + (url[2] || url[3]).trim() + quote})`);
+            modified = true;
+        }
+        if (modified) {
+            source = spliceString(source, startIndex, REGEXP_IMAGESET.lastIndex = endIndex, content);
+            modified = false;
+        }
+    }
     while (match = pattern.exec(source)) {
         const isText = !!match[1];
         const isHref = !!match[2];
@@ -668,7 +687,7 @@ function transformOptions(file, mimeType, code, bundleContent) {
     const metadata = { userAgentData: this.userAgentData };
     switch (mimeType) {
         case 'text/html':
-            metadata['__fromhtml__'] = true;
+            metadata.__fromhtml__ = true;
         case 'text/css':
             Object.assign(metadata, this.config);
         default:
@@ -745,7 +764,7 @@ function transformJs(host, file, output) {
                         });
                     }
                     else {
-                        this.writeFail(['Unable to create element entry point', path.basename(chunkUri)], (0, types_1.errorMessage)('js', 'Element not found', chunkUri), 4 /* LOG_TYPE.PROCESS */);
+                        this.writeFail(['Unable to create script entry point', path.basename(chunkUri)], (0, types_1.errorMessage)('js', 'Element not found', chunkUri), 4 /* LOG_TYPE.PROCESS */);
                     }
                 }
             }
@@ -767,19 +786,25 @@ function replaceCss(file) {
             map[id] = this.removeServerRoot(map[id]);
         }
     };
-    if (file.inlineUrlMap) {
-        sanitize(file.inlineUrlMap);
+    const { inlineUrlMap, inlineUrlCloudMap } = file;
+    if (inlineUrlMap) {
+        sanitize(inlineUrlMap);
     }
-    if (file.inlineUrlCloudMap) {
-        sanitize(file.inlineUrlCloudMap);
+    if (inlineUrlCloudMap) {
+        sanitize(inlineUrlCloudMap);
     }
 }
 function replaceHtml(source, { productionRelease, contentMap }, cssMap) {
-    for (const data of [cssMap, contentMap]) {
+    const finalize = (value, data) => {
         for (const id in data) {
-            source = source.replace(new RegExp((0, types_1.escapePattern)(id), 'g'), data[id]);
+            value = value.replace(new RegExp((0, types_1.escapePattern)(id), 'g'), data[id]);
         }
+        return value;
+    };
+    if (cssMap) {
+        source = finalize(source, cssMap);
     }
+    source = finalize(source, contentMap);
     return productionRelease ? this.removeServerRoot(source) : source;
 }
 function isWatched(file) {
@@ -858,11 +883,11 @@ 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 hasSourceMap = (metadata, value) => (0, types_1.isObject)(metadata) && metadata['__sourcemap__'] === value;
+const getBuffer = (item, localUri) => item.sourceUTF8 || item.buffer || ((localUri || (localUri = item.localUri)) && 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 getBuffer = (item) => item.sourceUTF8 || item.buffer || (item.localUri && isPath(item.localUri) ? fs.readFileSync(item.localUri, item.encoding) : null);
 const isRemoved = (item) => item.exclude === true || isBundled(item.bundleIndex);
 const isUnedited = (item) => !item.attributes && !item.inlineContent && !item.srcSet && !item.element.dynamic && item.element.textContent === undefined && (!item.uri && !isBundled(item.bundleIndex, true) || (0, util_1.hasValue)(item.format, 'crossorigin'));
 const isIgnored = (item, exists) => item.invalid || (0, types_1.ignoreFlag)(item.flags) || !exists && (0, types_1.existsFlag)(item.flags);
@@ -888,6 +913,7 @@ class ChromeDocument extends Document {
             useOriginalHtmlPage: undefined,
             useUnsafeHtmlReplace: undefined,
             useUnsafeCssReplace: undefined,
+            useSessionCache: undefined,
             stripCommentsAndCDATA: undefined,
             normalizeHtmlOutput: undefined,
             escapeReservedCharacters: undefined,
@@ -910,7 +936,8 @@ class ChromeDocument extends Document {
         this._elements = null;
         this._idMap = Object.create(null);
         this._editing = [];
-        this._selectorMap = {};
+        this._queryMap = new Map();
+        this._selectorMap = new Map();
     }
     static async purgeMemory(percent = 1, limit = 0, parent) {
         if (typeof limit === 'boolean') {
@@ -918,14 +945,14 @@ class ChromeDocument extends Document {
             limit = 0;
         }
         let result = 0;
-        if (limit === 0 || CACHE_TOTAL >= limit) {
+        if ((limit === 0 || CACHE_TOTAL >= limit) && percent > 0) {
             if (percent >= 1) {
                 result += CACHE_DBRESULT.size + CACHE_LOCALFILE.size;
                 CACHE_DBRESULT.clear();
                 CACHE_LOCALFILE.clear();
                 CACHE_TOTAL = 0;
             }
-            else if (percent > 0) {
+            else {
                 const stored = [];
                 for (const map of [CACHE_DBRESULT, CACHE_LOCALFILE]) {
                     for (const [key, value] of map) {
@@ -940,6 +967,8 @@ class ChromeDocument extends Document {
                 }
                 CACHE_TOTAL = stored.length - result;
             }
+            CACHE_QUERY.clear();
+            CACHE_SELECTOR.clear();
         }
         return result + (parent && result > 0 ? await super.purgeMemory(typeof parent === 'number' && parent > 0 ? parent : percent, limit, true) : 0);
     }
@@ -1050,34 +1079,35 @@ class ChromeDocument extends Document {
             }
         }
         let productionRelease = instance.productionRelease;
-        if ((0, types_1.isString)(productionRelease)) {
-            if (path.isAbsolute(productionRelease = path.normalize(productionRelease)) && isDir(productionRelease)) {
-                if (this.canWrite(productionRelease)) {
-                    const serverRoot = ChromeDocument.INTERNAL_SERVERROOT;
-                    const srcDir = path.join(this.baseDirectory, serverRoot);
-                    if (isDir(srcDir)) {
-                        const result = await Document.copyDir(srcDir, productionRelease, this.incremental !== 'staging');
-                        const failed = result.failed.map(value => this.removeCwd(value));
-                        for (const value of this.files) {
-                            if (value.startsWith(serverRoot)) {
-                                if (!failed.includes(value)) {
-                                    this.delete(value);
-                                }
-                                else {
-                                    instance.writeFail(["Unable to move file" /* ERR_MESSAGE.MOVE_FILE */, instance.moduleName], (0, types_1.errorMessage)('production', path.join(this.baseDirectory, value)), { fatal: true });
-                                }
+        if (!(0, types_1.isString)(productionRelease)) {
+            return;
+        }
+        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 failed = result.failed.map(value => this.removeCwd(value));
+                    for (const value of this.files) {
+                        if (value.startsWith(serverRoot)) {
+                            if (!failed.includes(value)) {
+                                this.delete(value);
+                            }
+                            else {
+                                instance.writeFail(["Unable to move file" /* ERR_MESSAGE.MOVE_FILE */, instance.moduleName], (0, types_1.errorMessage)('production', path.join(this.baseDirectory, value)), { fatal: true });
                             }
                         }
                     }
                 }
-                else {
-                    instance.writeFail(["Unable to write directory" /* ERR_MESSAGE.WRITE_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Access denied', productionRelease));
-                }
             }
             else {
-                instance.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Invalid directory', productionRelease), 32 /* LOG_TYPE.FILE */);
+                instance.writeFail(["Unable to write directory" /* ERR_MESSAGE.WRITE_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Access denied', productionRelease));
             }
         }
+        else {
+            instance.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, instance.moduleName], (0, types_1.errorMessage)('production', 'Invalid directory', productionRelease), 32 /* LOG_TYPE.FILE */);
+        }
     }
     static sanitizeAssets(assets, exclusions = []) {
         assets.forEach(item => {
@@ -1158,8 +1188,9 @@ class ChromeDocument extends Document {
             }
             return 0;
         });
+        let imports;
         if (config) {
-            const { useUnsafeReplace, baseUrl, productionRelease, productionIncremental, templateMap, userAgentData, imports, cache } = config;
+            const { useUnsafeReplace, baseUrl, productionRelease, productionIncremental, templateMap, userAgentData, cache } = config;
             const target = this.config;
             for (const attr in config) {
                 if (attr in target) {
@@ -1204,22 +1235,37 @@ class ChromeDocument extends Document {
             if ((0, types_1.isObject)(userAgentData)) {
                 this.userAgentData = userAgentData;
             }
-            this.imports = (0, types_1.isPlainObject)(imports) ? { ...this.module.imports, ...imports } : this.module.imports;
             if ((0, types_1.isObject)(cache) && 'transform' in cache) {
                 this.customize({ transform: cache.transform });
             }
+            if (!(0, types_1.isPlainObject)(imports = config.imports)) {
+                imports = undefined;
+            }
         }
         super.init(assets, config);
         const mimeMap = this._mimeMap;
-        if (mimeMap && 'format' in mimeMap) {
-            const format = mimeMap.format;
-            if ((0, types_1.isObject)(format)) {
-                this.formatMap = 'pathname' in format || 'filename' in format || 'dictionary' in format ? { uuid: format } : format;
+        if (mimeMap) {
+            if ('imports' in mimeMap) {
+                const imported = mimeMap.imports;
+                if ((0, types_1.isPlainObject)(imported)) {
+                    imports = imports ? Object.assign(imported, imports) : imported;
+                }
+                delete mimeMap.imports;
             }
-            else {
-                this.formatMap = undefined;
+            if ('format' in mimeMap) {
+                const format = mimeMap.format;
+                if ((0, types_1.isObject)(format)) {
+                    this.formatMap = 'pathname' in format || 'filename' in format || 'dictionary' in format ? { uuid: format } : format;
+                }
+                else {
+                    this.formatMap = undefined;
+                }
+                delete mimeMap.format;
             }
         }
+        if (imports) {
+            this.imports = imports;
+        }
         for (const storage of cloud) {
             for (const { service, upload, download } of storage) {
                 if (upload) {
@@ -1588,7 +1634,7 @@ class ChromeDocument extends Document {
     replaceContent(source, statement, mimeType) {
         switch (mimeType) {
             case 'text/css': {
-                const match = /^@import\s+(?:url\((?:[^)]|(?<=\\)\))+\)|"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')(\s*layer(?:\(([^)]*)\)|\b))?(?:\s*supports\(((?:\([^(]+\(|\([^)]+\)|\)[^)]+\)|(?:(?!\))[^(])+|(?:(?!\()[^)])+)+)\))?(.*?);?$/.exec((typeof statement === 'string' ? statement : statement[0]).trim());
+                const match = REGEXP_REPLACECSS.exec((typeof statement === 'string' ? statement : statement[0]).trim());
                 if (match) {
                     const layer = match[1];
                     const supports = match[3]?.trim();
@@ -1643,8 +1689,9 @@ class ChromeDocument extends Document {
         this._cloudUrlMap = Object.create(null);
         this._cloudUploaded = new Set();
         this._cloudEndpoint = null;
-        if (this.htmlFile) {
-            const endpoint = instance.getStorage('upload', this.htmlFile.cloudStorage)?.upload?.endpoint;
+        const htmlFile = this.htmlFile;
+        if (htmlFile) {
+            const endpoint = instance.getStorage('upload', htmlFile.cloudStorage)?.upload?.endpoint;
             if (endpoint) {
                 this._cloudEndpoint = new RegExp((0, types_1.escapePattern)(toPosix(endpoint)) + '/', 'g');
             }
@@ -1822,9 +1869,7 @@ class ChromeDocument extends Document {
                 }
             }
             search ?? (search = restoreSearchParams(asset.url?.search));
-            if (status) {
-                status = status.filter(item => item.type >= types_1.STATUS_TYPE.FATAL && item.type <= types_1.STATUS_TYPE.WARN);
-            }
+            status && (status = status.filter(item => item.type >= types_1.STATUS_TYPE.FATAL && item.type <= types_1.STATUS_TYPE.WARN));
             watch.send(types_1.WATCH_EVENT.MODIFIED, {
                 action: pathname && watch.hot && !watch.main ? 'hot' : '',
                 type: asset.mimeType,
@@ -1924,12 +1969,12 @@ class ChromeDocument extends Document {
                 }
             }
             if (productionRelease) {
-                const { imported, inlineUrl: inlineUrl, inlineUrlCloud: inlineUrlCloud } = item;
+                const { inlineUrl, inlineUrlCloud, imported, hash } = item;
                 if (inlineUrl || inlineUrlCloud) {
-                    const filename = createHash(host, item, bufferMap);
+                    const filename = hash && createHash(host, item, hash, bufferMap);
                     if (filename) {
-                        for (const hash of this.assets) {
-                            const url = inlineUrl ? hash.inlineUrlMap?.[inlineUrl] : hash.inlineUrlCloudMap?.[inlineUrlCloud];
+                        for (const asset of this.assets) {
+                            const url = inlineUrl ? asset.inlineUrlMap?.[inlineUrl] : asset.inlineUrlCloudMap?.[inlineUrlCloud];
                             if (url) {
                                 const search = url.indexOf('?');
                                 const index = (search !== -1 ? url.substring(0, search) : url).lastIndexOf('/');
@@ -1942,17 +1987,17 @@ class ChromeDocument extends Document {
                                     result += url.substring(search);
                                 }
                                 if (inlineUrl) {
-                                    hash.inlineUrlMap[inlineUrl] = result;
+                                    asset.inlineUrlMap[inlineUrl] = result;
                                 }
                                 else {
-                                    hash.inlineUrlCloudMap[inlineUrlCloud] = result;
+                                    asset.inlineUrlCloudMap[inlineUrlCloud] = result;
                                 }
                             }
                         }
                     }
                     hashed.add(item);
                 }
-                else if ((!item.editing || imported) && createHash(host, item, bufferMap)) {
+                else if (hash && (!item.editing || imported) && createHash(host, item, hash, bufferMap)) {
                     hashed.add(item);
                 }
             }
@@ -1999,15 +2044,16 @@ class ChromeDocument extends Document {
                 item.modified = true;
             }
             source = sanitizeSource(item, source);
-            if (item.format) {
-                const result = await this.transform('html', source, item.format, transformOptions.call(this, item, 'image/svg+xml'));
+            const format = item.format;
+            if (format) {
+                const result = await this.transform('html', source, format, transformOptions.call(this, item, 'image/svg+xml'));
                 if (result) {
                     item.modified = true;
                     source = result.code;
                 }
             }
             item.sourceUTF8 = source;
-            if (productionRelease && !hashed.has(item) && createHash(host, item, bufferMap)) {
+            if (productionRelease && item.hash && !hashed.has(item) && createHash(host, item, item.hash, bufferMap)) {
                 hashed.add(item);
             }
         }
@@ -2110,11 +2156,12 @@ class ChromeDocument extends Document {
         await this.setElementAttributes(processing, domBase);
         await this.applyDataSource(processing, domBase);
         for (const item of this.assets) {
-            if (item.element && isRemoved(item) && !(0, types_1.ignoreFlag)(item.flags)) {
-                const domElement = new dom_1.HtmlElement(moduleName, item.element, item.attributes);
+            const element = item.element;
+            if (element && isRemoved(item) && !(0, types_1.ignoreFlag)(item.flags)) {
+                const domElement = new dom_1.HtmlElement(moduleName, element, item.attributes);
                 domElement.remove = true;
                 if (!domBase.write(domElement)) {
-                    this.writeFail('Unable to exclude HTML element', errorHtml(item.element), 4 /* LOG_TYPE.PROCESS */);
+                    this.writeFail('Unable to exclude HTML element', errorHtml(element), 4 /* LOG_TYPE.PROCESS */);
                 }
             }
         }
@@ -2135,13 +2182,15 @@ class ChromeDocument extends Document {
         if ((0, types_1.isString)(config.stripCommentsAndCDATA)) {
             source = dom_1.DomWriter.getCommentsAndCDATA(source, config.stripCommentsAndCDATA, true, true);
         }
-        if (htmlFile.format) {
-            const result = await this.transform('html', source, htmlFile.format, {
+        const format = htmlFile.format;
+        if (format) {
+            const { filename, uri, encoding, metadata } = htmlFile;
+            const result = await this.transform('html', source, format, {
                 pathname: path.dirname(localUri),
-                filename: htmlFile.filename,
+                filename,
                 mimeType: 'text/html',
-                metadata: Object.assign({ '__fromhtml__': true, ...this.config }, htmlFile.metadata),
-                cacheData: !productionRelease || this.productionIncremental ? { uri: htmlFile.uri, encoding: htmlFile.encoding } : undefined
+                metadata: Object.assign({ '__fromhtml__': true, ...this.config }, metadata),
+                cacheData: !productionRelease || this.productionIncremental ? { uri, encoding } : undefined
             });
             if (result) {
                 source = result.code;
@@ -2175,12 +2224,12 @@ class ChromeDocument extends Document {
         const cloud = host.Cloud;
         const removeWatchReload = (item) => (0, types_1.isObject)(item.watch) && delete item.watch.reload;
         for (const item of this.assets) {
-            const element = item.element;
+            const { element, inlineContent } = item;
             if (!element || element.removed || isRemoved(item) || isUnedited(item) || (0, types_1.ignoreFlag)(item.flags) && !(0, types_1.processFlag)(item.flags)) {
                 continue;
             }
             const domElement = new dom_1.HtmlElement(moduleName, element, item.attributes);
-            if (item.inlineContent) {
+            if (inlineContent) {
                 let [innerXml, sourceMappingURL, inlineMap] = transform_1.SourceMap.removeSourceMappingURL(host.getUTF8String(item).trim());
                 if (sourceMappingURL && !inlineMap && item.localUri) {
                     let mapUri = path.resolve(sourceMappingURL = decodeURIComponent(sourceMappingURL));
@@ -2189,7 +2238,7 @@ class ChromeDocument extends Document {
                     }
                     host.deleteFile(mapUri);
                 }
-                domElement.tagName = item.inlineContent;
+                domElement.tagName = inlineContent;
                 domElement.innerXml = innerXml;
                 domElement.removeAttribute('src', 'href');
             }
@@ -2279,10 +2328,10 @@ class ChromeDocument extends Document {
                 }
             }
             if (!domBase.write(domElement)) {
-                this.writeFail(item.inlineContent ? 'Inline tag replacement' : 'Element attribute replacement', errorHtml(element), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
+                this.writeFail(inlineContent ? 'Inline tag replacement' : 'Element attribute replacement', errorHtml(element), { type: 4 /* LOG_TYPE.PROCESS */, startTime });
                 delete item.inlineUrlCloud;
             }
-            else if (item.inlineContent) {
+            else if (inlineContent) {
                 host.removeAsset(item);
                 removeWatchReload(item);
             }
@@ -2309,7 +2358,7 @@ class ChromeDocument extends Document {
         };
         const errorCredential = (item, err) => {
             removeElement(item);
-            const pkg = getPackageName(err, item.source);
+            const pkg = getPackageName(err);
             if (!(pkg && this.checkPackage(err, pkg))) {
                 this.writeFail(["Invalid credentials" /* ERR_DB.CREDENTIALS */, item.source], err);
             }
@@ -2421,13 +2470,13 @@ class ChromeDocument extends Document {
                     const length = batch.length;
                     const current = batch[0];
                     const type = current.source;
-                    let result = new Array(length);
+                    let result = new Array(length), errors;
                     switch (type) {
                         case 'cloud':
                             result = await cloud.getDatabaseBatchRows(batch, true, sessionKey).catch(err => {
                                 this.abort(type);
                                 if (err instanceof Error) {
-                                    cloud.addLog(this.aborted ? types_1.STATUS_TYPE.ERROR : types_1.STATUS_TYPE.WARN, err);
+                                    cloud.addLog(this.aborted ? types_1.STATUS_TYPE.ERROR : types_1.STATUS_TYPE.WARN, errors = err);
                                 }
                                 return [];
                             });
@@ -2593,9 +2642,7 @@ class ChromeDocument extends Document {
                                     }
                                     if (!getData) {
                                         const { settings, encoding, persist = true } = current;
-                                        if (!target) {
-                                            target = settings && this.settings.export?.[settings] || pathname;
-                                        }
+                                        target || (target = settings && this.settings.export?.[settings] || pathname);
                                         if (typeof target === 'function') {
                                             getData = target;
                                             hint = target.name;
@@ -2683,7 +2730,7 @@ class ChromeDocument extends Document {
                                                                 search.schema = loadLocalFile.call(this, current, pathname, cacheData, cmd.encoding);
                                                             }
                                                             catch (err) {
-                                                                this.writeFail(['Unable to parse document', path.basename(pathname)], err, { startTime });
+                                                                this.writeFail(['Unable to parse document', path.basename(pathname)], err instanceof Error ? errors = err : err, { startTime });
                                                                 search.schema = undefined;
                                                             }
                                                         }
@@ -2769,7 +2816,7 @@ class ChromeDocument extends Document {
                                             this.abort(type);
                                         }
                                         if (err) {
-                                            this.writeFail(["Unable to execute query" /* ERR_DB.EXEC_QUERY */, message || "Unknown" /* ERR_MESSAGE.UNKNOWN */], err, { type: 65536 /* LOG_TYPE.DB */, startTime });
+                                            this.writeFail(["Unable to execute query" /* ERR_DB.EXEC_QUERY */, message || "Unknown" /* ERR_MESSAGE.UNKNOWN */], err instanceof Error ? errors = err : err, { type: 65536 /* LOG_TYPE.DB */, startTime });
                                         }
                                         return this.aborted;
                                     };
@@ -2778,7 +2825,7 @@ class ChromeDocument extends Document {
                                 }
                                 catch (err) {
                                     this.abort(type);
-                                    const pkg = getPackageName(err, type);
+                                    const pkg = getPackageName(err);
                                     errorClient(current, pkg && this.checkPackage(err, pkg) ? null : err);
                                 }
                                 break;
@@ -2822,7 +2869,7 @@ class ChromeDocument extends Document {
                         if (items.length && !item.transactionFail) {
                             const { element, preRender } = item;
                             const domElement = new dom_1.HtmlElement(moduleName, element);
-                            let errors, value = '';
+                            let value = '';
                             const checkValue = async (name) => {
                                 const data = await checkData.call(this, item, name, value, row => typeof row === 'string');
                                 if (data) {
@@ -2879,7 +2926,7 @@ class ChromeDocument extends Document {
                                                 for (let j = 0, match; j < items.length; ++j) {
                                                     const row = items[j];
                                                     if ((0, types_1.isPlainObject)(row)) {
-                                                        row['__index__'] ?? (row['__index__'] = j + 1);
+                                                        row.__index__ ?? (row.__index__ = j + 1);
                                                     }
                                                     let segment = template;
                                                     while (match = REGEXP_TEMPLATECONDITIONAL.exec(segment)) {
@@ -2911,7 +2958,7 @@ class ChromeDocument extends Document {
                                                     else {
                                                         const pattern = /\$\{\s*([^\s}]+)\s*\}/g;
                                                         while (match = pattern.exec(segment)) {
-                                                            segment = replaceMatch(match, segment, match[1] === '__index__' && !(0, types_1.isObject)(row) ? (j + 1).toString() : valueAsString(getObjectValue(row, match[1]), ', '), pattern);
+                                                            segment = replaceMatch(match, segment, match[1] === "__index__" /* PROPERTIES.INDEX */ && !(0, types_1.isObject)(row) ? (j + 1).toString() : valueAsString(getObjectValue(row, match[1]), ', '), pattern);
                                                         }
                                                     }
                                                     value += trimTemplate(segment);
@@ -3118,7 +3165,10 @@ class ChromeDocument extends Document {
                         }
                         else {
                             if (!empty && item.type !== 'display' || item.transactionFail) {
-                                const emptyResponse = (value, service = item.source) => errorDataSource(service + ' -> Empty', value || "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+                                const emptyResponse = (value, service = item.source) => {
+                                    value || (value = "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+                                    return errors instanceof Error ? (0, types_1.errorMessage)(service, value, errors.message) : errorDataSource(service + ' -> Empty', value);
+                                };
                                 switch (item.source) {
                                     case 'cloud': {
                                         const { service, table, id, query } = item;
@@ -3166,8 +3216,8 @@ class ChromeDocument extends Document {
             if (isIgnored(item, true)) {
                 continue;
             }
-            if (!hashed.has(item)) {
-                createHash(host, item, bufferMap);
+            if (item.hash && !hashed.has(item)) {
+                createHash(host, item, item.hash, bufferMap);
             }
             switch (item.element?.tagName.toLowerCase()) {
                 case 'style':
@@ -3208,12 +3258,13 @@ class ChromeDocument extends Document {
             }
         }
     }
-    removeUnusedStyles(source, { useUnsafeCssReplace, usedVariables, usedFontFace, usedKeyframes, unusedStyles, unusedMedia, unusedContainer, unusedSupports } = this.config) {
+    removeUnusedStyles(source, { useUnsafeCssReplace, usedVariables, usedFontFace, usedKeyframes, unusedStyles, unusedMedia, unusedContainer, unusedSupports, useSessionCache } = this.config) {
         var _a;
         if (!usedVariables && !usedFontFace && !usedKeyframes && !unusedStyles && !unusedMedia && !unusedContainer && !unusedSupports) {
             return;
         }
-        const selectorMap = this._selectorMap;
+        const queryMap = useSessionCache ? CACHE_QUERY : this._queryMap;
+        const selectorMap = useSessionCache ? CACHE_SELECTOR : this._selectorMap;
         const replaceMap = [];
         const getStringSome = () => useUnsafeCssReplace ? '\\s*' : PATTERN_STRING_SOME;
         const getStringMany = () => useUnsafeCssReplace ? '\\s+' : PATTERN_STRING_MANY;
@@ -3310,17 +3361,17 @@ class ChromeDocument extends Document {
                         return `[${capture[1]}]`;
                 }
             });
-            for (let i = 0; i < items.length; ++i) {
+            for (let i = 0, length = revised.length; i < length; ++i) {
                 selector = selector.replace('`%' + i + '`', items[i]);
             }
-            return selector.replace(/[ ]+/g, getStringMany()) + getStringSome();
+            return selector.replace(/ +/g, getStringMany()) + getStringSome();
         };
         const replaceUnunsed = (name, items) => {
             for (let value of items) {
                 const key = name + '_' + (value = value.trim()) + (useUnsafeCssReplace ? '_1' : '');
-                let [pattern] = selectorMap[key] || [], selector = '', rule;
+                let pattern = queryMap.get(key), rule;
                 if (!pattern) {
-                    let flags = 'gi', revised;
+                    let flags = 'gi', selector = '', revised;
                     if (name === 'container') {
                         for (let i = 0, length = value.length, casing = true; i < length; i++) {
                             let ch = value[i];
@@ -3356,27 +3407,25 @@ class ChromeDocument extends Document {
                             .replace(/\s*(\\[()])\s*/g, (...capture) => getStringSome() + capture[1] + getStringSome())
                             .replace(/:\s+/g, getStringSome() + ':' + getStringSome())
                             .replace(/\s+([<>/]|<=|>=|\\\*)\s+/g, (...capture) => getStringSome() + capture[1] + getStringSome())
-                            .replace(/[ ]+/g, getStringMany());
+                            .replace(/ +/g, getStringMany());
                         if (flags === 'g') {
                             selector = selector.replace(/`([a-z][A-Z])`/g, (...capture) => `[${capture[1]}]`);
                         }
                     }
                     pattern = new RegExp('(\\s*)@' + (flags === 'g' ? name.split('').map(ch => `[${ch + ch.toUpperCase()}]`).join('') : name) + getStringMany() + selector + getStringSome() + '{', flags);
+                    queryMap.set(key, pattern);
                 }
                 else {
                     pattern.lastIndex = 0;
                 }
                 while (rule = pattern.exec(current)) {
-                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(rule));
+                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(rule), '{');
                     if (endIndex !== -1) {
                         current = spliceSource(current, rule.index, endIndex, pattern, rule[1], trailing);
                         (checkEmpty || (checkEmpty = {}))[name] = true;
                         modified = true;
                     }
                 }
-                if (selector) {
-                    selectorMap[key] = [pattern];
-                }
             }
         };
         if (!useUnsafeCssReplace) {
@@ -3415,41 +3464,110 @@ class ChromeDocument extends Document {
             replaceUnunsed('container', unusedContainer);
         }
         if (unusedStyles) {
-            for (const value of unusedStyles) {
-                const key = value + (useUnsafeCssReplace ? '_1' : '');
-                let [single, group] = selectorMap[key] || [], selector;
-                if (!single || !group) {
-                    single = new RegExp(`(}|^)(${getStringSome()})(?<!@[^}]*)${selector = parseSelector(value)}\\{([^}]*)\\}` + dom_1.DomWriter.PATTERN_TRAILINGSPACE, 'g');
-                    group = new RegExp(`((?:}|^)[^{]*?)((?:,${getStringSome()}|(?<!@[^}]*))${selector})(,[^{]*)?\\{`, 'g');
-                }
-                else {
-                    single.lastIndex = 0;
-                    group.lastIndex = 0;
-                }
-                while ((match = single.exec(current)) && match[3].indexOf('{') === -1) {
-                    current = spliceSource(current, match.index, getEndIndex(match), single, match[2], match[4], match[1] || '');
-                    modified = true;
-                }
-                while (match = group.exec(current)) {
-                    const opening = match.index + match[0].length;
-                    const closing = current.indexOf('}', opening);
-                    if (closing !== -1 && current.substring(opening, closing).indexOf('{') === -1) {
-                        const middle = match[2][0] === ',';
-                        const leading = middle ? match[1].trimEnd() : match[1];
-                        const trailing = match[3];
-                        const segment = trailing ? (!middle ? (!isSpace(leading[leading.length - 1]) ? ' ' : '') + trailing.substring(1).trimStart() : trailing).trimEnd() : '';
-                        current = replaceMatch(match, current, leading + segment + ' {');
-                        group.lastIndex = match.index;
-                        modified = true;
+            current = (function recurse(target, child) {
+                let output = '', index = 0, pendingStart = 0, pendingEnd = 0, found = -1;
+                while ((found = target.indexOf('{', index)) !== -1) {
+                    ++found;
+                    const closing = findClosingIndex(target, found, '{')[0];
+                    if (closing === -1) {
+                        break;
+                    }
+                    let header = target.substring(index, found), invalid = 0, content;
+                    for (const value of unusedStyles) {
+                        const key = value + (child ? '_1' : '') + (useUnsafeCssReplace ? '_2' : '');
+                        const pattern = selectorMap.get(key);
+                        let single, group;
+                        if (!pattern) {
+                            const selector = parseSelector(value) + (child ? `(?:${getStringSome()}&${getStringSome()})*` : '');
+                            single = new RegExp(`(^|;)(${getStringSome()})(?<!${child ? '&|' : ''}@[^};]*)${selector}\\{$`);
+                            group = new RegExp(`((?:^|;)[^{]*?${getStringSome()}(,${getStringSome()}|(?<!@[^};]*)))(${(child ? '(?:&\\s+|(?<!&))' : '') + selector})(,[^{]*)?\\{$`, 'g');
+                            selectorMap.set(key, [single, group]);
+                        }
+                        else {
+                            [single, group] = pattern;
+                        }
+                        if (match = single.exec(header)) {
+                            content = match[1] === ';' ? header.substring(0, match.index + 1) + match[2].replace(/[^\n]+$/, '') : undefined;
+                            invalid = 1;
+                            break;
+                        }
+                        let leading = -1, first = true;
+                        while (match = group.exec(header)) {
+                            const start = match.index + match[1].length;
+                            if (!child && first) {
+                                if (match[1].trimEnd().endsWith(';')) {
+                                    leading = start;
+                                }
+                                first = false;
+                            }
+                            const sibling = match[2][0] === ',';
+                            const trailing = match[4];
+                            const offset = trailing && !sibling ? /^,\s*/.exec(trailing)[0].length : 1;
+                            header = header.substring(0, start - (sibling ? match[2].length : 0)) + header.substring(start + match[3].length + (trailing ? sibling ? 0 : offset : /\s$/.test(match[3]) ? -1 : 0));
+                            group.lastIndex = match.index;
+                            invalid = 2;
+                        }
+                        if (invalid) {
+                            group.lastIndex = 0;
+                            const empty = /(.)\s*{$/.exec(header);
+                            if (empty) {
+                                if (header.trim() === '{') {
+                                    content = undefined;
+                                    invalid = 1;
+                                    break;
+                                }
+                                else if (leading !== -1 && empty[1] === ';') {
+                                    content = target.substring(index, found).substring(0, leading).replace(/[^\n;]+$/, '');
+                                    invalid = 1;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (invalid === 0 || invalid === 2) {
+                        const trailing = target.substring(found, closing);
+                        if (content = recurse(trailing, true)) {
+                            content = header + content;
+                        }
+                        else if (invalid === 2) {
+                            content = header + trailing;
+                        }
+                    }
+                    if (content) {
+                        if (pendingEnd) {
+                            output = target.substring(pendingStart, pendingEnd) + content;
+                            pendingEnd = 0;
+                        }
+                        else {
+                            output += content;
+                        }
+                    }
+                    else if (!invalid) {
+                        if (output) {
+                            output += target.substring(index, closing);
+                        }
+                        else {
+                            pendingEnd = closing;
+                        }
+                    }
+                    else if (pendingEnd) {
+                        output = target.substring(pendingStart, pendingEnd);
+                        pendingEnd = 0;
                     }
+                    else {
+                        pendingStart = closing;
+                    }
+                    index = closing;
                 }
-                if (selector) {
-                    selectorMap[key] = [single, group];
+                if (output) {
+                    modified = true;
+                    return output + target.substring(index);
                 }
-            }
+                return !child ? target : '';
+            })(current, false);
         }
         if (usedVariables) {
-            const pattern = useUnsafeCssReplace ? REGEXP_VARIABLES_UNSAFE : REGEXP_VARIABLES;
+            let pattern = useUnsafeCssReplace ? REGEXP_VARIABLES_UNSAFE : REGEXP_VARIABLES;
             while (match = pattern.exec(current)) {
                 if (!usedVariables.includes(match[2])) {
                     current = replaceMatch(match, current, match[3] === ';' ? getNewlineString(match[1], match[4]) : '', pattern);
@@ -3457,24 +3575,35 @@ class ChromeDocument extends Document {
                 }
             }
             pattern.lastIndex = 0;
+            pattern = useUnsafeCssReplace ? REGEXP_PROPERTY_UNSAFE : REGEXP_PROPERTY;
+            while (match = pattern.exec(current)) {
+                if (!usedVariables.includes(match[2])) {
+                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match), '{');
+                    if (endIndex !== -1) {
+                        current = spliceSource(current, match.index, endIndex, pattern, match[1], trailing);
+                        modified = true;
+                    }
+                }
+            }
+            pattern.lastIndex = 0;
         }
         if (usedFontFace) {
-            const fontFace = useUnsafeCssReplace ? REGEXP_FONTFACE_UNSAFE : REGEXP_FONTFACE;
+            const pattern = useUnsafeCssReplace ? REGEXP_FONTFACE_UNSAFE : REGEXP_FONTFACE;
             const fontFamily = useUnsafeCssReplace ? REGEXP_FONTFAMILY_UNSAFE : REGEXP_FONTFAMILY;
-            while (match = fontFace.exec(current)) {
+            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]))) {
-                    current = spliceSource(current, match.index, getEndIndex(match), fontFace, match[1], match[3]);
+                    current = spliceSource(current, match.index, getEndIndex(match), pattern, match[1], match[3]);
                     modified = true;
                 }
             }
-            fontFace.lastIndex = 0;
+            pattern.lastIndex = 0;
         }
         if (usedKeyframes) {
             const pattern = useUnsafeCssReplace ? REGEXP_KEYFRAMES_UNSAFE : REGEXP_KEYFRAMES;
             while (match = pattern.exec(current)) {
                 if (!usedKeyframes.includes(match[2].trim())) {
-                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match));
+                    const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match), '{');
                     if (endIndex !== -1) {
                         current = spliceSource(current, match.index, endIndex, pattern, match[1], trailing);
                         modified = true;
@@ -3529,7 +3658,9 @@ class ChromeDocument extends Document {
         return this._editing;
     }
     set dataSource(value) {
-        this._dataSource = value;
+        if (Array.isArray(value)) {
+            this._dataSource = value;
+        }
     }
     get dataSource() {
         const result = this._dataSource;
@@ -3552,7 +3683,7 @@ class ChromeDocument extends Document {
         return (_a = this.module).settings || (_a.settings = {});
     }
 }
-ChromeDocument.INTERNAL_ASSIGNUUID = '__assign__';
-ChromeDocument.INTERNAL_SERVERROOT = '__serverroot__';
+ChromeDocument.INTERNAL_ASSIGNUUID = "__assign__" /* PROPERTIES.ASSIGN */;
+ChromeDocument.INTERNAL_SERVERROOT = "__serverroot__" /* PROPERTIES.SERVERROOT */;
 
 module.exports = ChromeDocument;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/chrome",
-  "version": "0.2.2",
+  "version": "0.5.0",
   "description": "Chrome document constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -20,9 +20,9 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.5.3",
-    "@e-mc/core": "^0.5.3",
-    "@e-mc/document": "^0.5.3",
-    "@e-mc/types": "^0.5.3"
+    "@e-mc/cloud": "^0.7.0",
+    "@e-mc/core": "^0.7.0",
+    "@e-mc/document": "^0.7.0",
+    "@e-mc/types": "^0.7.0"
   }
 }

package/types/index.d.ts

@@ -10,6 +10,13 @@ import type { IDomWriter, IXmlElement } from '@e-mc/document/parse/types';
 
 import type { ChromeAsset, CssRuleData, DataSource, DocumentOutput } from './squared';
 
+export const enum PROPERTIES {
+    INDEX = '__index__',
+    FROM_HTML = '__fromhtml__',
+    ASSIGN = '__assign__',
+    SERVERROOT = '__serverroot__'
+}
+
 interface DocumentDirectory extends IDocumentDirectory {
     template?: string;
     data?: string;
@@ -104,10 +111,11 @@ export interface IChromeDocument<T extends IFileManager<U>, U extends DocumentAs
     cloudObject(state: CloudScopeOrigin<T, U, V>, file: U): boolean;
     cloudUpload(state: CloudScopeOrigin<T, U, V>, file: U, url: string, active: boolean): Promise<boolean>;
     cloudFinalize(state: CloudScopeOrigin<T, U, V>): Promise<unknown[]>;
-    get settings(): ChromeDocumentSettings;
     get editing(): U[];
+    set dataSource(value);
     get dataSource(): DataSource[];
     get elements(): XmlTagNode[];
+    get settings(): ChromeDocumentSettings;
 }
 
 export interface ChromeDocumentConstructor<T extends IFileManager<U>, U extends DocumentAsset = DocumentAsset> extends DocumentConstructor<T, U> {

package/types/squared.d.ts

@@ -29,6 +29,7 @@ export interface DocumentOutput {
     productionIncremental?: boolean;
     useOriginalHtmlPage?: boolean | string;
     useUnsafeReplace?: ArrayOf<"html" | "css"> | boolean;
+    useSessionCache?: boolean;
     stripCommentsAndCDATA?: boolean | string;
     normalizeHtmlOutput?: boolean | string;
     escapeReservedCharacters?: boolean;