@dooboostore/dom-render 1.0.109 → 1.0.110

package/dist/umd-bundle/dooboostore-dom-render.umd.js

@@ -1115,6 +1115,1091 @@ var dooboostoreDomRender = (() => {
     }
   });
 
+  // ../../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+  var require_Reflect2 = __commonJS({
+    "../../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js"() {
+      var Reflect2;
+      (function(Reflect3) {
+        (function(factory) {
+          var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+          var exporter = makeExporter(Reflect3);
+          if (typeof root.Reflect !== "undefined") {
+            exporter = makeExporter(root.Reflect, exporter);
+          }
+          factory(exporter, root);
+          if (typeof root.Reflect === "undefined") {
+            root.Reflect = Reflect3;
+          }
+          function makeExporter(target, previous) {
+            return function(key, value) {
+              Object.defineProperty(target, key, { configurable: true, writable: true, value });
+              if (previous)
+                previous(key, value);
+            };
+          }
+          function functionThis() {
+            try {
+              return Function("return this;")();
+            } catch (_) {
+            }
+          }
+          function indirectEvalThis() {
+            try {
+              return (void 0, eval)("(function() { return this; })()");
+            } catch (_) {
+            }
+          }
+          function sloppyModeThis() {
+            return functionThis() || indirectEvalThis();
+          }
+        })(function(exporter, root) {
+          var hasOwn = Object.prototype.hasOwnProperty;
+          var supportsSymbol = typeof Symbol === "function";
+          var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+          var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+          var supportsCreate = typeof Object.create === "function";
+          var supportsProto = { __proto__: [] } instanceof Array;
+          var downLevel = !supportsCreate && !supportsProto;
+          var HashMap = {
+            // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+            create: supportsCreate ? function() {
+              return MakeDictionary(/* @__PURE__ */ Object.create(null));
+            } : supportsProto ? function() {
+              return MakeDictionary({ __proto__: null });
+            } : function() {
+              return MakeDictionary({});
+            },
+            has: downLevel ? function(map2, key) {
+              return hasOwn.call(map2, key);
+            } : function(map2, key) {
+              return key in map2;
+            },
+            get: downLevel ? function(map2, key) {
+              return hasOwn.call(map2, key) ? map2[key] : void 0;
+            } : function(map2, key) {
+              return map2[key];
+            }
+          };
+          var functionPrototype = Object.getPrototypeOf(Function);
+          var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+          var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+          var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+          var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+          var metadataRegistry = GetOrCreateMetadataRegistry();
+          var metadataProvider = CreateMetadataProvider(metadataRegistry);
+          function decorate(decorators, target, propertyKey, attributes) {
+            if (!IsUndefined(propertyKey)) {
+              if (!IsArray(decorators))
+                throw new TypeError();
+              if (!IsObject(target))
+                throw new TypeError();
+              if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+                throw new TypeError();
+              if (IsNull(attributes))
+                attributes = void 0;
+              propertyKey = ToPropertyKey(propertyKey);
+              return DecorateProperty(decorators, target, propertyKey, attributes);
+            } else {
+              if (!IsArray(decorators))
+                throw new TypeError();
+              if (!IsConstructor(target))
+                throw new TypeError();
+              return DecorateConstructor(decorators, target);
+            }
+          }
+          exporter("decorate", decorate);
+          function metadata(metadataKey, metadataValue) {
+            function decorator(target, propertyKey) {
+              if (!IsObject(target))
+                throw new TypeError();
+              if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+                throw new TypeError();
+              OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+            }
+            return decorator;
+          }
+          exporter("metadata", metadata);
+          function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+          }
+          exporter("defineMetadata", defineMetadata);
+          function hasMetadata(metadataKey, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+          }
+          exporter("hasMetadata", hasMetadata);
+          function hasOwnMetadata(metadataKey, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+          }
+          exporter("hasOwnMetadata", hasOwnMetadata);
+          function getMetadata(metadataKey, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+          }
+          exporter("getMetadata", getMetadata);
+          function getOwnMetadata(metadataKey, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+          }
+          exporter("getOwnMetadata", getOwnMetadata);
+          function getMetadataKeys(target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryMetadataKeys(target, propertyKey);
+          }
+          exporter("getMetadataKeys", getMetadataKeys);
+          function getOwnMetadataKeys(target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            return OrdinaryOwnMetadataKeys(target, propertyKey);
+          }
+          exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+          function deleteMetadata(metadataKey, target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey))
+              propertyKey = ToPropertyKey(propertyKey);
+            var provider = GetMetadataProvider(
+              target,
+              propertyKey,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(provider))
+              return false;
+            return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+          }
+          exporter("deleteMetadata", deleteMetadata);
+          function DecorateConstructor(decorators, target) {
+            for (var i = decorators.length - 1; i >= 0; --i) {
+              var decorator = decorators[i];
+              var decorated = decorator(target);
+              if (!IsUndefined(decorated) && !IsNull(decorated)) {
+                if (!IsConstructor(decorated))
+                  throw new TypeError();
+                target = decorated;
+              }
+            }
+            return target;
+          }
+          function DecorateProperty(decorators, target, propertyKey, descriptor) {
+            for (var i = decorators.length - 1; i >= 0; --i) {
+              var decorator = decorators[i];
+              var decorated = decorator(target, propertyKey, descriptor);
+              if (!IsUndefined(decorated) && !IsNull(decorated)) {
+                if (!IsObject(decorated))
+                  throw new TypeError();
+                descriptor = decorated;
+              }
+            }
+            return descriptor;
+          }
+          function OrdinaryHasMetadata(MetadataKey, O, P) {
+            var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+            if (hasOwn2)
+              return true;
+            var parent = OrdinaryGetPrototypeOf(O);
+            if (!IsNull(parent))
+              return OrdinaryHasMetadata(MetadataKey, parent, P);
+            return false;
+          }
+          function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+            var provider = GetMetadataProvider(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(provider))
+              return false;
+            return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+          }
+          function OrdinaryGetMetadata(MetadataKey, O, P) {
+            var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+            if (hasOwn2)
+              return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+            var parent = OrdinaryGetPrototypeOf(O);
+            if (!IsNull(parent))
+              return OrdinaryGetMetadata(MetadataKey, parent, P);
+            return void 0;
+          }
+          function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+            var provider = GetMetadataProvider(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(provider))
+              return;
+            return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+          }
+          function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+            var provider = GetMetadataProvider(
+              O,
+              P,
+              /*Create*/
+              true
+            );
+            provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+          }
+          function OrdinaryMetadataKeys(O, P) {
+            var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+            var parent = OrdinaryGetPrototypeOf(O);
+            if (parent === null)
+              return ownKeys;
+            var parentKeys = OrdinaryMetadataKeys(parent, P);
+            if (parentKeys.length <= 0)
+              return ownKeys;
+            if (ownKeys.length <= 0)
+              return parentKeys;
+            var set = new _Set();
+            var keys = [];
+            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+              var key = ownKeys_1[_i];
+              var hasKey = set.has(key);
+              if (!hasKey) {
+                set.add(key);
+                keys.push(key);
+              }
+            }
+            for (var _a2 = 0, parentKeys_1 = parentKeys; _a2 < parentKeys_1.length; _a2++) {
+              var key = parentKeys_1[_a2];
+              var hasKey = set.has(key);
+              if (!hasKey) {
+                set.add(key);
+                keys.push(key);
+              }
+            }
+            return keys;
+          }
+          function OrdinaryOwnMetadataKeys(O, P) {
+            var provider = GetMetadataProvider(
+              O,
+              P,
+              /*create*/
+              false
+            );
+            if (!provider) {
+              return [];
+            }
+            return provider.OrdinaryOwnMetadataKeys(O, P);
+          }
+          function Type(x) {
+            if (x === null)
+              return 1;
+            switch (typeof x) {
+              case "undefined":
+                return 0;
+              case "boolean":
+                return 2;
+              case "string":
+                return 3;
+              case "symbol":
+                return 4;
+              case "number":
+                return 5;
+              case "object":
+                return x === null ? 1 : 6;
+              default:
+                return 6;
+            }
+          }
+          function IsUndefined(x) {
+            return x === void 0;
+          }
+          function IsNull(x) {
+            return x === null;
+          }
+          function IsSymbol(x) {
+            return typeof x === "symbol";
+          }
+          function IsObject(x) {
+            return typeof x === "object" ? x !== null : typeof x === "function";
+          }
+          function ToPrimitive(input, PreferredType) {
+            switch (Type(input)) {
+              case 0:
+                return input;
+              case 1:
+                return input;
+              case 2:
+                return input;
+              case 3:
+                return input;
+              case 4:
+                return input;
+              case 5:
+                return input;
+            }
+            var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+            if (exoticToPrim !== void 0) {
+              var result = exoticToPrim.call(input, hint);
+              if (IsObject(result))
+                throw new TypeError();
+              return result;
+            }
+            return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+          }
+          function OrdinaryToPrimitive(O, hint) {
+            if (hint === "string") {
+              var toString_1 = O.toString;
+              if (IsCallable(toString_1)) {
+                var result = toString_1.call(O);
+                if (!IsObject(result))
+                  return result;
+              }
+              var valueOf = O.valueOf;
+              if (IsCallable(valueOf)) {
+                var result = valueOf.call(O);
+                if (!IsObject(result))
+                  return result;
+              }
+            } else {
+              var valueOf = O.valueOf;
+              if (IsCallable(valueOf)) {
+                var result = valueOf.call(O);
+                if (!IsObject(result))
+                  return result;
+              }
+              var toString_2 = O.toString;
+              if (IsCallable(toString_2)) {
+                var result = toString_2.call(O);
+                if (!IsObject(result))
+                  return result;
+              }
+            }
+            throw new TypeError();
+          }
+          function ToBoolean(argument) {
+            return !!argument;
+          }
+          function ToString(argument) {
+            return "" + argument;
+          }
+          function ToPropertyKey(argument) {
+            var key = ToPrimitive(
+              argument,
+              3
+              /* String */
+            );
+            if (IsSymbol(key))
+              return key;
+            return ToString(key);
+          }
+          function IsArray(argument) {
+            return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+          }
+          function IsCallable(argument) {
+            return typeof argument === "function";
+          }
+          function IsConstructor(argument) {
+            return typeof argument === "function";
+          }
+          function IsPropertyKey(argument) {
+            switch (Type(argument)) {
+              case 3:
+                return true;
+              case 4:
+                return true;
+              default:
+                return false;
+            }
+          }
+          function SameValueZero(x, y) {
+            return x === y || x !== x && y !== y;
+          }
+          function GetMethod(V, P) {
+            var func = V[P];
+            if (func === void 0 || func === null)
+              return void 0;
+            if (!IsCallable(func))
+              throw new TypeError();
+            return func;
+          }
+          function GetIterator(obj) {
+            var method = GetMethod(obj, iteratorSymbol);
+            if (!IsCallable(method))
+              throw new TypeError();
+            var iterator = method.call(obj);
+            if (!IsObject(iterator))
+              throw new TypeError();
+            return iterator;
+          }
+          function IteratorValue(iterResult) {
+            return iterResult.value;
+          }
+          function IteratorStep(iterator) {
+            var result = iterator.next();
+            return result.done ? false : result;
+          }
+          function IteratorClose(iterator) {
+            var f = iterator["return"];
+            if (f)
+              f.call(iterator);
+          }
+          function OrdinaryGetPrototypeOf(O) {
+            var proto = Object.getPrototypeOf(O);
+            if (typeof O !== "function" || O === functionPrototype)
+              return proto;
+            if (proto !== functionPrototype)
+              return proto;
+            var prototype = O.prototype;
+            var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+            if (prototypeProto == null || prototypeProto === Object.prototype)
+              return proto;
+            var constructor = prototypeProto.constructor;
+            if (typeof constructor !== "function")
+              return proto;
+            if (constructor === O)
+              return proto;
+            return constructor;
+          }
+          function CreateMetadataRegistry() {
+            var fallback;
+            if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+              fallback = CreateFallbackProvider(root.Reflect);
+            }
+            var first;
+            var second;
+            var rest;
+            var targetProviderMap = new _WeakMap();
+            var registry = {
+              registerProvider,
+              getProvider,
+              setProvider
+            };
+            return registry;
+            function registerProvider(provider) {
+              if (!Object.isExtensible(registry)) {
+                throw new Error("Cannot add provider to a frozen registry.");
+              }
+              switch (true) {
+                case fallback === provider:
+                  break;
+                case IsUndefined(first):
+                  first = provider;
+                  break;
+                case first === provider:
+                  break;
+                case IsUndefined(second):
+                  second = provider;
+                  break;
+                case second === provider:
+                  break;
+                default:
+                  if (rest === void 0)
+                    rest = new _Set();
+                  rest.add(provider);
+                  break;
+              }
+            }
+            function getProviderNoCache(O, P) {
+              if (!IsUndefined(first)) {
+                if (first.isProviderFor(O, P))
+                  return first;
+                if (!IsUndefined(second)) {
+                  if (second.isProviderFor(O, P))
+                    return first;
+                  if (!IsUndefined(rest)) {
+                    var iterator = GetIterator(rest);
+                    while (true) {
+                      var next = IteratorStep(iterator);
+                      if (!next) {
+                        return void 0;
+                      }
+                      var provider = IteratorValue(next);
+                      if (provider.isProviderFor(O, P)) {
+                        IteratorClose(iterator);
+                        return provider;
+                      }
+                    }
+                  }
+                }
+              }
+              if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+                return fallback;
+              }
+              return void 0;
+            }
+            function getProvider(O, P) {
+              var providerMap = targetProviderMap.get(O);
+              var provider;
+              if (!IsUndefined(providerMap)) {
+                provider = providerMap.get(P);
+              }
+              if (!IsUndefined(provider)) {
+                return provider;
+              }
+              provider = getProviderNoCache(O, P);
+              if (!IsUndefined(provider)) {
+                if (IsUndefined(providerMap)) {
+                  providerMap = new _Map();
+                  targetProviderMap.set(O, providerMap);
+                }
+                providerMap.set(P, provider);
+              }
+              return provider;
+            }
+            function hasProvider(provider) {
+              if (IsUndefined(provider))
+                throw new TypeError();
+              return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+            }
+            function setProvider(O, P, provider) {
+              if (!hasProvider(provider)) {
+                throw new Error("Metadata provider not registered.");
+              }
+              var existingProvider = getProvider(O, P);
+              if (existingProvider !== provider) {
+                if (!IsUndefined(existingProvider)) {
+                  return false;
+                }
+                var providerMap = targetProviderMap.get(O);
+                if (IsUndefined(providerMap)) {
+                  providerMap = new _Map();
+                  targetProviderMap.set(O, providerMap);
+                }
+                providerMap.set(P, provider);
+              }
+              return true;
+            }
+          }
+          function GetOrCreateMetadataRegistry() {
+            var metadataRegistry2;
+            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+              metadataRegistry2 = root.Reflect[registrySymbol];
+            }
+            if (IsUndefined(metadataRegistry2)) {
+              metadataRegistry2 = CreateMetadataRegistry();
+            }
+            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+              Object.defineProperty(root.Reflect, registrySymbol, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: metadataRegistry2
+              });
+            }
+            return metadataRegistry2;
+          }
+          function CreateMetadataProvider(registry) {
+            var metadata2 = new _WeakMap();
+            var provider = {
+              isProviderFor: function(O, P) {
+                var targetMetadata = metadata2.get(O);
+                if (IsUndefined(targetMetadata))
+                  return false;
+                return targetMetadata.has(P);
+              },
+              OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+              OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+              OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+              OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+              OrdinaryDeleteMetadata
+            };
+            metadataRegistry.registerProvider(provider);
+            return provider;
+            function GetOrCreateMetadataMap(O, P, Create) {
+              var targetMetadata = metadata2.get(O);
+              var createdTargetMetadata = false;
+              if (IsUndefined(targetMetadata)) {
+                if (!Create)
+                  return void 0;
+                targetMetadata = new _Map();
+                metadata2.set(O, targetMetadata);
+                createdTargetMetadata = true;
+              }
+              var metadataMap = targetMetadata.get(P);
+              if (IsUndefined(metadataMap)) {
+                if (!Create)
+                  return void 0;
+                metadataMap = new _Map();
+                targetMetadata.set(P, metadataMap);
+                if (!registry.setProvider(O, P, provider)) {
+                  targetMetadata.delete(P);
+                  if (createdTargetMetadata) {
+                    metadata2.delete(O);
+                  }
+                  throw new Error("Wrong provider for target.");
+                }
+              }
+              return metadataMap;
+            }
+            function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+              var metadataMap = GetOrCreateMetadataMap(
+                O,
+                P,
+                /*Create*/
+                false
+              );
+              if (IsUndefined(metadataMap))
+                return false;
+              return ToBoolean(metadataMap.has(MetadataKey));
+            }
+            function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+              var metadataMap = GetOrCreateMetadataMap(
+                O,
+                P,
+                /*Create*/
+                false
+              );
+              if (IsUndefined(metadataMap))
+                return void 0;
+              return metadataMap.get(MetadataKey);
+            }
+            function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+              var metadataMap = GetOrCreateMetadataMap(
+                O,
+                P,
+                /*Create*/
+                true
+              );
+              metadataMap.set(MetadataKey, MetadataValue);
+            }
+            function OrdinaryOwnMetadataKeys2(O, P) {
+              var keys = [];
+              var metadataMap = GetOrCreateMetadataMap(
+                O,
+                P,
+                /*Create*/
+                false
+              );
+              if (IsUndefined(metadataMap))
+                return keys;
+              var keysObj = metadataMap.keys();
+              var iterator = GetIterator(keysObj);
+              var k = 0;
+              while (true) {
+                var next = IteratorStep(iterator);
+                if (!next) {
+                  keys.length = k;
+                  return keys;
+                }
+                var nextValue = IteratorValue(next);
+                try {
+                  keys[k] = nextValue;
+                } catch (e) {
+                  try {
+                    IteratorClose(iterator);
+                  } finally {
+                    throw e;
+                  }
+                }
+                k++;
+              }
+            }
+            function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+              var metadataMap = GetOrCreateMetadataMap(
+                O,
+                P,
+                /*Create*/
+                false
+              );
+              if (IsUndefined(metadataMap))
+                return false;
+              if (!metadataMap.delete(MetadataKey))
+                return false;
+              if (metadataMap.size === 0) {
+                var targetMetadata = metadata2.get(O);
+                if (!IsUndefined(targetMetadata)) {
+                  targetMetadata.delete(P);
+                  if (targetMetadata.size === 0) {
+                    metadata2.delete(targetMetadata);
+                  }
+                }
+              }
+              return true;
+            }
+          }
+          function CreateFallbackProvider(reflect) {
+            var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+            var metadataOwner = new _WeakMap();
+            var provider = {
+              isProviderFor: function(O, P) {
+                var metadataPropertySet = metadataOwner.get(O);
+                if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+                  return true;
+                }
+                if (getOwnMetadataKeys2(O, P).length) {
+                  if (IsUndefined(metadataPropertySet)) {
+                    metadataPropertySet = new _Set();
+                    metadataOwner.set(O, metadataPropertySet);
+                  }
+                  metadataPropertySet.add(P);
+                  return true;
+                }
+                return false;
+              },
+              OrdinaryDefineOwnMetadata: defineMetadata2,
+              OrdinaryHasOwnMetadata: hasOwnMetadata2,
+              OrdinaryGetOwnMetadata: getOwnMetadata2,
+              OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+              OrdinaryDeleteMetadata: deleteMetadata2
+            };
+            return provider;
+          }
+          function GetMetadataProvider(O, P, Create) {
+            var registeredProvider = metadataRegistry.getProvider(O, P);
+            if (!IsUndefined(registeredProvider)) {
+              return registeredProvider;
+            }
+            if (Create) {
+              if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+                return metadataProvider;
+              }
+              throw new Error("Illegal state.");
+            }
+            return void 0;
+          }
+          function CreateMapPolyfill() {
+            var cacheSentinel = {};
+            var arraySentinel = [];
+            var MapIterator = (
+              /** @class */
+              function() {
+                function MapIterator2(keys, values, selector) {
+                  this._index = 0;
+                  this._keys = keys;
+                  this._values = values;
+                  this._selector = selector;
+                }
+                MapIterator2.prototype["@@iterator"] = function() {
+                  return this;
+                };
+                MapIterator2.prototype[iteratorSymbol] = function() {
+                  return this;
+                };
+                MapIterator2.prototype.next = function() {
+                  var index = this._index;
+                  if (index >= 0 && index < this._keys.length) {
+                    var result = this._selector(this._keys[index], this._values[index]);
+                    if (index + 1 >= this._keys.length) {
+                      this._index = -1;
+                      this._keys = arraySentinel;
+                      this._values = arraySentinel;
+                    } else {
+                      this._index++;
+                    }
+                    return { value: result, done: false };
+                  }
+                  return { value: void 0, done: true };
+                };
+                MapIterator2.prototype.throw = function(error) {
+                  if (this._index >= 0) {
+                    this._index = -1;
+                    this._keys = arraySentinel;
+                    this._values = arraySentinel;
+                  }
+                  throw error;
+                };
+                MapIterator2.prototype.return = function(value) {
+                  if (this._index >= 0) {
+                    this._index = -1;
+                    this._keys = arraySentinel;
+                    this._values = arraySentinel;
+                  }
+                  return { value, done: true };
+                };
+                return MapIterator2;
+              }()
+            );
+            var Map2 = (
+              /** @class */
+              function() {
+                function Map3() {
+                  this._keys = [];
+                  this._values = [];
+                  this._cacheKey = cacheSentinel;
+                  this._cacheIndex = -2;
+                }
+                Object.defineProperty(Map3.prototype, "size", {
+                  get: function() {
+                    return this._keys.length;
+                  },
+                  enumerable: true,
+                  configurable: true
+                });
+                Map3.prototype.has = function(key) {
+                  return this._find(
+                    key,
+                    /*insert*/
+                    false
+                  ) >= 0;
+                };
+                Map3.prototype.get = function(key) {
+                  var index = this._find(
+                    key,
+                    /*insert*/
+                    false
+                  );
+                  return index >= 0 ? this._values[index] : void 0;
+                };
+                Map3.prototype.set = function(key, value) {
+                  var index = this._find(
+                    key,
+                    /*insert*/
+                    true
+                  );
+                  this._values[index] = value;
+                  return this;
+                };
+                Map3.prototype.delete = function(key) {
+                  var index = this._find(
+                    key,
+                    /*insert*/
+                    false
+                  );
+                  if (index >= 0) {
+                    var size = this._keys.length;
+                    for (var i = index + 1; i < size; i++) {
+                      this._keys[i - 1] = this._keys[i];
+                      this._values[i - 1] = this._values[i];
+                    }
+                    this._keys.length--;
+                    this._values.length--;
+                    if (SameValueZero(key, this._cacheKey)) {
+                      this._cacheKey = cacheSentinel;
+                      this._cacheIndex = -2;
+                    }
+                    return true;
+                  }
+                  return false;
+                };
+                Map3.prototype.clear = function() {
+                  this._keys.length = 0;
+                  this._values.length = 0;
+                  this._cacheKey = cacheSentinel;
+                  this._cacheIndex = -2;
+                };
+                Map3.prototype.keys = function() {
+                  return new MapIterator(this._keys, this._values, getKey);
+                };
+                Map3.prototype.values = function() {
+                  return new MapIterator(this._keys, this._values, getValue);
+                };
+                Map3.prototype.entries = function() {
+                  return new MapIterator(this._keys, this._values, getEntry);
+                };
+                Map3.prototype["@@iterator"] = function() {
+                  return this.entries();
+                };
+                Map3.prototype[iteratorSymbol] = function() {
+                  return this.entries();
+                };
+                Map3.prototype._find = function(key, insert) {
+                  if (!SameValueZero(this._cacheKey, key)) {
+                    this._cacheIndex = -1;
+                    for (var i = 0; i < this._keys.length; i++) {
+                      if (SameValueZero(this._keys[i], key)) {
+                        this._cacheIndex = i;
+                        break;
+                      }
+                    }
+                  }
+                  if (this._cacheIndex < 0 && insert) {
+                    this._cacheIndex = this._keys.length;
+                    this._keys.push(key);
+                    this._values.push(void 0);
+                  }
+                  return this._cacheIndex;
+                };
+                return Map3;
+              }()
+            );
+            return Map2;
+            function getKey(key, _) {
+              return key;
+            }
+            function getValue(_, value) {
+              return value;
+            }
+            function getEntry(key, value) {
+              return [key, value];
+            }
+          }
+          function CreateSetPolyfill() {
+            var Set2 = (
+              /** @class */
+              function() {
+                function Set3() {
+                  this._map = new _Map();
+                }
+                Object.defineProperty(Set3.prototype, "size", {
+                  get: function() {
+                    return this._map.size;
+                  },
+                  enumerable: true,
+                  configurable: true
+                });
+                Set3.prototype.has = function(value) {
+                  return this._map.has(value);
+                };
+                Set3.prototype.add = function(value) {
+                  return this._map.set(value, value), this;
+                };
+                Set3.prototype.delete = function(value) {
+                  return this._map.delete(value);
+                };
+                Set3.prototype.clear = function() {
+                  this._map.clear();
+                };
+                Set3.prototype.keys = function() {
+                  return this._map.keys();
+                };
+                Set3.prototype.values = function() {
+                  return this._map.keys();
+                };
+                Set3.prototype.entries = function() {
+                  return this._map.entries();
+                };
+                Set3.prototype["@@iterator"] = function() {
+                  return this.keys();
+                };
+                Set3.prototype[iteratorSymbol] = function() {
+                  return this.keys();
+                };
+                return Set3;
+              }()
+            );
+            return Set2;
+          }
+          function CreateWeakMapPolyfill() {
+            var UUID_SIZE = 16;
+            var keys = HashMap.create();
+            var rootKey = CreateUniqueKey();
+            return (
+              /** @class */
+              function() {
+                function WeakMap2() {
+                  this._key = CreateUniqueKey();
+                }
+                WeakMap2.prototype.has = function(target) {
+                  var table = GetOrCreateWeakMapTable(
+                    target,
+                    /*create*/
+                    false
+                  );
+                  return table !== void 0 ? HashMap.has(table, this._key) : false;
+                };
+                WeakMap2.prototype.get = function(target) {
+                  var table = GetOrCreateWeakMapTable(
+                    target,
+                    /*create*/
+                    false
+                  );
+                  return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+                };
+                WeakMap2.prototype.set = function(target, value) {
+                  var table = GetOrCreateWeakMapTable(
+                    target,
+                    /*create*/
+                    true
+                  );
+                  table[this._key] = value;
+                  return this;
+                };
+                WeakMap2.prototype.delete = function(target) {
+                  var table = GetOrCreateWeakMapTable(
+                    target,
+                    /*create*/
+                    false
+                  );
+                  return table !== void 0 ? delete table[this._key] : false;
+                };
+                WeakMap2.prototype.clear = function() {
+                  this._key = CreateUniqueKey();
+                };
+                return WeakMap2;
+              }()
+            );
+            function CreateUniqueKey() {
+              var key;
+              do
+                key = "@@WeakMap@@" + CreateUUID();
+              while (HashMap.has(keys, key));
+              keys[key] = true;
+              return key;
+            }
+            function GetOrCreateWeakMapTable(target, create) {
+              if (!hasOwn.call(target, rootKey)) {
+                if (!create)
+                  return void 0;
+                Object.defineProperty(target, rootKey, { value: HashMap.create() });
+              }
+              return target[rootKey];
+            }
+            function FillRandomBytes(buffer, size) {
+              for (var i = 0; i < size; ++i)
+                buffer[i] = Math.random() * 255 | 0;
+              return buffer;
+            }
+            function GenRandomBytes(size) {
+              if (typeof Uint8Array === "function") {
+                var array = new Uint8Array(size);
+                if (typeof crypto !== "undefined") {
+                  crypto.getRandomValues(array);
+                } else if (typeof msCrypto !== "undefined") {
+                  msCrypto.getRandomValues(array);
+                } else {
+                  FillRandomBytes(array, size);
+                }
+                return array;
+              }
+              return FillRandomBytes(new Array(size), size);
+            }
+            function CreateUUID() {
+              var data = GenRandomBytes(UUID_SIZE);
+              data[6] = data[6] & 79 | 64;
+              data[8] = data[8] & 191 | 128;
+              var result = "";
+              for (var offset = 0; offset < UUID_SIZE; ++offset) {
+                var byte = data[offset];
+                if (offset === 4 || offset === 6 || offset === 8)
+                  result += "-";
+                if (byte < 16)
+                  result += "0";
+                result += byte.toString(16).toLowerCase();
+              }
+              return result;
+            }
+          }
+          function MakeDictionary(obj) {
+            obj.__ = void 0;
+            delete obj.__;
+            return obj;
+          }
+        });
+      })(Reflect2 || (Reflect2 = {}));
+    }
+  });
+
   // src/bundle-entry.ts
   var bundle_entry_exports3 = {};
   __export(bundle_entry_exports3, {
@@ -1226,7 +2311,6 @@ var dooboostoreDomRender = (() => {
     isOnInitRender: () => isOnInitRender,
     isOnProxyDomRender: () => isOnProxyDomRender,
     isOnRawSetRendered: () => isOnRawSetRendered,
-    isPopStateCurrentTargetDomrenderRouter: () => isPopStateCurrentTargetDomrenderRouter,
     isWrapProxyDomRenderProxy: () => isWrapProxyDomRenderProxy
   });
   var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
@@ -4459,7 +5543,7 @@ var dooboostoreDomRender = (() => {
           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();
@@ -4671,6 +5755,74 @@ var dooboostoreDomRender = (() => {
     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 };
     };
@@ -6257,126 +7409,15 @@ var dooboostoreDomRender = (() => {
         }
       }
     }
-    // constructor(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, public avaliablePlace: Rectangle = new Rectangle(new Point(0, 0), new Point(0, 0))) {
-    //     super(canvas, context);
-    // }
-    // get centerPoint(): Point {
-    //     return new Point();
-    // }
-  };
-  _RenderTransactionDrawObj.DEFAULT_BEZIER = { p1x: 0.61, p1y: 1, p2x: 0.88, p2y: 1 };
-  var RenderTransactionDrawObj = _RenderTransactionDrawObj;
-
-  // ../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 = {}));
+    // constructor(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, public avaliablePlace: Rectangle = new Rectangle(new Point(0, 0), new Point(0, 0))) {
+    //     super(canvas, context);
+    // }
+    // get centerPoint(): Point {
+    //     return new Point();
+    // }
+  };
+  _RenderTransactionDrawObj.DEFAULT_BEZIER = { p1x: 0.61, p1y: 1, p2x: 0.88, p2y: 1 };
+  var RenderTransactionDrawObj = _RenderTransactionDrawObj;
 
   // ../core/dist/esm/expression/Expression.js
   var Expression;
@@ -6392,17 +7433,6 @@ var dooboostoreDomRender = (() => {
         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) => {
@@ -6858,6 +7888,48 @@ var dooboostoreDomRender = (() => {
       });
       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) {
@@ -8628,6 +9700,138 @@ ${indentStr}}`;
     }
   };
 
+  // ../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/dist/esm/transaction/TransactionManager.js
   var TransactionManager = class {
     constructor(transaction = /* @__PURE__ */ new Map()) {
@@ -8706,7 +9910,7 @@ ${indentStr}}`;
     ValidUtils: () => ValidUtils2,
     WindowUtils: () => WindowUtils
   });
-  var import_reflect_metadata = __toESM(require_Reflect(), 1);
+  var import_reflect_metadata = __toESM(require_Reflect2(), 1);
 
   // ../core/dist/esm/message/AutoCloseSubscription.js
   var AutoCloseSubscription = class {
@@ -10016,7 +11220,13 @@ ${indentStr}}`;
       this.procAttr(childNodes, _EventManager.normalAttrMapAttrName, (it, attribute2) => {
         const map2 = new Map(JSON.parse(attribute2));
         map2.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)
@@ -10206,7 +11416,7 @@ ${indentStr}}`;
       });
     }
     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);
       }
@@ -10308,6 +11518,7 @@ ${indentStr}}`;
   _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,
@@ -10441,7 +11652,7 @@ ${indentStr}}`;
       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)})) {
@@ -10954,7 +12165,7 @@ ${indentStr}}`;
     }
     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 ?? ""}
@@ -11074,7 +12285,10 @@ ${indentStr}}`;
       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; 
@@ -11097,11 +12311,18 @@ ${indentStr}}`;
                                 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);
@@ -11124,12 +12345,16 @@ ${indentStr}}`;
                             }
 
                             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 {
@@ -11688,7 +12913,8 @@ ${indentStr}}`;
           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(";");
@@ -11749,12 +12975,18 @@ ${indentStr}}`;
           const runText = _RawSet.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);
@@ -11793,23 +13025,140 @@ ${indentStr}}`;
           };
           drAttrs.push(drAttr);
           const operators = [
-            new DrPre(this, __render, { raws, fag }, { element, attrName: _RawSet.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: _RawSet.DR_NAME, attr: drAttr.dr, attrs: drAttr }, { config, obj, operatorAround: config.operatorAround?.dr }, { onAttrInitCallBacks, onElementInitCallBacks, onThisComponentSetCallBacks }),
+            new DrPre(
+              this,
+              __render,
+              { raws, fag },
+              { element, attrName: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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: _RawSet.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();
@@ -11849,12 +13198,12 @@ ${indentStr}}`;
       });
       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);
       }
@@ -11956,7 +13305,10 @@ ${indentStr}}`;
     getDrAppendAttributeAndDelete(element, obj) {
       let data = element.getAttribute(_RawSet.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(_RawSet.DR_APPENDER_NAME, data);
       }
@@ -12002,22 +13354,28 @@ ${indentStr}}`;
             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 && _RawSet.isExpression(value)) {
-                let variablePath = _RawSet.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 = _RawSet.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;
@@ -12431,11 +13789,33 @@ ${indentStr}}`;
       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(_RawSet.DR_COMPONENT_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+      const innerText = element.textContent?.trim() ?? "";
+      const escapedInnerHTML = ConvertUtils.escapeHTML(element.innerHTML);
+      const innerHTMLName = targetElement.getAttribute(_RawSet.DR_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+      const innerTEXTName = targetElement.getAttribute(_RawSet.DR_INNER_TEXT_NAME_OPTIONNAME) ?? "innerTEXT";
+      const innerHTMLEscapedName = targetElement.getAttribute(_RawSet.DR_INNER_HTML_ESCAPED_NAME_OPTIONNAME) ?? "innerHTMLEscaped";
+      const templateReplacements = [];
       if (innerHTMLName) {
-        _RawSet.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(_RawSet.DR_THIS_NAME_OPTIONNAME);
       targetElement.getAttributeNames().forEach((it) => targetElement.setAttribute(it, targetElement.getAttribute(it).replace(/#this#/g, drThis)));
@@ -12512,7 +13892,6 @@ ${indentStr}}`;
           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; 
@@ -12567,15 +13946,40 @@ ${indentStr}}`;
           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(_RawSet.DR_COMPONENT_NAME_OPTIONNAME) ?? "component";
-          const innerHTMLName = element.getAttribute(_RawSet.DR_COMPONENT_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+          const componentName = element.getAttribute(_RawSet.DR_VARIABLE_NAME_OPTIONNAME) ?? "component";
+          const innerHTMLName = element.getAttribute(_RawSet.DR_INNER_HTML_NAME_OPTIONNAME) ?? "innerHTML";
+          const innerTEXTName = element.getAttribute(_RawSet.DR_INNER_TEXT_NAME_OPTIONNAME) ?? "innerTEXT";
+          const innerHTMLEscapedName = element.getAttribute(_RawSet.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 = _RawSet.generateStyleTransform(this.styles, rawSet.uuid, true);
           element.innerHTML = style + (applayTemplate ?? "");
           let data = await _RawSet.drThisCreate(
@@ -12589,8 +13993,8 @@ ${indentStr}}`;
           );
           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;
@@ -12627,8 +14031,24 @@ ${indentStr}}`;
       const normalAttribute = attribute2[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)
           );
           attribute2[k] = cval;
@@ -12671,11 +14091,12 @@ ${indentStr}}`;
   _RawSet.DR_STRIP_OPTIONNAME = "dr-option-strip";
   _RawSet.DR_DESTROY_OPTIONNAME = "dr-option-destroy";
   _RawSet.DR_THIS_NAME_OPTIONNAME = "dr-option-this-name";
-  /**
-   * @deprecated
-   */
-  _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";
@@ -12773,7 +14194,20 @@ ${indentStr}}`;
   };
 
   // src/DomRenderProxy.ts
-  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;
   };
@@ -12816,7 +14250,7 @@ ${indentStr}}`;
     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);
@@ -12841,18 +14275,18 @@ ${indentStr}}`;
           }
         });
       }
-      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];
         }
@@ -12865,7 +14299,11 @@ ${indentStr}}`;
       }
       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) {
@@ -12876,16 +14314,20 @@ ${indentStr}}`;
           });
         }
       });
-      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();
@@ -12918,9 +14360,12 @@ ${indentStr}}`;
           } else if (it.type === "TARGET_ELEMENT" /* TARGET_ELEMENT */ && it.dataSet?.render?.currentThis && fullPathStr && targetAttrMap) {
             new Map(JSON.parse(targetAttrMap)).forEach((v, k) => {
               var _a2;
-              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 })
+                });
                 (_a2 = it.dataSet).render ?? (_a2.render = {});
                 it.dataSet.render.attribute = targetAttrObject;
                 if (isOnChangeAttrRender(it.dataSet?.render?.currentThis)) {
@@ -12964,7 +14409,11 @@ ${indentStr}}`;
             it.forEach((sit) => {
               try {
                 const concat2 = pathInfos.concat([[{ path: sit, obj: key }]]);
-                const items = key._DomRender_proxy?.root(concat2, value, lastDoneExecute);
+                const items = key._DomRender_proxy?.root(
+                  concat2,
+                  value,
+                  lastDoneExecute
+                );
                 fullPaths.push(items.flat());
               } catch (e) {
               }
@@ -13000,10 +14449,19 @@ ${indentStr}}`;
                 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);
                   }
@@ -13023,10 +14481,19 @@ ${indentStr}}`;
             } 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)) {
@@ -13058,49 +14525,64 @@ ${indentStr}}`;
         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;
@@ -13120,7 +14602,11 @@ ${indentStr}}`;
           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;
       }
@@ -13221,7 +14707,6 @@ ${indentStr}}`;
   };
 
   // src/routers/Router.ts
-  var isPopStateCurrentTargetDomrenderRouter = (obj) => obj?.currentTargetName === "domRenderRouter";
   var Router = class {
     constructor(config) {
       this._config = config;
@@ -13232,19 +14717,18 @@ ${indentStr}}`;
           url: config.firstUrl,
           path: path[0],
           searchParams: new URLSearchParams(path[1] ?? ""),
-          router: this
+          router: this,
+          triggerPoint: "end"
         };
         this.behaviorSubject = new BehaviorSubject(routeData);
         this.go(config.firstUrl);
       } else {
-        routeData = this.getRouteData();
+        routeData = { ...this.getRouteData(), triggerPoint: "end" };
         this.behaviorSubject = new BehaviorSubject(routeData);
       }
       this.config.window.addEventListener("popstate", (event) => {
-        if (!isPopStateCurrentTargetDomrenderRouter(event.state)) {
-          const routeData2 = this.getRouteData();
-          this.behaviorSubject.next(routeData2);
-        }
+        const routeData2 = { ...this.getRouteData(), triggerPoint: "end" };
+        this.behaviorSubject.next(routeData2);
       });
     }
     get observable() {
@@ -13286,9 +14770,30 @@ ${indentStr}}`;
       }
     }
     getRouteData(config) {
+      let path = "";
+      let url = "";
+      if (config?.pathOrUrl) {
+        let isUrl = false;
+        try {
+          new URL(config.pathOrUrl);
+          isUrl = true;
+        } catch {
+          isUrl = false;
+        }
+        if (isUrl) {
+          const u = new URL(config.pathOrUrl);
+          path = u.pathname;
+          url = u.pathname + u.search;
+        } else {
+          path = config.pathOrUrl.split("?")[0];
+        }
+      } else {
+        path = this.getPathName();
+        url = this.getUrl();
+      }
       const newVar = {
-        path: this.getPathName(),
-        url: this.getUrl(),
+        path,
+        url,
         searchParams: this.getSearchParams()
       };
       const data = this.getData();
@@ -13302,32 +14807,40 @@ ${indentStr}}`;
         }
       }
       newVar.router = this;
-      newVar.currentTarget = config?.currentTarget;
       return Object.freeze(newVar);
     }
     pushState(data, title, path) {
-      this.config.window.history.pushState(data, title ?? "", path);
-      this.behaviorSubject.next(this.getRouteData({ currentTarget: { currentTargetName: "domRenderRouter" } }));
+      this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      this.config.window.history?.pushState(data, title ?? "", path);
+      this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
       return { data };
     }
     replaceState(data, title, path) {
-      this.config.window.history.replaceState(data, title ?? "", path);
-      this.behaviorSubject.next(this.getRouteData({ currentTarget: { currentTargetName: "domRenderRouter" } }));
+      this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      this.config.window.history?.replaceState(data, title ?? "", path);
+      this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
       return { data };
     }
-    dispatchPopStateEvent(data) {
-      this.config.window.dispatchEvent(new PopStateEvent("popstate", { state: { ...data, currentTargetName: "domRenderRouter" } }));
-    }
-    reload(data) {
-      this.config.window.dispatchEvent(new PopStateEvent("popstate", { state: data }));
-    }
     getData() {
-      return this.config.window.history.state;
+      return this.config.window.history?.state;
     }
     getPathData(urlExpression, currentUrl = this.getPathName()) {
       return Expression.Path.pathNameData(currentUrl, urlExpression);
     }
-    async go(config) {
+    back() {
+      this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+      this.config.window.history.back();
+    }
+    forward() {
+      this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+      this.config.window.history?.forward();
+    }
+    go(config) {
+      if (typeof config === "number") {
+        this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+        this.config.window.history?.go(config);
+        return;
+      }
       if (typeof config === "string") {
         config = { path: config };
       }
@@ -13342,11 +14855,9 @@ ${indentStr}}`;
         } catch (e) {
         }
       }
-      if (!config.disabledPopEvent) {
-        this.dispatchPopStateEvent(config?.data);
-      }
     }
     toUrl(data) {
+      console.log("toUrl", data);
       let targetPath;
       if (typeof data === "string") {
         targetPath = data;
@@ -13365,7 +14876,10 @@ ${indentStr}}`;
       super(config);
     }
     getSearchParams(data) {
-      const searchParams = new URL(this.config.window.document.location.href).searchParams;
+      if (!this.config.window.document?.location?.href) {
+        return new URLSearchParams();
+      }
+      const searchParams = new URL(this.config.window.document.location?.href).searchParams;
       data?.delete?.forEach((it) => {
         searchParams.delete(it);
       });
@@ -13387,7 +14901,7 @@ ${indentStr}}`;
     pushDeleteHashSearchParam(name, data, title) {
       const s = this.getHashSearchParams({ delete: [name] });
       const size = Array.from(s.entries()).length;
-      const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? "#" + s.toString() : ""}`;
+      const href = `${this.config.window.location?.pathname ?? "/"}${this.config.window.location?.search}${size > 0 ? "#" + s.toString() : ""}`;
       super.pushState(data, title, href);
     }
     pushAddSearchParam(params, data, title) {
@@ -13401,7 +14915,7 @@ ${indentStr}}`;
     replaceDeleteHashSearchParam(name, data, title) {
       const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
       const size = Array.from(s.entries()).length;
-      const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? "#" + s.toString() : ""}`;
+      const href = `${this.config.window.location?.pathname ?? "/"}${this.config.window.location?.search}${size > 0 ? "#" + s.toString() : ""}`;
       super.replaceState(data, title, href);
     }
     replaceAddSearchParam(params, data, title) {
@@ -13409,17 +14923,20 @@ ${indentStr}}`;
       this.replace({ searchParams: s }, data, title);
     }
     getUrl() {
-      const url = new URL(this.config.window.document.location.href);
+      if (!this.config.window.document?.location?.href) {
+        return "/";
+      }
+      const url = new URL(this.config.window.document.location?.href);
       return url.pathname + url.search;
     }
     getHref() {
-      return this.config.window.location.href;
+      return this.config.window.location?.href ?? "/";
     }
     getPathName() {
-      return this.config.window.location.pathname;
+      return this.config.window.location?.pathname ?? "/";
     }
     getHashSearchParams(data) {
-      const searchParams = new URLSearchParams(this.config.window.location.hash.slice(1));
+      const searchParams = new URLSearchParams(this.config.window.location?.hash.slice(1) ?? "");
       data?.delete?.forEach((it) => {
         searchParams.delete(it);
       });
@@ -13837,10 +15354,10 @@ ${indentStr}}`;
         if (typeof method === "function") {
           const paramTypes = ReflectUtils.getParameterTypes(this, propertyKey);
           if (paramTypes && paramTypes.length > 0 && paramTypes[0] === Array) {
-            method.call(this, processedNewElements, processedElements);
+            method.call(this, processedNewElements, { all: processedElements });
           } else {
             if (processedNewElements.length > 0) {
-              method.call(this, processedNewElements[0]);
+              method.call(this, processedNewElements[0], { all: processedElements, newAll: processedNewElements });
             }
           }
         }
@@ -14097,7 +15614,7 @@ ${indentStr}}`;
       return (this.render ?? this.rawSet?.dataSet?.render)?.getElement?.();
     }
     getFirstChild(type) {
-      return this._children.find((it) => it instanceof type)?.instance;
+      return this._children.find((it) => it.instance instanceof type)?.instance;
     }
     getParentThis() {
       return this.render?.parentThis;
@@ -14161,7 +15678,7 @@ ${indentStr}}`;
         }
       }
     }
-    onInitRender(param, rawSet) {
+    async onInitRender(param, rawSet) {
       this.createChildrenDebounceSubscription = this.childrenSetSubject.pipe(debounceTime(this.componentConfig?.createChildrenDebounce ?? 0)).subscribe((it) => {
         this.onCreatedThisChildDebounce(it);
       });
@@ -14244,8 +15761,8 @@ ${indentStr}}`;
       setValue(value) {
         this.value = value;
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         const c = this.getParentThis();
         const userValue = this.getAttribute("value");
         if (userValue) {
@@ -14436,9 +15953,6 @@ ${indentStr}}`;
       // test() {
       //   console.log('t', this.getAttribute('appender'))
       // }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
-      }
       // push(...data:D[]) {
       //   console.log('push/////', data);
       //   this.appender.push(...data);
@@ -14608,7 +16122,9 @@ ${indentStr}}`;
         super.onChangeAttrRender(name, value, other);
         if (this.equalsAttributeName(name, "data")) {
           this.choose = void 0;
-          const children = this.getChildren([When, OtherWise]).sort((a, b) => (a instanceof OtherWise ? 1 : 0) - (b instanceof OtherWise ? 1 : 0));
+          const children = this.getChildren([When, OtherWise]).sort(
+            (a, b) => (a instanceof OtherWise ? 1 : 0) - (b instanceof OtherWise ? 1 : 0)
+          );
           children.forEach((it) => this.setChange(it));
         }
       }
@@ -14717,8 +16233,8 @@ ${indentStr}}`;
           toggleAttribute?.(element.open);
         }
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         if (ValidUtils2.isBrowser() && this.rawSet?.dataSet.config.window) {
           const detailsElement = this.element;
           const document2 = this.rawSet.dataSet.config.window.document;
@@ -14857,7 +16373,7 @@ ${indentStr}}`;
         super(...arguments);
         this.sw = false;
       }
-      onInitRender(param, rawSet) {
+      async onInitRender(param, rawSet) {
         super.onInitRender(param, rawSet);
       }
       onChangeAttrRender(name, value, other) {
@@ -14873,7 +16389,7 @@ ${indentStr}}`;
     if: (config) => {
       return RawSet.createComponentTargetElement({
         name: If.selector,
-        template: '<div dr-if="@this@.sw" dr-option-strip="true">#innerHTML#</div>',
+        template: '<div dr-if="@this@.sw" >#innerHTML#</div>',
         objFactory: (e, o, r2, counstructorParam) => {
           return DomRender.run({ rootObject: new If.If(...counstructorParam), config });
         }
@@ -14943,8 +16459,8 @@ ${indentStr}}`;
     class Input2 extends Base {
       onCreateRender(...param) {
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         const inputElement = this.element;
         const debounceTimeAttribute = this.getAttribute("debounceTime");
         const debounceTimeValue = ValidUtils.isNotNullUndefined(debounceTimeAttribute) ? Number(debounceTimeAttribute) : 0;
@@ -15058,16 +16574,16 @@ ${indentStr}}`;
         const rejecteds = this.getChildren(Rejected);
         const full = [...fulfilleds, ...rejecteds, ...pendings, ...defaults];
         if (this.promiseState === void 0) {
-          this.status = void 0;
+          this.state = void 0;
           full.filter((it) => !it.hidden).forEach((it) => it.hidden = true);
           defaults.filter((it) => it.hidden).forEach((it) => it.hidden = false);
           pendings.filter((it) => it.getAttribute("defaultView") && it.hidden).forEach((it) => it.hidden = false);
         } else if (this.promiseState.status === "pending") {
-          this.status = "pending";
+          this.state = "pending";
           full.filter((it) => !it.hidden).forEach((it) => it.hidden = true);
           pendings.filter((it) => it.hidden).forEach((it) => it.hidden = false);
         } else if (this.promiseState.status === "fulfilled") {
-          this.status = "fulfilled";
+          this.state = "fulfilled";
           const value = this.promiseState.value;
           full.filter((it) => !it.hidden).forEach((it) => it.hidden = true);
           fulfilleds.forEach((it) => {
@@ -15075,7 +16591,7 @@ ${indentStr}}`;
           });
           fulfilleds.filter((it) => it.hidden).forEach((it) => it.hidden = false);
         } else if (this.promiseState.status === "rejected") {
-          this.status = "rejected";
+          this.state = "rejected";
           const value = this.promiseState.reason;
           full.filter((it) => !it.hidden).forEach((it) => it.hidden = true);
           rejecteds.forEach((it) => {
@@ -15083,13 +16599,13 @@ ${indentStr}}`;
           });
           rejecteds.filter((it) => it.hidden).forEach((it) => it.hidden = false);
         }
-        return this.status;
+        return this.state;
       }
       onChangeAttrRender(name, value, other) {
         super.onChangeAttrRender(name, value, other);
         if (this.equalsAttributeName(name, "data") && value) {
           this.promiseState = void 0;
-          this.status = void 0;
+          this.state = void 0;
           this.promiseState = Promises.Result.wrap(typeof value === "function" ? value() : value);
           this.getAttribute("change")?.({ status: "pending" });
           this.childStateChange();
@@ -15285,8 +16801,8 @@ ${indentStr}}`;
         this.sw = false;
         this.inputDomRenderConfig = domRenderConfig;
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         this.routerSubscription = this.inputDomRenderConfig?.router?.observable.subscribe((it) => {
           if (this.value && this.inputDomRenderConfig) {
             this.sw = this.check(this.inputDomRenderConfig);
@@ -15426,8 +16942,8 @@ ${indentStr}}`;
         this.disabled = false;
         this.classAttr = null;
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         this.updateStatus();
       }
       // onCreatedThisChild(child: any, data: OnCreateRenderDataParams) {
@@ -15551,8 +17067,8 @@ ${indentStr}}`;
           }
         }
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
       }
       onInitSummaryElement(element, event) {
         this.element = element;
@@ -15643,8 +17159,8 @@ ${indentStr}}`;
       }
       onCreateRenderData() {
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         if (ValidUtils2.isBrowser() && this.rawSet?.dataSet.config.window) {
           const detailsElement = this.element;
           const window2 = this.rawSet.dataSet.config.window;
@@ -15807,8 +17323,8 @@ ${indentStr}}`;
         super(...arguments);
         this.if = null;
       }
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
       }
       onDestroyRender(data) {
         super.onDestroyRender(data);
@@ -15849,8 +17365,8 @@ ${indentStr}}`;
   ((_Timer) => {
     _Timer.selector = "dr-timer";
     class Timer2 extends ComponentBase {
-      onInitRender(param, rawSet) {
-        super.onInitRender(param, rawSet);
+      async onInitRender(param, rawSet) {
+        await super.onInitRender(param, rawSet);
         this.getAttribute("onCreated")?.(this);
       }
       isRunning() {
@@ -15863,7 +17379,6 @@ ${indentStr}}`;
           const intervalValue = this.getAttribute("interval") ?? 1e3;
           console.log("int", this.value, intervalValue);
           this.interval = setInterval(() => {
-            console.log("--------->", this.value);
             if (this.value) {
               this.value--;
             } else {
@@ -16487,6 +18002,22 @@ ${indentStr}}`;
 })();
 /*! Bundled license information:
 
+reflect-metadata/Reflect.js:
+  (*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+
 reflect-metadata/Reflect.js:
   (*! *****************************************************************************
   Copyright (C) Microsoft. All rights reserved.