@dooboostore/dom-render 1.0.109 → 1.0.110

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

@@ -1113,6 +1113,1091 @@ var require_Reflect = __commonJS({
   }
 });
 
+// ../../../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 import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
@@ -4344,7 +5429,7 @@ var ObjectUtils;
         const func = new Function("window", "document", "console", `"use strict"; ${script}; `);
         func.call(destUser, globalContext.window, globalContext.document, globalContext.console);
       } catch (e) {
-        console.error("detectPathFromScript error:", e);
+        console.error("detectPathFromScript error:", script, e);
       }
       if (options?.excludeThis) {
         const filteredVars = /* @__PURE__ */ new Set();
@@ -4556,6 +5641,74 @@ var ConvertUtils;
   ConvertUtils22.decodeHTMLEscape = (data) => {
     return data.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x2F;/g, "/");
   };
+  function escapeHTML(htmlString, option) {
+    if (!htmlString) return "";
+    const escapeMap = {
+      "&": "&amp;",
+      // 반드시 먼저 처리
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;",
+      // or &apos; (하지만 HTML4에서는 &#39; 권장)
+      "/": "&#x2F;",
+      "`": "&#x60;",
+      "=": "&#x3D;",
+      "{": "&#123;",
+      "}": "&#125;",
+      "#": "&#35;",
+      "$": "&#36;",
+      "\n": "&#10;",
+      // newline
+      "\r": "&#13;",
+      // carriage return
+      "	": "&#9;",
+      // tab
+      "\xA0": "&nbsp;",
+      // non-breaking space
+      "\xA2": "&cent;",
+      "\xA3": "&pound;",
+      "\xA5": "&yen;",
+      "\u20AC": "&euro;",
+      "\xA9": "&copy;",
+      "\xAE": "&reg;",
+      "\u2122": "&trade;",
+      "\xB0": "&deg;",
+      "\xB1": "&plusmn;",
+      "\xD7": "&times;",
+      "\xF7": "&divide;",
+      "\u2212": "&minus;",
+      "\u2022": "&bull;",
+      "\u2026": "&hellip;",
+      "\u2190": "&larr;",
+      "\u2192": "&rarr;",
+      "\u2191": "&uarr;",
+      "\u2193": "&darr;",
+      "\u2194": "&harr;"
+    };
+    const targetsSet = option?.targets ? new Set(option.targets) : null;
+    const filteredEscapeMap = targetsSet ? Object.fromEntries(Object.entries(escapeMap).filter(([key]) => targetsSet.has(key))) : escapeMap;
+    const shouldEscapeAmpersand = !targetsSet || targetsSet.has("&");
+    const charsToEscape = Object.keys(filteredEscapeMap).filter((char) => char !== "&");
+    if (charsToEscape.length === 0 && !shouldEscapeAmpersand) {
+      return htmlString;
+    }
+    const escapedChars = charsToEscape.map((char) => {
+      return char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    let result = htmlString;
+    if (shouldEscapeAmpersand) {
+      result = result.replace(/&/g, "&amp;");
+    }
+    if (escapedChars.length > 0) {
+      const regex = new RegExp(`[${escapedChars}]`, "g");
+      result = result.replace(regex, (match) => {
+        return filteredEscapeMap[match] || match;
+      });
+    }
+    return result;
+  }
+  ConvertUtils22.escapeHTML = escapeHTML;
   ConvertUtils22.copyObject = (obj, update = {}) => {
     return { ...obj, ...update };
   };
@@ -6142,126 +7295,15 @@ var _RenderTransactionDrawObj = class _RenderTransactionDrawObj2 extends RenderD
       }
     }
   }
-  // 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;
@@ -6277,17 +7319,6 @@ var Expression;
       return binder;
     });
   };
-  let Group;
-  ((Group2) => {
-    Group2.isExpression = (data) => {
-      const reg = /[$#]\{([\s\S.]*?)\}[$#]/g;
-      return reg.test(data ?? "");
-    };
-    Group2.expressionGroups = (data) => {
-      const reg = /[$#]\{([\s\S.]*?)\}[$#]/g;
-      return StringUtils.regexExec(reg, data ?? "");
-    };
-  })(Group = Expression2.Group || (Expression2.Group = {}));
   let Path;
   ((Path2) => {
     Path2.pathNameData = (pathName, urlExpression) => {
@@ -6743,6 +7774,48 @@ var Promises;
     });
     return { promise, resolve, reject };
   };
+  Promises2.executeInChunks = async (promiseFactories, chunkSize = 10) => {
+    const results = [];
+    for (let i = 0; i < promiseFactories.length; i += chunkSize) {
+      const chunk = promiseFactories.slice(i, i + chunkSize);
+      const chunkResults = await Promise.all(chunk.map((factory) => factory()));
+      results.push(...chunkResults);
+      if (i + chunkSize < promiseFactories.length) {
+        await (0, Promises2.sleep)(100);
+      }
+    }
+    return results;
+  };
+  Promises2.executeWithConcurrency = async (promiseFactories, concurrency = 10) => {
+    const results = new Array(promiseFactories.length);
+    let currentIndex = 0;
+    const executeNext = async (index) => {
+      while (currentIndex < promiseFactories.length) {
+        const factoryIndex = currentIndex++;
+        results[factoryIndex] = await promiseFactories[factoryIndex]();
+      }
+    };
+    const workers = Array(Math.min(concurrency, promiseFactories.length)).fill(0).map((_, i) => executeNext(i));
+    await Promise.all(workers);
+    return results;
+  };
+  Promises2.executeWithLimit = async (promiseFactories, limit = 5) => {
+    const results = new Array(promiseFactories.length);
+    const executing = [];
+    for (const [index, factory] of promiseFactories.entries()) {
+      const promise = factory().then((result) => {
+        results[index] = result;
+      }).finally(() => {
+        executing.splice(executing.indexOf(promise), 1);
+      });
+      executing.push(promise);
+      if (executing.length >= limit) {
+        await Promise.race(executing);
+      }
+    }
+    await Promise.all(executing);
+    return results;
+  };
   let Result;
   ((Result2) => {
     async function awaitWrap(promise) {
@@ -8513,6 +9586,138 @@ var StorageUtils = class _StorageUtils {
   }
 };
 
+// ../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()) {
@@ -8591,7 +9796,7 @@ __export(bundle_entry_exports2, {
   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 {
@@ -9901,7 +11106,13 @@ var _EventManager = class _EventManager {
     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)
@@ -10091,7 +11302,7 @@ var _EventManager = class _EventManager {
     });
   }
   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);
     }
@@ -10193,6 +11404,7 @@ _EventManager.VARNAMES = [_EventManager.SCRIPTS_VARNAME, _EventManager.FAG_VARNA
 _EventManager.WINDOW_EVENT_POPSTATE = "popstate";
 _EventManager.WINDOW_EVENT_RESIZE = "resize";
 _EventManager.WINDOW_EVENTS = [_EventManager.WINDOW_EVENT_POPSTATE, _EventManager.WINDOW_EVENT_RESIZE];
+_EventManager.noDetectAttr = [_EventManager.normalAttrMapAttrName];
 _EventManager.attrNames = [
   _EventManager.valueAttrName,
   _EventManager.checkedAttrName,
@@ -10326,7 +11538,7 @@ var DrIf = class extends OperatorExecuterAttrRequire {
     const itRandom = RawSet.drItOtherEncoding(this.elementSource.element, "DrIf");
     const vars = RawSet.drVarEncoding(this.elementSource.element, this.elementSource.attrs.drVarOption ?? "");
     const newTemp = this.source.config.window.document.createElement("temp");
-    const keepgoing = ScriptUtils.evaluate(`
+    const keepgoing = ObjectUtils.Script.evaluate(`
                 ${this.render.bindScript}
                 ${this.elementSource.attrs.drBeforeOption ?? ""}
                 if ($rawSet.data === (${ObjectUtils.Path.toOptionalChainPath(attr)})) {
@@ -10839,7 +12051,7 @@ var DrInnerText = class extends OperatorExecuterAttrRequire {
   }
   async executeAttrRequire(attr) {
     const newTemp = this.source.config.window.document.createElement("temp");
-    ScriptUtils.evaluate(` 
+    ObjectUtils.Script.evaluate(` 
                         ${this.render.bindScript}
                         const n = $element.cloneNode(true);  
                         ${this.elementSource.attrs.drBeforeOption ?? ""}
@@ -10959,7 +12171,10 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
     const itRandom = RawSet.drItOtherEncoding(this.elementSource.element, "DrForOf");
     const vars = RawSet.drVarEncoding(this.elementSource.element, this.elementSource.attrs.drVarOption ?? "");
     const newTemp = this.source.config.window.document.createElement("temp");
-    ScriptUtils.evaluate(`
+    const variableName = this.elementSource.element.getAttribute(RawSet.DR_VARIABLE_NAME_OPTIONNAME);
+    const itemVariableName = this.elementSource.element.getAttribute(RawSet.DR_ITEM_VARIABLE_NAME_OPTIONNAME);
+    const itemIndexVariableName = this.elementSource.element.getAttribute(RawSet.DR_ITEM_INDEX_VARIABLE_NAME_OPTIONNAME);
+    ObjectUtils.Script.evaluate(`
                     ${this.render.bindScript}
                     ${this.elementSource.attrs.drBeforeOption ?? ""}
                     var i = -1; 
@@ -10982,11 +12197,18 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
                                 destIt = forOfStr + '[' + i +']'
                             }
                             const n = this.__render.element.cloneNode(true);
-                            // console.log('zzzzzzzzzzz', n.getAttribute('${RawSet.DR_DETECT_ATTR_OPTIONNAME}'));
                             Object.entries(this.__render.drAttr).filter(([k,v]) => k !== 'drForOf' && k !== 'drNextOption' && v).forEach(([k, v]) => n.setAttribute(this.__render.drAttrsOriginName[k], v));
-                            // console.log('---------'+destIt,n, Array.from(n.getAttributeNames()).map(it=>({name:it,attr: n.getAttribute(it)})));
-                            // console.log('---------destItdestIt',destIt);
                             n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replace(/\\#it\\#/g, destIt).replace(/\\#nearForOfIt\\#/g, destIt).replace(/\\#it\\#/g, destIt).replace(/\\#nearForOfIndex\\#/g, i)))
+                            if ('${variableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${variableName}#', forOfStr)));
+                            }
+                            if ('${itemVariableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${itemVariableName}#', destIt)));
+                            }
+                            if ('${itemIndexVariableName}') {
+                              n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replaceAll('#${itemIndexVariableName}#', i)));
+                            }
+                            
                             const drOptionAttr = n.getAttribute('${RawSet.DR_DETECT_ATTR_OPTIONNAME}');
                             if (drOptionAttr) {
                               const drOptionAttrResult = $scriptUtils.evaluateReturn(drOptionAttr, this);
@@ -11009,12 +12231,16 @@ var DrForOf = class extends OperatorExecuterAttrRequire {
                             }
 
                             n.innerHTML = n.innerHTML.replace(/\\#it\\#/g, destIt).replace(/\\#index\\#/g, i);
-                            // console.log('!@@@@', n.innerHTML);
-                            // DR_THIS_OPTIONNAME \uB294 \uC81C\uAC70\uD55C\uB2E4 \uAF2C\uC778\uB2E4. strip \uD560\uB54C \uB9C9 \uAF2C\uC5EC\uBC84\uB9B0\uB2E4.
-                            // const drOptionThis = n.getAttribute('${RawSet.DR_THIS_OPTIONNAME}');
-                            // if (drOptionThis) {
-                            //  n.setAttribute('${RawSet.DR_THIS_NAME}', drOptionThis)
-                            // }
+                            if ('${variableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${variableName}#', forOfStr);
+                            }
+                            if ('${itemVariableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${itemVariableName}#', destIt);
+                            }
+                            if ('${itemIndexVariableName}') {
+                              n.innerHTML = n.innerHTML.replaceAll('#${itemIndexVariableName}#', i);
+                            }
+                   
                             if (this.__render.drStripOption === 'true') {
                                 Array.from(n.childNodes).forEach(it => this.__render.fag.append(it));
                             } else {
@@ -11573,7 +12799,8 @@ var _RawSet = class _RawSet {
         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(";");
@@ -11634,12 +12861,18 @@ var _RawSet = class _RawSet {
         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);
@@ -11678,23 +12911,140 @@ var _RawSet = class _RawSet {
         };
         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();
@@ -11734,12 +13084,12 @@ var _RawSet = class _RawSet {
     });
     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);
     }
@@ -11841,7 +13191,10 @@ var _RawSet = class _RawSet {
   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);
     }
@@ -11887,22 +13240,28 @@ var _RawSet = class _RawSet {
           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;
@@ -12316,11 +13675,33 @@ var _RawSet = class _RawSet {
     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)));
@@ -12397,7 +13778,6 @@ var _RawSet = class _RawSet {
         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; 
@@ -12452,15 +13832,40 @@ var _RawSet = class _RawSet {
         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(
@@ -12474,8 +13879,8 @@ var _RawSet = class _RawSet {
         );
         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;
@@ -12512,8 +13917,24 @@ var _RawSet = class _RawSet {
     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;
@@ -12556,11 +13977,12 @@ _RawSet.DR_COMPLETE_OPTIONNAME = "dr-option-complete";
 _RawSet.DR_STRIP_OPTIONNAME = "dr-option-strip";
 _RawSet.DR_DESTROY_OPTIONNAME = "dr-option-destroy";
 _RawSet.DR_THIS_NAME_OPTIONNAME = "dr-option-this-name";
-/**
- * @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";
@@ -12658,7 +14080,20 @@ var isOnRawSetRendered = (obj) => {
 };
 
 // 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;
 };
@@ -12701,7 +14136,7 @@ var DomRenderProxy = class _DomRenderProxy {
   static isFinal(obj) {
     return ValidUtils.isNull(obj) || DomRenderFinalProxy.isFinal(obj);
   }
-  run(objProxy) {
+  async run(objProxy) {
     this._domRender_proxy = objProxy;
     if (isOnProxyDomRender(objProxy)) {
       objProxy.onProxyDomRender(this._domRender_config);
@@ -12726,18 +14161,18 @@ var DomRenderProxy = class _DomRenderProxy {
         }
       });
     }
-    this._targets.forEach((target) => {
-      this.initRender(target);
-    });
+    for (let target of this._targets) {
+      await this.initRender(target);
+    }
   }
-  initRender(target, rawSet) {
+  async initRender(target, rawSet) {
     if (target instanceof Element) {
       target.innerHTML = target.innerHTML.replace(/@this@/g, "this");
     }
     const onCreate = target.getAttribute?.(RawSet.DR_ON_CREATE_ARGUMENTS_OPTIONNAME);
     let createParam = [];
     if (onCreate) {
-      createParam = ScriptUtils.evaluateReturn(onCreate, this._domRender_proxy);
+      createParam = ObjectUtils.Script.evaluateReturn(onCreate, this._domRender_proxy);
       if (!Array.isArray(createParam)) {
         createParam = [createParam];
       }
@@ -12750,7 +14185,11 @@ var DomRenderProxy = class _DomRenderProxy {
     }
     this._targets.add(target);
     const rawSets = RawSet.checkPointCreates(target, this._domRender_proxy, this._domRender_config);
-    this._domRender_config.eventManager.applyEvent(this._domRender_proxy, this._domRender_config.eventManager.findAttrElements(target, this._domRender_config), this._domRender_config);
+    this._domRender_config.eventManager.applyEvent(
+      this._domRender_proxy,
+      this._domRender_config.eventManager.findAttrElements(target, this._domRender_config),
+      this._domRender_config
+    );
     rawSets.forEach((it) => {
       const variables = it.getUsingTriggerVariables(this._domRender_config);
       if (variables.size <= 0) {
@@ -12761,16 +14200,20 @@ var DomRenderProxy = class _DomRenderProxy {
         });
       }
     });
-    this.render(this.getRawSets()).then((it) => {
+    const targetRawSets = await this.render(this.getRawSets());
+    for (let targetRawSet of targetRawSets) {
       const onInit = target.getAttribute?.(RawSet.DR_ON_INIT_ARGUMENTS_OPTIONNAME);
       let initParam;
       if (onCreate) {
         initParam = ScriptUtils.evaluateReturn(onCreate, this._domRender_proxy);
       }
       if (isOnInitRender(this._domRender_proxy)) {
-        this._domRender_proxy.onInitRender(initParam, rawSet ?? { dataSet: { config: this._domRender_config } });
+        await this._domRender_proxy.onInitRender(
+          initParam,
+          rawSet ?? { dataSet: { config: this._domRender_config } }
+        );
       }
-    });
+    }
   }
   getRawSets() {
     const set = /* @__PURE__ */ new Set();
@@ -12803,9 +14246,12 @@ var DomRenderProxy = class _DomRenderProxy {
         } 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)) {
@@ -12849,7 +14295,11 @@ var DomRenderProxy = class _DomRenderProxy {
           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) {
             }
@@ -12885,10 +14335,19 @@ var DomRenderProxy = class _DomRenderProxy {
               if (value === void 0) {
                 const rawSet = it.getHasRawSet(lastPropertyName);
                 rawSet?.remove();
-                startElement.setAttribute(RawSet.DR_HAS_KEYS_OPTIONNAME, keys.filter((it2) => it2 !== lastPropertyName).join(","));
+                startElement.setAttribute(
+                  RawSet.DR_HAS_KEYS_OPTIONNAME,
+                  keys.filter((it2) => it2 !== lastPropertyName).join(",")
+                );
               }
               if (!keys.includes(lastPropertyName)) {
-                const raws = DrThisProperty.append(this._domRender_proxy, fullPathStr, lastPropertyName, it, this._domRender_config);
+                const raws = DrThisProperty.append(
+                  this._domRender_proxy,
+                  fullPathStr,
+                  lastPropertyName,
+                  it,
+                  this._domRender_config
+                );
                 if (raws) {
                   rawSets.push(...raws);
                 }
@@ -12908,10 +14367,19 @@ var DomRenderProxy = class _DomRenderProxy {
           } else if (iterable) {
             rData = await this.render(Array.from(iterable), fullPathStr);
           }
+          const Node2 = this._domRender_config.window.Node;
           this._targets.forEach((it) => {
-            if (it.nodeType === Node.DOCUMENT_FRAGMENT_NODE || it.nodeType === Node.ELEMENT_NODE) {
-              const targets = this._domRender_config.eventManager.findAttrElements(it, this._domRender_config);
-              this._domRender_config.eventManager.changeVar(this._domRender_proxy, targets, `this.${fullPathStr}`, this._domRender_config);
+            if (it.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || it.nodeType === Node2.ELEMENT_NODE) {
+              const targets = this._domRender_config.eventManager.findAttrElements(
+                it,
+                this._domRender_config
+              );
+              this._domRender_config.eventManager.changeVar(
+                this._domRender_proxy,
+                targets,
+                `this.${fullPathStr}`,
+                this._domRender_config
+              );
             }
           });
           if (rData?.length > 0 && isOnChildRenderedByProperty(data)) {
@@ -12943,49 +14411,64 @@ var DomRenderProxy = class _DomRenderProxy {
       fullPathInfo = this.root([[{ path: p, obj: this._domRender_proxy }]], value);
     }
     const rootElement = this._domRender_config.rootElement ?? this._domRender_config.window.document;
-    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.normalAttrMapAttrName)?.forEach((elementInfo) => {
-      const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((it) => {
-        const optionalPath = ObjectUtils.Path.toOptionalChainPath(it.valueScript);
-        const value1 = ScriptUtils.evaluateReturn(optionalPath, it.pathInfo.obj);
-        if (value1 === null) {
-          elementInfo.element.removeAttribute(it.key);
-          elementInfo.element[it.key] = null;
-        } else {
-          elementInfo.element.setAttribute(it.key, value1);
-          elementInfo.element[it.key] = value1;
-        }
-      });
-    });
-    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.linkTargetMapAttrName)?.forEach((elementInfo) => {
-      const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((info) => {
-        const value1 = ScriptUtils.evaluateReturn(info.valueScript, info.pathInfo.obj);
-        const applyAttributeName = EventManager.linkAttrs.find((it) => it.name === info.key);
-        if (applyAttributeName) {
+    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.normalAttrMapAttrName)?.forEach(
+      (elementInfo) => {
+        const targets = new Map(
+          ObjectUtils.Script.evaluateReturn(elementInfo.value)
+        );
+        Array.from(targets.entries()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.variablePaths?.some((vit) => vit.inner.includes(`this.${it.path}`))).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((it) => {
+          const variablePaths = it.valueScript.variablePaths;
+          let targetScript = it.valueScript.originalAttrValue;
+          variablePaths.forEach((it2) => {
+            let r = ObjectUtils.Path.toOptionalChainPath(it2.inner);
+            targetScript = targetScript.replaceAll(it2.origin, `\${${r}}`);
+          });
+          const value1 = ObjectUtils.Script.evaluateReturn("`" + targetScript + "`", it.pathInfo.obj);
           if (value1 === null) {
-            elementInfo.element.removeAttribute(applyAttributeName.property);
+            elementInfo.element.removeAttribute(it.key);
+            elementInfo.element[it.key] = null;
           } else {
-            elementInfo.element.setAttribute(applyAttributeName.property, value1);
+            elementInfo.element.setAttribute(it.key, value1);
+            elementInfo.element[it.key] = value1;
           }
-        }
-      });
-      Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
-        return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
-      }).forEach((info) => {
-        const linkInfo = EventManager.linkAttrs.find((it) => it.name === info.key);
-        if (linkInfo) {
-          elementInfo.element[linkInfo.property] = value;
-        }
-      });
-    });
+        });
+      }
+    );
+    DocumentUtils.querySelectorAllByAttributeName(rootElement, EventManager.linkTargetMapAttrName)?.forEach(
+      (elementInfo) => {
+        const targets = new Map(ScriptUtils.evaluateReturn(elementInfo.value));
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((info) => {
+          const value1 = ScriptUtils.evaluateReturn(info.valueScript, info.pathInfo.obj);
+          const applyAttributeName = EventManager.linkAttrs.find((it) => it.name === info.key);
+          if (applyAttributeName) {
+            if (value1 === null) {
+              elementInfo.element.removeAttribute(applyAttributeName.property);
+            } else {
+              elementInfo.element.setAttribute(applyAttributeName.property, value1);
+            }
+          }
+        });
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(isDefined).flatMap(([key, valueScript]) => {
+          return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
+        }).forEach((info) => {
+          const linkInfo = EventManager.linkAttrs.find((it) => it.name === info.key);
+          if (linkInfo) {
+            elementInfo.element[linkInfo.property] = value;
+          }
+        });
+      }
+    );
     if ("onBeforeReturnSet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnSets ?? []).concat(excludeGetSetPropertys).includes(p)) {
       if (isOnBeforeReturnSet(receiver)) {
-        receiver.onBeforeReturnSet?.(p, value, fullPathInfo.map((it) => it.map((it2) => it2.path).join()));
+        receiver.onBeforeReturnSet?.(
+          p,
+          value,
+          fullPathInfo.map((it) => it.map((it2) => it2.path).join())
+        );
       }
     }
     return true;
@@ -13005,7 +14488,11 @@ var DomRenderProxy = class _DomRenderProxy {
         it = it._DomRender_origin;
       }
       if ("onBeforeReturnGet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnGets ?? []).concat(excludeGetSetPropertys).includes(p)) {
-        receiver?.onBeforeReturnGet?.(p, it, this.root([[{ path: p, obj: this._domRender_proxy }]], it, false));
+        receiver?.onBeforeReturnGet?.(
+          p,
+          it,
+          this.root([[{ path: p, obj: this._domRender_proxy }]], it, false)
+        );
       }
       return it;
     }
@@ -13106,7 +14593,6 @@ var DomRenderProxy = class _DomRenderProxy {
 };
 
 // src/routers/Router.ts
-var isPopStateCurrentTargetDomrenderRouter = (obj) => obj?.currentTargetName === "domRenderRouter";
 var Router = class {
   constructor(config) {
     this._config = config;
@@ -13117,19 +14603,18 @@ var Router = class {
         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() {
@@ -13171,9 +14656,30 @@ var Router = class {
     }
   }
   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();
@@ -13187,32 +14693,40 @@ var Router = class {
       }
     }
     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 };
     }
@@ -13227,11 +14741,9 @@ var Router = class {
       } catch (e) {
       }
     }
-    if (!config.disabledPopEvent) {
-      this.dispatchPopStateEvent(config?.data);
-    }
   }
   toUrl(data) {
+    console.log("toUrl", data);
     let targetPath;
     if (typeof data === "string") {
       targetPath = data;
@@ -13250,7 +14762,10 @@ var PathRouter = class extends Router {
     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);
     });
@@ -13272,7 +14787,7 @@ var PathRouter = class extends Router {
   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) {
@@ -13286,7 +14801,7 @@ var PathRouter = class extends Router {
   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) {
@@ -13294,17 +14809,20 @@ var PathRouter = class extends Router {
     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);
     });
@@ -13722,10 +15240,10 @@ var ComponentBase = class {
       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 });
           }
         }
       }
@@ -13982,7 +15500,7 @@ var ComponentBase = class {
     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;
@@ -14046,7 +15564,7 @@ var ComponentBase = class {
       }
     }
   }
-  onInitRender(param, rawSet) {
+  async onInitRender(param, rawSet) {
     this.createChildrenDebounceSubscription = this.childrenSetSubject.pipe(debounceTime(this.componentConfig?.createChildrenDebounce ?? 0)).subscribe((it) => {
       this.onCreatedThisChildDebounce(it);
     });
@@ -14129,8 +15647,8 @@ var RouterOutlet;
     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) {
@@ -14321,9 +15839,6 @@ var Appender;
     // 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);
@@ -14493,7 +16008,9 @@ var Choose;
       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));
       }
     }
@@ -14602,8 +16119,8 @@ var Details;
         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;
@@ -14742,7 +16259,7 @@ var If;
       super(...arguments);
       this.sw = false;
     }
-    onInitRender(param, rawSet) {
+    async onInitRender(param, rawSet) {
       super.onInitRender(param, rawSet);
     }
     onChangeAttrRender(name, value, other) {
@@ -14758,7 +16275,7 @@ var If_default = {
   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 });
       }
@@ -14828,8 +16345,8 @@ var Input;
   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;
@@ -14943,16 +16460,16 @@ var PromiseSwitch;
       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) => {
@@ -14960,7 +16477,7 @@ var PromiseSwitch;
         });
         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) => {
@@ -14968,13 +16485,13 @@ var PromiseSwitch;
         });
         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();
@@ -15170,8 +16687,8 @@ var Route;
       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);
@@ -15311,8 +16828,8 @@ var Select;
       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) {
@@ -15436,8 +16953,8 @@ var Select;
         }
       }
     }
-    onInitRender(param, rawSet) {
-      super.onInitRender(param, rawSet);
+    async onInitRender(param, rawSet) {
+      await super.onInitRender(param, rawSet);
     }
     onInitSummaryElement(element, event) {
       this.element = element;
@@ -15528,8 +17045,8 @@ var Select;
     }
     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;
@@ -15692,8 +17209,8 @@ var This;
       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);
@@ -15734,8 +17251,8 @@ var Timer;
 ((_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() {
@@ -15748,7 +17265,6 @@ var Timer;
         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 {
@@ -16477,11 +17993,26 @@ export {
   isOnInitRender,
   isOnProxyDomRender,
   isOnRawSetRendered,
-  isPopStateCurrentTargetDomrenderRouter,
   isWrapProxyDomRenderProxy
 };
 /*! 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.