@dooboostore/simple-boot-http-server-ssr 1.0.12 → 1.0.13

package/dist/esm-bundle/dooboostore-simple-boot-http-server-ssr.esm.js

@@ -30,9 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/node-gzip@1.1.2/node_modules/node-gzip/dist/index.js
+// ../../../node_modules/.pnpm/node-gzip@1.1.2/node_modules/node-gzip/dist/index.js
 var require_dist = __commonJS({
-  "../../node_modules/.pnpm/node-gzip@1.1.2/node_modules/node-gzip/dist/index.js"(exports, module) {
+  "../../../node_modules/.pnpm/node-gzip@1.1.2/node_modules/node-gzip/dist/index.js"(exports, module) {
     "use strict";
     var zlib = __require("zlib");
     module.exports = {
@@ -945,7 +945,7 @@ var ObjectUtils;
         const func = new Function("window", "document", "console", `"use strict"; ${script}; `);
         func.call(destUser, globalContext.window, globalContext.document, globalContext.console);
       } catch (e) {
-        console.error("detectPathFromScript error:", e);
+        console.error("detectPathFromScript error:", script, e);
       }
       if (options?.excludeThis) {
         const filteredVars = /* @__PURE__ */ new Set();
@@ -1077,117 +1077,6 @@ var getStorage = (window2) => {
   return window2.aroundStorage;
 };
 
-// ../core/dist/esm/string/StringUtils.js
-var StringUtils;
-((StringUtils2) => {
-  StringUtils2.deleteEnter = (data) => {
-    return data.replace(/\r?\n/g, "");
-  };
-  StringUtils2.pickEmoji = (data) => {
-    return data.match(/[\p{Emoji}]/gu) ?? [];
-  };
-  StringUtils2.regexExec = (regex, text) => {
-    let varExec = regex.exec(text);
-    const usingVars = [];
-    while (varExec) {
-      usingVars.push(varExec);
-      varExec = regex.exec(varExec.input);
-    }
-    return usingVars;
-  };
-  StringUtils2.regexExecArrayReplace = (origin, regexpExecArrayOrRegex, replace) => {
-    const regexpExecArrays = Array.isArray(regexpExecArrayOrRegex) ? regexpExecArrayOrRegex : StringUtils2.regexExec(regexpExecArrayOrRegex, origin);
-    regexpExecArrays.reverse().forEach((it) => {
-      const r = typeof replace === "string" ? replace : replace(it);
-      origin = origin.substr(0, it.index) + origin.substr(it.index).replace(it[0], r);
-    });
-    return origin;
-  };
-  StringUtils2.escapeSpecialCharacterRegExp = (data) => {
-    return data.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  };
-  StringUtils2.trim = (data) => data.trim();
-  StringUtils2.rsubString = (data_s, blen_n) => data_s.substring(data_s.length - blen_n, data_s.length);
-  StringUtils2.lsubString = (data_s, alen_n) => data_s.substring(0, alen_n);
-  StringUtils2.lpad = (fill_s, len_n, full_s) => {
-    while (len_n > full_s.length) {
-      full_s = fill_s + full_s;
-    }
-    return StringUtils2.rsubString(full_s, len_n);
-  };
-  StringUtils2.rpad = (fill_s, len_n, full_s) => {
-    while (len_n > full_s.length) {
-      full_s += fill_s;
-    }
-    return StringUtils2.lsubString(full_s, len_n);
-  };
-  StringUtils2.lappend = (count_n, input_s) => {
-    let s = "";
-    let i = 0;
-    while (i++ < count_n) {
-      s += input_s;
-    }
-    return s;
-  };
-  StringUtils2.unescape = (html) => {
-    if (!html) return "";
-    const htmlEntity = {
-      quot: '"',
-      amp: "&",
-      apos: "'",
-      lt: "<",
-      gt: ">",
-      nbsp: "\xA0",
-      iexcl: "\xA1",
-      cent: "\xA2",
-      pound: "\xA3",
-      curren: "\xA4",
-      yen: "\xA5",
-      brvbar: "\xA6",
-      sect: "\xA7",
-      uml: "\xA8",
-      copy: "\xA9",
-      ordf: "\xAA",
-      laquo: "\xAB",
-      not: "\xAC",
-      shy: "\xAD",
-      reg: "\xAE",
-      macr: "\xAF",
-      deg: "\xB0",
-      plusmn: "\xB1",
-      sup2: "\xB2",
-      sup3: "\xB3",
-      acute: "\xB4",
-      micro: "\xB5",
-      para: "\xB6",
-      middot: "\xB7",
-      cedil: "\xB8",
-      sup1: "\xB9",
-      ordm: "\xBA",
-      raquo: "\xBB",
-      frac14: "\xBC",
-      frac12: "\xBD",
-      frac34: "\xBE",
-      iquest: "\xBF",
-      "#x27": "'"
-    };
-    return html.replace(/&((?:(?:[a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});?)+);/gi, (match, entity) => {
-      const entities = entity.toLowerCase().split(";");
-      return entities.map((it) => it in htmlEntity ? htmlEntity[it] : match).join("");
-    });
-  };
-  StringUtils2.executeExpression = (formatString, object) => {
-    return formatString.replace(/\${([^{}]*)}/g, (matched, piece) => String(object[piece] ?? matched));
-  };
-  StringUtils2.ellipsis = (text, length) => {
-    if (text.length > length) return `${text.slice(0, length)}...`;
-    return text;
-  };
-  StringUtils2.appendPostposition = (text, { vowel, consonant }) => {
-    return `${text}${ValidUtils.lastConsonantLetter(text) ? consonant : vowel}`;
-  };
-})(StringUtils || (StringUtils = {}));
-
 // ../core/dist/esm/expression/Expression.js
 var Expression;
 ((Expression2) => {
@@ -1202,17 +1091,6 @@ var Expression;
       return binder;
     });
   };
-  let Group;
-  ((Group2) => {
-    Group2.isExpression = (data) => {
-      const reg = /[$#]\{([\s\S.]*?)\}[$#]/g;
-      return reg.test(data ?? "");
-    };
-    Group2.expressionGroups = (data) => {
-      const reg = /[$#]\{([\s\S.]*?)\}[$#]/g;
-      return StringUtils.regexExec(reg, data ?? "");
-    };
-  })(Group = Expression2.Group || (Expression2.Group = {}));
   let Path;
   ((Path2) => {
     Path2.pathNameData = (pathName, urlExpression) => {
@@ -2841,6 +2719,74 @@ var ConvertUtils;
   ConvertUtils22.decodeHTMLEscape = (data) => {
     return data.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x2F;/g, "/");
   };
+  function escapeHTML(htmlString, option) {
+    if (!htmlString) return "";
+    const escapeMap = {
+      "&": "&amp;",
+      // 반드시 먼저 처리
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;",
+      // or &apos; (하지만 HTML4에서는 &#39; 권장)
+      "/": "&#x2F;",
+      "`": "&#x60;",
+      "=": "&#x3D;",
+      "{": "&#123;",
+      "}": "&#125;",
+      "#": "&#35;",
+      "$": "&#36;",
+      "\n": "&#10;",
+      // newline
+      "\r": "&#13;",
+      // carriage return
+      "	": "&#9;",
+      // tab
+      "\xA0": "&nbsp;",
+      // non-breaking space
+      "\xA2": "&cent;",
+      "\xA3": "&pound;",
+      "\xA5": "&yen;",
+      "\u20AC": "&euro;",
+      "\xA9": "&copy;",
+      "\xAE": "&reg;",
+      "\u2122": "&trade;",
+      "\xB0": "&deg;",
+      "\xB1": "&plusmn;",
+      "\xD7": "&times;",
+      "\xF7": "&divide;",
+      "\u2212": "&minus;",
+      "\u2022": "&bull;",
+      "\u2026": "&hellip;",
+      "\u2190": "&larr;",
+      "\u2192": "&rarr;",
+      "\u2191": "&uarr;",
+      "\u2193": "&darr;",
+      "\u2194": "&harr;"
+    };
+    const targetsSet = option?.targets ? new Set(option.targets) : null;
+    const filteredEscapeMap = targetsSet ? Object.fromEntries(Object.entries(escapeMap).filter(([key]) => targetsSet.has(key))) : escapeMap;
+    const shouldEscapeAmpersand = !targetsSet || targetsSet.has("&");
+    const charsToEscape = Object.keys(filteredEscapeMap).filter((char) => char !== "&");
+    if (charsToEscape.length === 0 && !shouldEscapeAmpersand) {
+      return htmlString;
+    }
+    const escapedChars = charsToEscape.map((char) => {
+      return char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    let result = htmlString;
+    if (shouldEscapeAmpersand) {
+      result = result.replace(/&/g, "&amp;");
+    }
+    if (escapedChars.length > 0) {
+      const regex = new RegExp(`[${escapedChars}]`, "g");
+      result = result.replace(regex, (match) => {
+        return filteredEscapeMap[match] || match;
+      });
+    }
+    return result;
+  }
+  ConvertUtils22.escapeHTML = escapeHTML;
   ConvertUtils22.copyObject = (obj, update = {}) => {
     return { ...obj, ...update };
   };
@@ -4550,6 +4496,138 @@ var NotFoundError = class extends HttpError {
   }
 };
 
+// ../core/dist/esm/string/StringUtils.js
+var StringUtils;
+(function(StringUtils2) {
+  StringUtils2.deleteEnter = (data) => {
+    return data.replace(/\r?\n/g, "");
+  };
+  StringUtils2.pickEmoji = (data) => {
+    return data.match(/[\p{Emoji}]/gu) ?? [];
+  };
+  StringUtils2.regexExec = (regex, text) => {
+    let varExec = regex.exec(text);
+    const usingVars = [];
+    while (varExec) {
+      usingVars.push(varExec);
+      varExec = regex.exec(varExec.input);
+    }
+    return usingVars;
+  };
+  StringUtils2.escapeSpecialCharacterRegExp = (data) => {
+    return data.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  };
+  StringUtils2.trim = (data) => data.trim();
+  StringUtils2.rsubString = (data_s, blen_n) => data_s.substring(data_s.length - blen_n, data_s.length);
+  StringUtils2.lsubString = (data_s, alen_n) => data_s.substring(0, alen_n);
+  StringUtils2.lpad = (fill_s, len_n, full_s) => {
+    while (len_n > full_s.length) {
+      full_s = fill_s + full_s;
+    }
+    return StringUtils2.rsubString(full_s, len_n);
+  };
+  StringUtils2.rpad = (fill_s, len_n, full_s) => {
+    while (len_n > full_s.length) {
+      full_s += fill_s;
+    }
+    return StringUtils2.lsubString(full_s, len_n);
+  };
+  StringUtils2.lappend = (count_n, input_s) => {
+    let s = "";
+    let i = 0;
+    while (i++ < count_n) {
+      s += input_s;
+    }
+    return s;
+  };
+  StringUtils2.unescape = (html) => {
+    if (!html)
+      return "";
+    const htmlEntity = {
+      quot: '"',
+      amp: "&",
+      apos: "'",
+      lt: "<",
+      gt: ">",
+      nbsp: "\xA0",
+      iexcl: "\xA1",
+      cent: "\xA2",
+      pound: "\xA3",
+      curren: "\xA4",
+      yen: "\xA5",
+      brvbar: "\xA6",
+      sect: "\xA7",
+      uml: "\xA8",
+      copy: "\xA9",
+      ordf: "\xAA",
+      laquo: "\xAB",
+      not: "\xAC",
+      shy: "\xAD",
+      reg: "\xAE",
+      macr: "\xAF",
+      deg: "\xB0",
+      plusmn: "\xB1",
+      sup2: "\xB2",
+      sup3: "\xB3",
+      acute: "\xB4",
+      micro: "\xB5",
+      para: "\xB6",
+      middot: "\xB7",
+      cedil: "\xB8",
+      sup1: "\xB9",
+      ordm: "\xBA",
+      raquo: "\xBB",
+      frac14: "\xBC",
+      frac12: "\xBD",
+      frac34: "\xBE",
+      iquest: "\xBF",
+      "#x27": "'"
+    };
+    return html.replace(/&((?:(?:[a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});?)+);/gi, (match, entity) => {
+      const entities = entity.toLowerCase().split(";");
+      return entities.map((it) => it in htmlEntity ? htmlEntity[it] : match).join("");
+    });
+  };
+  StringUtils2.executeExpression = (formatString, object) => {
+    return formatString.replace(/\${([^{}]*)}/g, (matched, piece) => String(object[piece] ?? matched));
+  };
+  StringUtils2.ellipsis = (text, length) => {
+    if (text.length > length)
+      return `${text.slice(0, length)}...`;
+    return text;
+  };
+  StringUtils2.appendPostposition = (text, { vowel, consonant }) => {
+    return `${text}${ValidUtils.lastConsonantLetter(text) ? consonant : vowel}`;
+  };
+  StringUtils2.replaceSequentially = (text, replacements) => {
+    let remainingText = text;
+    let result = "";
+    while (remainingText.length > 0) {
+      let bestMatch = null;
+      for (const replacement of replacements) {
+        const newRegex = new RegExp(replacement.regex);
+        const match = newRegex.exec(remainingText);
+        if (match) {
+          if (bestMatch === null || match.index < bestMatch.index) {
+            bestMatch = { index: match.index, match, replacement };
+          }
+        }
+      }
+      if (bestMatch) {
+        const { index, match, replacement } = bestMatch;
+        const matchedString = match[0];
+        result += remainingText.substring(0, index);
+        result += replacement.callback(matchedString);
+        remainingText = remainingText.substring(index + matchedString.length);
+      } else {
+        result += remainingText;
+        break;
+      }
+    }
+    return result;
+  };
+})(StringUtils || (StringUtils = {}));
+
 // ../core-web/dist/esm/script/ScriptUtils.js
 var ScriptUtils = class _ScriptUtils {
   /**
@@ -4766,6 +4844,48 @@ var Promises;
     });
     return { promise, resolve, reject };
   };
+  Promises2.executeInChunks = async (promiseFactories, chunkSize = 10) => {
+    const results = [];
+    for (let i = 0; i < promiseFactories.length; i += chunkSize) {
+      const chunk = promiseFactories.slice(i, i + chunkSize);
+      const chunkResults = await Promise.all(chunk.map((factory) => factory()));
+      results.push(...chunkResults);
+      if (i + chunkSize < promiseFactories.length) {
+        await (0, Promises2.sleep)(100);
+      }
+    }
+    return results;
+  };
+  Promises2.executeWithConcurrency = async (promiseFactories, concurrency = 10) => {
+    const results = new Array(promiseFactories.length);
+    let currentIndex = 0;
+    const executeNext = async (index) => {
+      while (currentIndex < promiseFactories.length) {
+        const factoryIndex = currentIndex++;
+        results[factoryIndex] = await promiseFactories[factoryIndex]();
+      }
+    };
+    const workers = Array(Math.min(concurrency, promiseFactories.length)).fill(0).map((_, i) => executeNext(i));
+    await Promise.all(workers);
+    return results;
+  };
+  Promises2.executeWithLimit = async (promiseFactories, limit = 5) => {
+    const results = new Array(promiseFactories.length);
+    const executing = [];
+    for (const [index, factory] of promiseFactories.entries()) {
+      const promise = factory().then((result) => {
+        results[index] = result;
+      }).finally(() => {
+        executing.splice(executing.indexOf(promise), 1);
+      });
+      executing.push(promise);
+      if (executing.length >= limit) {
+        await Promise.race(executing);
+      }
+    }
+    await Promise.all(executing);
+    return results;
+  };
   let Result;
   ((Result2) => {
     async function awaitWrap(promise) {
@@ -5371,7 +5491,13 @@ var _EventManager = class _EventManager2 {
     this.procAttr(childNodes, _EventManager2.normalAttrMapAttrName, (it, attribute) => {
       const map = new Map(JSON.parse(attribute));
       map.forEach((v, k) => {
-        const data = ScriptUtils.evaluate(`const $element = this.element;  return ${v} `, Object.assign(obj, {
+        const variablePaths = v.variablePaths;
+        let targetScript = v.originalAttrValue;
+        variablePaths.forEach((it2) => {
+          let r = ObjectUtils.Path.toOptionalChainPath(it2.inner);
+          targetScript = targetScript.replaceAll(it2.origin, `\${${r}}`);
+        });
+        const data = ObjectUtils.Script.evaluate(`const $element = this.element;  return ${"`" + targetScript + "`"} `, Object.assign(obj, {
           __render: Object.freeze({
             element: it,
             attribute: ElementUtils.getAttributeToObject(it)
@@ -5561,7 +5687,7 @@ var _EventManager = class _EventManager2 {
     });
   }
   getValue(obj, name, bindObj) {
-    let r = ScriptUtils.evaluateReturn(name, obj);
+    let r = ObjectUtils.Script.evaluateReturn(name, obj);
     if (typeof r === "function") {
       r = r.bind(bindObj ?? obj);
     }
@@ -5661,6 +5787,7 @@ _EventManager.VARNAMES = [_EventManager.SCRIPTS_VARNAME, _EventManager.FAG_VARNA
 _EventManager.WINDOW_EVENT_POPSTATE = "popstate";
 _EventManager.WINDOW_EVENT_RESIZE = "resize";
 _EventManager.WINDOW_EVENTS = [_EventManager.WINDOW_EVENT_POPSTATE, _EventManager.WINDOW_EVENT_RESIZE];
+_EventManager.noDetectAttr = [_EventManager.normalAttrMapAttrName];
 _EventManager.attrNames = [
   _EventManager.valueAttrName,
   _EventManager.checkedAttrName,
@@ -5794,7 +5921,7 @@ var DrIf = class extends OperatorExecuterAttrRequire {
     const itRandom = RawSet.drItOtherEncoding(this.elementSource.element, "DrIf");
     const vars = RawSet.drVarEncoding(this.elementSource.element, this.elementSource.attrs.drVarOption ?? "");
     const newTemp = this.source.config.window.document.createElement("temp");
-    const keepgoing = ScriptUtils.evaluate(`
+    const keepgoing = ObjectUtils.Script.evaluate(`
                 ${this.render.bindScript}
                 ${this.elementSource.attrs.drBeforeOption ?? ""}
                 if ($rawSet.data === (${ObjectUtils.Path.toOptionalChainPath(attr)})) {
@@ -6307,7 +6434,7 @@ var DrInnerText = class extends OperatorExecuterAttrRequire {
   }
   async executeAttrRequire(attr) {
     const newTemp = this.source.config.window.document.createElement("temp");
-    ScriptUtils.evaluate(` 
+    ObjectUtils.Script.evaluate(` 
                         ${this.render.bindScript}
                         const n = $element.cloneNode(true);  
                         ${this.elementSource.attrs.drBeforeOption ?? ""}
@@ -6427,7 +6554,10 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
     const itRandom = RawSet.drItOtherEncoding(this.elementSource.element, "DrForOf");
     const vars = RawSet.drVarEncoding(this.elementSource.element, this.elementSource.attrs.drVarOption ?? "");
     const newTemp = this.source.config.window.document.createElement("temp");
-    ScriptUtils.evaluate(`
+    const variableName = this.elementSource.element.getAttribute(RawSet.DR_VARIABLE_NAME_OPTIONNAME);
+    const itemVariableName = this.elementSource.element.getAttribute(RawSet.DR_ITEM_VARIABLE_NAME_OPTIONNAME);
+    const itemIndexVariableName = this.elementSource.element.getAttribute(RawSet.DR_ITEM_INDEX_VARIABLE_NAME_OPTIONNAME);
+    ObjectUtils.Script.evaluate(`
                     ${this.render.bindScript}
                     ${this.elementSource.attrs.drBeforeOption ?? ""}
                     var i = -1; 
@@ -6450,11 +6580,18 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
                                 destIt = forOfStr + '[' + i +']'
                             }
                             const n = this.__render.element.cloneNode(true);
-                            // console.log('zzzzzzzzzzz', n.getAttribute('${RawSet.DR_DETECT_ATTR_OPTIONNAME}'));
                             Object.entries(this.__render.drAttr).filter(([k,v]) => k !== 'drForOf' && k !== 'drNextOption' && v).forEach(([k, v]) => n.setAttribute(this.__render.drAttrsOriginName[k], v));
-                            // console.log('---------'+destIt,n, Array.from(n.getAttributeNames()).map(it=>({name:it,attr: n.getAttribute(it)})));
-                            // console.log('---------destItdestIt',destIt);
                             n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replace(/\\#it\\#/g, destIt).replace(/\\#nearForOfIt\\#/g, destIt).replace(/\\#it\\#/g, destIt).replace(/\\#nearForOfIndex\\#/g, i)))
+                            if ('${variableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${variableName}#', forOfStr)));
+                            }
+                            if ('${itemVariableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${itemVariableName}#', destIt)));
+                            }
+                            if ('${itemIndexVariableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${itemIndexVariableName}#', i)));
+                            }
+                            
                             const drOptionAttr = n.getAttribute('${RawSet.DR_DETECT_ATTR_OPTIONNAME}');
                             if (drOptionAttr) {
                               const drOptionAttrResult = $scriptUtils.evaluateReturn(drOptionAttr, this);
@@ -6477,12 +6614,16 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
                             }
 
                             n.innerHTML = n.innerHTML.replace(/\\#it\\#/g, destIt).replace(/\\#index\\#/g, i);
-                            // console.log('!@@@@', n.innerHTML);
-                            // DR_THIS_OPTIONNAME \uB294 \uC81C\uAC70\uD55C\uB2E4 \uAF2C\uC778\uB2E4. strip \uD560\uB54C \uB9C9 \uAF2C\uC5EC\uBC84\uB9B0\uB2E4.
-                            // const drOptionThis = n.getAttribute('${RawSet.DR_THIS_OPTIONNAME}');
-                            // if (drOptionThis) {
-                            //  n.setAttribute('${RawSet.DR_THIS_NAME}', drOptionThis)
-                            // }
+                            if ('${variableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${variableName}#', forOfStr);
+                            }
+                            if ('${itemVariableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${itemVariableName}#', destIt);
+                            }
+                            if ('${itemIndexVariableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${itemIndexVariableName}#', i);
+                            }
+                   
                             if (this.__render.drStripOption === 'true') {
                                 Array.from(n.childNodes).forEach(it => this.__render.fag.append(it));
                             } else {
@@ -7475,7 +7616,8 @@ var _RawSet = class _RawSet2 {
         const targetAttrMap = element.getAttribute(EventManager.normalAttrMapAttrName);
         if (targetAttrMap) {
           new Map(JSON.parse(targetAttrMap)).forEach((v, k) => {
-            targetScripts.push(`(${v})`);
+            const variablePaths = v.variablePaths;
+            variablePaths.forEach((it) => targetScripts.push(`(${it.inner})`));
           });
         }
         script = targetScripts.join(";");
@@ -7536,12 +7678,18 @@ var _RawSet = class _RawSet2 {
         const runText = _RawSet2.expressionGroups(textContent)[0][1];
         let newNode;
         if (textContent?.startsWith("#")) {
-          const r = ObjectUtils.Script.evaluate(`${__render.bindScript} return ${runText}`, Object.assign(obj, { __render }));
+          const r = ObjectUtils.Script.evaluate(
+            `${__render.bindScript} return ${runText}`,
+            Object.assign(obj, { __render })
+          );
           const template = config.window.document.createElement("template");
           template.innerHTML = r;
           newNode = template.content;
         } else {
-          const r = ObjectUtils.Script.evaluate(`${__render.bindScript}  return ${runText}`, Object.assign(obj, { __render }));
+          const r = ObjectUtils.Script.evaluate(
+            `${__render.bindScript}  return ${runText}`,
+            Object.assign(obj, { __render })
+          );
           newNode = config.window.document.createTextNode(r);
         }
         cNode.parentNode?.replaceChild(newNode, cNode);
@@ -7580,23 +7728,140 @@ var _RawSet = class _RawSet2 {
         };
         drAttrs.push(drAttr);
         const operators = [
-          new DrPre(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_PRE_NAME, attr: drAttr.drPre, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drPre }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new Dr(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_NAME, attr: drAttr.dr, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.dr }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
+          new DrPre(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_PRE_NAME, attr: drAttr.drPre, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drPre },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new Dr(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_NAME, attr: drAttr.dr, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.dr },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
           // new Dr(this, __render, {raws, fag}, {element, attrName: EventManager.onRenderedInitAttrName, attr: drAttr.dr, attrs: drAttr}, {config, obj, operatorAround: config.operatorAround?.dr}, {onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks}),
-          new DrIf(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_IF_NAME, attr: drAttr.drIf, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drIf }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrStripElement(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_STRIP_NAME, attr: drAttr.drStripElement, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drThis }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrThis(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_THIS_NAME, attr: drAttr.drThis, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drThis }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrForm(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_FOR_NAME, attr: drAttr.drForm, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drForm }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrInnerText(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_INNERTEXT_NAME, attr: drAttr.drInnerText, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drInnerText }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrInnerHTML(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_INNERHTML_NAME, attr: drAttr.drInnerHTML, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drInnerHTML }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrFor(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_FOR_NAME, attr: drAttr.drFor, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drFor }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrForOf(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_FOR_OF_NAME, attr: drAttr.drForOf, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drForOf }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrThisProperty(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_THIS_PROPERTY_NAME, attr: drAttr.drThisProperty, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drThisProperty }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrAppender(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_APPENDER_NAME, attr: drAttr.drAppender, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drAppender }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrRepeat(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_REPEAT_NAME, attr: drAttr.drRepeat, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.drRepeat }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrTargetElementIsElement(this, __render, { raws, fag }, { element, attrName: _RawSet2.DR_REPLACE_TARGET_ELEMENT_IS_NAME, attr: drAttr.drReplaceTargetElementIs, attrs: drAttr }, { config, obj }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrTargetElement(this, __render, { raws, fag }, { element, attrs: drAttr }, { config, obj }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
-          new DrTargetAttr(this, __render, { raws, fag }, { element, attrs: drAttr }, { config, obj }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks })
+          new DrIf(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_IF_NAME, attr: drAttr.drIf, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drIf },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrStripElement(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_STRIP_NAME, attr: drAttr.drStripElement, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drThis },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrThis(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_THIS_NAME, attr: drAttr.drThis, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drThis },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrForm(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_FOR_NAME, attr: drAttr.drForm, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drForm },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrInnerText(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_INNERTEXT_NAME, attr: drAttr.drInnerText, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drInnerText },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrInnerHTML(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_INNERHTML_NAME, attr: drAttr.drInnerHTML, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drInnerHTML },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrFor(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_FOR_NAME, attr: drAttr.drFor, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drFor },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrForOf(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_FOR_OF_NAME, attr: drAttr.drForOf, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drForOf },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrThisProperty(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_THIS_PROPERTY_NAME, attr: drAttr.drThisProperty, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drThisProperty },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrAppender(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_APPENDER_NAME, attr: drAttr.drAppender, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drAppender },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrRepeat(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrName: _RawSet2.DR_REPEAT_NAME, attr: drAttr.drRepeat, attrs: drAttr },
+            { config, obj, operatorAround: config.operatorAround?.drRepeat },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrTargetElementIsElement(
+            this,
+            __render,
+            { raws, fag },
+            {
+              element,
+              attrName: _RawSet2.DR_REPLACE_TARGET_ELEMENT_IS_NAME,
+              attr: drAttr.drReplaceTargetElementIs,
+              attrs: drAttr
+            },
+            { config, obj },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrTargetElement(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrs: drAttr },
+            { config, obj },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          ),
+          new DrTargetAttr(
+            this,
+            __render,
+            { raws, fag },
+            { element, attrs: drAttr },
+            { config, obj },
+            { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }
+          )
         ];
         for (const operator of operators) {
           const state = await operator.start();
@@ -7636,12 +7901,12 @@ var _RawSet = class _RawSet2 {
     });
     for (const it of onThisComponentSetCallBacks) {
       if (isOnInitRender(it.obj)) {
-        it.obj?.onInitRender?.({}, this);
+        await it.obj?.onInitRender?.({}, this);
       }
     }
     for (const it of onElementInitCallBacks) {
       if (isOnInitRender(this.dataSet.render?.currentThis)) {
-        this.dataSet.render.currentThis.onInitRender({}, this);
+        await this.dataSet.render.currentThis.onInitRender({}, this);
       }
       config?.onElementInit?.(it.name, obj, this, it.targetElement);
     }
@@ -7743,7 +8008,10 @@ var _RawSet = class _RawSet2 {
   getDrAppendAttributeAndDelete(element, obj) {
     let data = element.getAttribute(_RawSet2.DR_APPENDER_NAME);
     if (data && !/\[.+\]/g.test(data)) {
-      const currentIndex = ObjectUtils.Script.evaluateReturn(`${ObjectUtils.Path.toOptionalChainPath(data)}?.length -1`, obj);
+      const currentIndex = ObjectUtils.Script.evaluateReturn(
+        `${ObjectUtils.Path.toOptionalChainPath(data)}?.length -1`,
+        obj
+      );
       data = `${data}[${currentIndex}]`;
       element.setAttribute(_RawSet2.DR_APPENDER_NAME, data);
     }
@@ -7789,22 +8057,28 @@ var _RawSet = class _RawSet2 {
           const normalAttrs = /* @__PURE__ */ new Map();
           const linkVariables = /* @__PURE__ */ new Map();
           const linkNames = EventManager.linkAttrs.map((it) => it.name);
-          const isAttr = element2.getAttributeNames().filter((it) => {
+          const isAttr = element2.getAttributeNames().filter((it) => !EventManager.noDetectAttr.includes(it)).filter((it) => {
             const value = element2.getAttribute(it);
             if (value && linkNames.includes(it)) {
               linkVariables.set(it, value);
             } else if (value && _RawSet2.isExpression(value)) {
-              let variablePath = _RawSet2.expressionGroups(value)[0][1];
-              const originVariable = variablePath;
-              variablePath = variablePath.replace(/#[^#]*#/g, "({})");
-              const optionalChainPath = ObjectUtils.Path.toOptionalChainPath(variablePath);
-              const cval = ObjectUtils.Script.evaluateReturn(optionalChainPath, Object.assign(obj));
+              const variablePaths = _RawSet2.expressionGroups(value).map((it2) => ({
+                origin: it2[0],
+                inner: it2[1]
+              }));
+              let targetScript = value;
+              variablePaths.forEach((it2) => {
+                let r3 = it2.inner.replace(/#[^#]*#/g, "({})");
+                r3 = ObjectUtils.Path.toOptionalChainPath(r3);
+                targetScript = targetScript.replaceAll(it2.origin, `\${${r3}}`);
+              });
+              const cval = ObjectUtils.Script.evaluateReturn("`" + targetScript + "`", Object.assign(obj));
               if (cval === null) {
                 element2.removeAttribute(it);
               } else {
                 element2.setAttribute(it, cval);
               }
-              normalAttrs.set(it, originVariable);
+              normalAttrs.set(it, { originalAttrValue: value, variablePaths });
             }
             const isTargetAttr = targetAttrNames.includes(it.toLowerCase());
             return isTargetAttr;
@@ -8218,11 +8492,33 @@ var _RawSet = class _RawSet2 {
     targetElement.querySelectorAll(EventManager.attrNames.map((it) => `[${it}]`).join(",")).forEach((it) => {
       it.setAttribute(EventManager.ownerVariablePathAttrName, "this");
     });
-    const componentNameReplaceKey = RandomUtils.uuid();
     rawSet.point.innerHTML = element.innerHTML;
-    const innerHTMLName = targetElement.getAttribute(_RawSet2.DR_COMPONENT_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+    const innerText = element.textContent?.trim() ?? "";
+    const escapedInnerHTML = ConvertUtils.escapeHTML(element.innerHTML);
+    const innerHTMLName = targetElement.getAttribute(_RawSet2.DR_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+    const innerTEXTName = targetElement.getAttribute(_RawSet2.DR_INNER_TEXT_NAME_OPTIONNAME) ?? "innerTEXT";
+    const innerHTMLEscapedName = targetElement.getAttribute(_RawSet2.DR_INNER_HTML_ESCAPED_NAME_OPTIONNAME) ?? "innerHTMLEscaped";
+    const templateReplacements = [];
     if (innerHTMLName) {
-      _RawSet2.replaceInnerHTML(targetElement, { asIs: `#${innerHTMLName}#`, toBe: element.innerHTML });
+      templateReplacements.push({
+        regex: new RegExp(`#${innerHTMLName}#`, "g"),
+        callback: () => element.innerHTML
+      });
+    }
+    if (innerTEXTName) {
+      templateReplacements.push({
+        regex: new RegExp(`#${innerTEXTName}#`, "g"),
+        callback: () => innerText
+      });
+    }
+    if (innerHTMLEscapedName) {
+      templateReplacements.push({
+        regex: new RegExp(`#${innerHTMLEscapedName}#`, "g"),
+        callback: () => escapedInnerHTML
+      });
+    }
+    if (templateReplacements.length > 0) {
+      targetElement.innerHTML = StringUtils.replaceSequentially(targetElement.innerHTML, templateReplacements);
     }
     const optionThisName = targetElement.getAttribute(_RawSet2.DR_THIS_NAME_OPTIONNAME);
     targetElement.getAttributeNames().forEach((it) => targetElement.setAttribute(it, targetElement.getAttribute(it).replace(/#this#/g, drThis)));
@@ -8299,7 +8595,6 @@ var _RawSet = class _RawSet2 {
         obj.__domrender_components ?? (obj.__domrender_components = {});
         const domrenderComponents = obj.__domrender_components;
         const renderScript = ` /*createComponentTargetElement*/
-            // console.log('-------------------',this.__render);
             var ${EventManager.RAWSET_VARNAME} = this.__render.rawSet; 
             var ${EventManager.COMPONENT_VARNAME} = this.__render.component; 
             var ${EventManager.ELEMENT_VARNAME} = this.__render.element; 
@@ -8354,15 +8649,40 @@ var _RawSet = class _RawSet2 {
         rawSet.dataSet.render = render;
         instance.__rawSet = rawSet;
         let applayTemplate = element.innerHTML;
+        let applayTemplateText = element.textContent?.trim() ?? "";
+        let applayTemplateEscape = ConvertUtils.escapeHTML(element.innerHTML);
         let innerHTMLThisRandom;
-        const componentName = element.getAttribute(_RawSet2.DR_COMPONENT_NAME_OPTIONNAME) ?? "component";
-        const innerHTMLName = element.getAttribute(_RawSet2.DR_COMPONENT_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+        const componentName = element.getAttribute(_RawSet2.DR_VARIABLE_NAME_OPTIONNAME) ?? "component";
+        const innerHTMLName = element.getAttribute(_RawSet2.DR_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+        const innerTEXTName = element.getAttribute(_RawSet2.DR_INNER_TEXT_NAME_OPTIONNAME) ?? "innerTEXT";
+        const innerHTMLEscapedName = element.getAttribute(_RawSet2.DR_INNER_HTML_ESCAPED_NAME_OPTIONNAME) ?? "innerHTMLEscaped";
         if (applayTemplate) {
           innerHTMLThisRandom = RandomUtils.uuid();
-          applayTemplate = applayTemplate.replace(/this\./g, innerHTMLThisRandom);
-          applayTemplate = applayTemplate.replace(RegExp(`#${componentName}#`, "g"), "this");
+          applayTemplate = StringUtils.replaceSequentially(applayTemplate, [
+            {
+              regex: /this\./g,
+              callback: () => innerHTMLThisRandom
+            },
+            {
+              regex: new RegExp(`#${componentName}#`, "g"),
+              callback: () => nearThisPath
+            }
+          ]);
         }
-        applayTemplate = (this.template ?? "").replace(RegExp(`#${innerHTMLName}#`, "g"), applayTemplate);
+        applayTemplate = StringUtils.replaceSequentially(this.template ?? "", [
+          {
+            regex: new RegExp(`#${innerHTMLName}#`, "g"),
+            callback: () => applayTemplate
+          },
+          {
+            regex: new RegExp(`#${innerTEXTName}#`, "g"),
+            callback: () => applayTemplateText
+          },
+          {
+            regex: new RegExp(`#${innerHTMLEscapedName}#`, "g"),
+            callback: () => applayTemplateEscape
+          }
+        ]);
         const style = _RawSet2.generateStyleTransform(this.styles, rawSet.uuid, true);
         element.innerHTML = style + (applayTemplate ?? "");
         let data = await _RawSet2.drThisCreate(
@@ -8376,8 +8696,8 @@ var _RawSet = class _RawSet2 {
         );
         if (data && innerHTMLThisRandom) {
           const template2 = config.window.document.createElement("template");
-          template2.content.append(data);
-          template2.innerHTML = template2.innerHTML.replace(RegExp(innerHTMLThisRandom, "g"), "this.");
+          template2.innerHTML = ElementUtils.toInnerHTML(data, { document: config.window.document }).replace(RegExp(innerHTMLThisRandom, "g"), "this.");
+          ;
           data = template2.content;
         }
         return data;
@@ -8414,8 +8734,24 @@ var _RawSet = class _RawSet2 {
     const normalAttribute = attribute[EventManager.normalAttrMapAttrName];
     if (normalAttribute) {
       new Map(JSON.parse(normalAttribute)).forEach((v, k) => {
+        const variablePaths = v.variablePaths;
+        let targetScript = v.originalAttrValue.trim();
+        let checktargetScript = v.originalAttrValue.trim();
+        variablePaths.forEach((it) => {
+          checktargetScript = targetScript.replaceAll(it.origin, "");
+        });
+        let isScriptValue = checktargetScript.length === 0 && variablePaths.length === 1;
+        if (isScriptValue) {
+          let r = ObjectUtils.Path.toOptionalChainPath(variablePaths[0].inner);
+          targetScript = targetScript.replaceAll(variablePaths[0].origin, r);
+        } else {
+          variablePaths.forEach((it) => {
+            let r = ObjectUtils.Path.toOptionalChainPath(it.inner);
+            targetScript = targetScript.replaceAll(it.origin, `\${${r}}`);
+          });
+        }
         const cval = ObjectUtils.Script.evaluateReturn(
-          { bodyScript: config.script, returnScript: v },
+          { bodyScript: config.script, returnScript: isScriptValue ? targetScript : "`" + targetScript + "`" },
           Object.assign(config.obj, config.renderData ? { __render: config.renderData } : void 0)
         );
         attribute[k] = cval;
@@ -8454,8 +8790,12 @@ _RawSet.DR_COMPLETE_OPTIONNAME = "dr-option-complete";
 _RawSet.DR_STRIP_OPTIONNAME = "dr-option-strip";
 _RawSet.DR_DESTROY_OPTIONNAME = "dr-option-destroy";
 _RawSet.DR_THIS_NAME_OPTIONNAME = "dr-option-this-name";
-_RawSet.DR_COMPONENT_NAME_OPTIONNAME = "dr-option-component-name";
-_RawSet.DR_COMPONENT_INNER_HTML_NAME_OPTIONNAME = "dr-option-component-inner-html-name";
+_RawSet.DR_VARIABLE_NAME_OPTIONNAME = "dr-option-variable-name";
+_RawSet.DR_ITEM_VARIABLE_NAME_OPTIONNAME = "dr-option-item-variable-name";
+_RawSet.DR_ITEM_INDEX_VARIABLE_NAME_OPTIONNAME = "dr-option-item-index-variable-name";
+_RawSet.DR_INNER_HTML_NAME_OPTIONNAME = "dr-option-inner-html-name";
+_RawSet.DR_INNER_TEXT_NAME_OPTIONNAME = "dr-option-inner-text-name";
+_RawSet.DR_INNER_HTML_ESCAPED_NAME_OPTIONNAME = "dr-option-inner-html-escaped-name";
 _RawSet.DR_KEY_OPTIONNAME = "dr-option-key";
 _RawSet.DR_HAS_KEYS_OPTIONNAME = "dr-option-has-keys";
 _RawSet.DR_ON_CREATE_ARGUMENTS_OPTIONNAME = "dr-on-create:arguments";
@@ -8561,7 +8901,20 @@ var isOnRawSetRendered = (obj) => {
 };
 
 // ../dom-render/dist/esm/DomRenderProxy.js
-var excludeGetSetPropertys = ["onBeforeReturnGet", "onBeforeReturnSet", "__domrender_components", "__render", "_DomRender_isFinal", "_domRender_ref", "_rawSets", "_domRender_proxy", "_targets", "_DomRender_origin", "_DomRender_ref", "_DomRender_proxy"];
+var excludeGetSetPropertys = [
+  "onBeforeReturnGet",
+  "onBeforeReturnSet",
+  "__domrender_components",
+  "__render",
+  "_DomRender_isFinal",
+  "_domRender_ref",
+  "_rawSets",
+  "_domRender_proxy",
+  "_targets",
+  "_DomRender_origin",
+  "_DomRender_ref",
+  "_DomRender_proxy"
+];
 var isWrapProxyDomRenderProxy = (obj) => {
   return obj && typeof obj === "object" && "_DomRender_isProxy" in obj;
 };
@@ -8597,7 +8950,7 @@ var DomRenderProxy = class _DomRenderProxy {
   static isFinal(obj) {
     return ValidUtils.isNull(obj) || DomRenderFinalProxy.isFinal(obj);
   }
-  run(objProxy) {
+  async run(objProxy) {
     this._domRender_proxy = objProxy;
     if (isOnProxyDomRender(objProxy)) {
       objProxy.onProxyDomRender(this._domRender_config);
@@ -8622,18 +8975,18 @@ var DomRenderProxy = class _DomRenderProxy {
         }
       });
     }
-    this._targets.forEach((target) => {
-      this.initRender(target);
-    });
+    for (let target of this._targets) {
+      await this.initRender(target);
+    }
   }
-  initRender(target, rawSet) {
+  async initRender(target, rawSet) {
     if (target instanceof Element) {
       target.innerHTML = target.innerHTML.replace(/@this@/g, "this");
     }
     const onCreate = target.getAttribute?.(RawSet.DR_ON_CREATE_ARGUMENTS_OPTIONNAME);
     let createParam = [];
     if (onCreate) {
-      createParam = ScriptUtils.evaluateReturn(onCreate, this._domRender_proxy);
+      createParam = ObjectUtils.Script.evaluateReturn(onCreate, this._domRender_proxy);
       if (!Array.isArray(createParam)) {
         createParam = [createParam];
       }
@@ -8646,7 +8999,11 @@ var DomRenderProxy = class _DomRenderProxy {
     }
     this._targets.add(target);
     const rawSets = RawSet.checkPointCreates(target, this._domRender_proxy, this._domRender_config);
-    this._domRender_config.eventManager.applyEvent(this._domRender_proxy, this._domRender_config.eventManager.findAttrElements(target, this._domRender_config), this._domRender_config);
+    this._domRender_config.eventManager.applyEvent(
+      this._domRender_proxy,
+      this._domRender_config.eventManager.findAttrElements(target, this._domRender_config),
+      this._domRender_config
+    );
     rawSets.forEach((it) => {
       const variables = it.getUsingTriggerVariables(this._domRender_config);
       if (variables.size <= 0) {
@@ -8657,16 +9014,20 @@ var DomRenderProxy = class _DomRenderProxy {
         });
       }
     });
-    this.render(this.getRawSets()).then((it) => {
+    const targetRawSets = await this.render(this.getRawSets());
+    for (let targetRawSet of targetRawSets) {
       const onInit = target.getAttribute?.(RawSet.DR_ON_INIT_ARGUMENTS_OPTIONNAME);
       let initParam;
       if (onCreate) {
         initParam = ScriptUtils.evaluateReturn(onCreate, this._domRender_proxy);
       }
       if (isOnInitRender(this._domRender_proxy)) {
-        this._domRender_proxy.onInitRender(initParam, rawSet ?? { dataSet: { config: this._domRender_config } });
+        await this._domRender_proxy.onInitRender(
+          initParam,
+          rawSet ?? { dataSet: { config: this._domRender_config } }
+        );
       }
-    });
+    }
   }
   getRawSets() {
     const set = /* @__PURE__ */ new Set();
@@ -8699,9 +9060,12 @@ var DomRenderProxy = class _DomRenderProxy {
         } else if (it.type === RawSetType.TARGET_ELEMENT && it.dataSet?.render?.currentThis && fullPathStr && targetAttrMap) {
           new Map(JSON.parse(targetAttrMap)).forEach((v, k) => {
             var _a7;
-            const isUsing = EventManager.isUsingThisVar(v, `this.${fullPathStr}`);
+            const isUsing = v.variablePaths.some((it2) => EventManager.isUsingThisVar(it2.inner, `this.${fullPathStr}`));
             if (isUsing) {
-              const targetAttrObject = RawSet.getAttributeObject(it.point.node, { script: it.dataSet?.render?.renderScript ?? "", obj: Object.assign(this._domRender_proxy ?? {}, { __render: it.dataSet?.render }) });
+              const targetAttrObject = RawSet.getAttributeObject(it.point.node, {
+                script: it.dataSet?.render?.renderScript ?? "",
+                obj: Object.assign(this._domRender_proxy ?? {}, { __render: it.dataSet?.render })
+              });
               (_a7 = it.dataSet).render ?? (_a7.render = {});
               it.dataSet.render.attribute = targetAttrObject;
               if (isOnChangeAttrRender(it.dataSet?.render?.currentThis)) {
@@ -8745,7 +9109,11 @@ var DomRenderProxy = class _DomRenderProxy {
           it.forEach((sit) => {
             try {
               const concat = pathInfos.concat([[{ path: sit, obj: key }]]);
-              const items = key._DomRender_proxy?.root(concat, value, lastDoneExecute);
+              const items = key._DomRender_proxy?.root(
+                concat,
+                value,
+                lastDoneExecute
+              );
               fullPaths.push(items.flat());
             } catch (e) {
             }
@@ -8781,10 +9149,19 @@ var DomRenderProxy = class _DomRenderProxy {
               if (value === void 0) {
                 const rawSet = it.getHasRawSet(lastPropertyName);
                 rawSet?.remove();
-                startElement.setAttribute(RawSet.DR_HAS_KEYS_OPTIONNAME, keys.filter((it2) => it2 !== lastPropertyName).join(","));
+                startElement.setAttribute(
+                  RawSet.DR_HAS_KEYS_OPTIONNAME,
+                  keys.filter((it2) => it2 !== lastPropertyName).join(",")
+                );
               }
               if (!keys.includes(lastPropertyName)) {
-                const raws = DrThisProperty.append(this._domRender_proxy, fullPathStr, lastPropertyName, it, this._domRender_config);
+                const raws = DrThisProperty.append(
+                  this._domRender_proxy,
+                  fullPathStr,
+                  lastPropertyName,
+                  it,
+                  this._domRender_config
+                );
                 if (raws) {
                   rawSets.push(...raws);
                 }
@@ -8804,10 +9181,19 @@ var DomRenderProxy = class _DomRenderProxy {
           } else if (iterable) {
             rData = await this.render(Array.from(iterable), fullPathStr);
           }
+          const Node2 = this._domRender_config.window.Node;
           this._targets.forEach((it) => {
-            if (it.nodeType === Node.DOCUMENT_FRAGMENT_NODE || it.nodeType === Node.ELEMENT_NODE) {
-              const targets = this._domRender_config.eventManager.findAttrElements(it, this._domRender_config);
-              this._domRender_config.eventManager.changeVar(this._domRender_proxy, targets, `this.${fullPathStr}`, this._domRender_config);
+            if (it.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || it.nodeType === Node2.ELEMENT_NODE) {
+              const targets = this._domRender_config.eventManager.findAttrElements(
+                it,
+                this._domRender_config
+              );
+              this._domRender_config.eventManager.changeVar(
+                this._domRender_proxy,
+                targets,
+                `this.${fullPathStr}`,
+                this._domRender_config
+              );
             }
           });
           if (rData?.length > 0 && isOnChildRenderedByProperty(data)) {
@@ -8839,49 +9225,64 @@ var DomRenderProxy = class _DomRenderProxy {
       fullPathInfo = this.root([[{ path: p, obj: this._domRender_proxy }]], value);
     }
     const rootElement = this._domRender_config.rootElement ?? this._domRender_config.window.document;
-    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.normalAttrMapAttrName)?.forEach((elementInfo) => {
-      const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((it) => {
-        const optionalPath = ObjectUtils.Path.toOptionalChainPath(it.valueScript);
-        const value1 = ScriptUtils.evaluateReturn(optionalPath, it.pathInfo.obj);
-        if (value1 === null) {
-          elementInfo.element.removeAttribute(it.key);
-          elementInfo.element[it.key] = null;
-        } else {
-          elementInfo.element.setAttribute(it.key, value1);
-          elementInfo.element[it.key] = value1;
-        }
-      });
-    });
-    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.linkTargetMapAttrName)?.forEach((elementInfo) => {
-      const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((info) => {
-        const value1 = ScriptUtils.evaluateReturn(info.valueScript, info.pathInfo.obj);
-        const applyAttributeName = EventManager.linkAttrs.find((it) => it.name === info.key);
-        if (applyAttributeName) {
+    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.normalAttrMapAttrName)?.forEach(
+      (elementInfo) => {
+        const targets = new Map(
+          ObjectUtils.Script.evaluateReturn(elementInfo.value)
+        );
+        Array.from(targets.entries()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.variablePaths?.some((vit) => vit.inner.includes(`this.${it.path}`))).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((it) => {
+          const variablePaths = it.valueScript.variablePaths;
+          let targetScript = it.valueScript.originalAttrValue;
+          variablePaths.forEach((it2) => {
+            let r = ObjectUtils.Path.toOptionalChainPath(it2.inner);
+            targetScript = targetScript.replaceAll(it2.origin, `\${${r}}`);
+          });
+          const value1 = ObjectUtils.Script.evaluateReturn("`" + targetScript + "`", it.pathInfo.obj);
           if (value1 === null) {
-            elementInfo.element.removeAttribute(applyAttributeName.property);
+            elementInfo.element.removeAttribute(it.key);
+            elementInfo.element[it.key] = null;
           } else {
-            elementInfo.element.setAttribute(applyAttributeName.property, value1);
+            elementInfo.element.setAttribute(it.key, value1);
+            elementInfo.element[it.key] = value1;
           }
-        }
-      });
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((info) => {
-        const linkInfo = EventManager.linkAttrs.find((it) => it.name === info.key);
-        if (linkInfo) {
-          elementInfo.element[linkInfo.property] = value;
-        }
-      });
-    });
+        });
+      }
+    );
+    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.linkTargetMapAttrName)?.forEach(
+      (elementInfo) => {
+        const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((info) => {
+          const value1 = ScriptUtils.evaluateReturn(info.valueScript, info.pathInfo.obj);
+          const applyAttributeName = EventManager.linkAttrs.find((it) => it.name === info.key);
+          if (applyAttributeName) {
+            if (value1 === null) {
+              elementInfo.element.removeAttribute(applyAttributeName.property);
+            } else {
+              elementInfo.element.setAttribute(applyAttributeName.property, value1);
+            }
+          }
+        });
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((info) => {
+          const linkInfo = EventManager.linkAttrs.find((it) => it.name === info.key);
+          if (linkInfo) {
+            elementInfo.element[linkInfo.property] = value;
+          }
+        });
+      }
+    );
     if ("onBeforeReturnSet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnSets ?? []).concat(excludeGetSetPropertys).includes(p)) {
       if (isOnBeforeReturnSet(receiver)) {
-        receiver.onBeforeReturnSet?.(p, value, fullPathInfo.map((it) => it.map((it2) => it2.path).join()));
+        receiver.onBeforeReturnSet?.(
+          p,
+          value,
+          fullPathInfo.map((it) => it.map((it2) => it2.path).join())
+        );
       }
     }
     return true;
@@ -8901,7 +9302,11 @@ var DomRenderProxy = class _DomRenderProxy {
         it = it._DomRender_origin;
       }
       if ("onBeforeReturnGet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnGets ?? []).concat(excludeGetSetPropertys).includes(p)) {
-        receiver?.onBeforeReturnGet?.(p, it, this.root([[{ path: p, obj: this._domRender_proxy }]], it, false));
+        receiver?.onBeforeReturnGet?.(
+          p,
+          it,
+          this.root([[{ path: p, obj: this._domRender_proxy }]], it, false)
+        );
       }
       return it;
     }
@@ -9193,7 +9598,7 @@ var SSRFilter = class {
           simpleBootFront.routingSubjectObservable.pipe(
             // @ts-ignore
             filter(
-              (it) => it.state === "end" && typeof it.routerModule.intent.uri === "string" && targetUrl.endsWith(it.routerModule.intent.uri)
+              (it) => it.triggerPoint === "end" && typeof it.routerModule.intent.uri === "string" && targetUrl.endsWith(it.routerModule.intent.uri)
             ),
             // delay(1000),
             first()
@@ -10288,6 +10693,7 @@ var ReqHeader = class {
 
 // ../simple-boot-http-server/dist/esm/models/RequestResponse.js
 var import_node_gzip = __toESM(require_dist(), 1);
+import { Blob } from "node:buffer";
 
 // ../core-node/dist/esm/file/FileUtils.js
 import * as node_os from "node:os";
@@ -10397,6 +10803,18 @@ var FileUtils;
     const buffer = config?.option ? node_fs.readFileSync(p, config.option) : node_fs.readFileSync(p);
     return buffer;
   };
+  FileUtils2.readAsync = async (path2, config) => {
+    const p = FileUtils2.path(path2);
+    return node_fs.promises.readFile(p, config?.option);
+  };
+  FileUtils2.readStringSync = (path2) => {
+    const p = FileUtils2.path(path2);
+    return node_fs.readFileSync(p, "utf-8");
+  };
+  FileUtils2.readStringAsync = async (path2) => {
+    const p = FileUtils2.path(path2);
+    return node_fs.promises.readFile(p, "utf-8");
+  };
   FileUtils2.read = async (path2, config) => {
     const p = FileUtils2.path(path2);
     return node_fs.readFile(p, config.option);
@@ -10855,7 +11273,28 @@ var RequestResponse = class _RequestResponse {
     this.res.end(data);
   }
   async resEnd(chunk) {
-    this.resWriteChunk = chunk ?? this.resWriteChunk;
+    if (chunk instanceof Response) {
+      chunk.headers.forEach((value, key) => {
+        this.res.setHeader(`ORIGIN-${key}`, value);
+      });
+      if (!this.resHeader(HttpHeaders.ContentType)) {
+        const contentType = chunk.headers.get(HttpHeaders.ContentType);
+        if (contentType) {
+          this.res.setHeader(HttpHeaders.ContentType, contentType);
+        }
+      }
+      this.res.statusCode = chunk.status;
+      this.resWriteChunk = Buffer2.from(await chunk.arrayBuffer());
+    } else if (chunk instanceof Blob) {
+      this.resWriteChunk = Buffer2.from(await chunk.arrayBuffer());
+      if (!this.resHeader(HttpHeaders.ContentType)) {
+        this.res.setHeader(HttpHeaders.ContentType, chunk.type);
+      }
+    } else if (chunk instanceof ArrayBuffer) {
+      this.resWriteChunk = Buffer2.from(chunk);
+    } else {
+      this.resWriteChunk = chunk ?? this.resWriteChunk;
+    }
     if (this.req.readable) {
       await this.reqBodyData();
       await this.resEndChunk();