@dooboostore/simple-web-component 1.0.23 → 1.0.25

package/dist/umd-bundle/dooboostore-simple-web-component.umd.js

@@ -303,8 +303,8 @@ var dooboostoreSimpleWebComponent = (() => {
                 keys.push(key);
               }
             }
-            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
-              var key = parentKeys_1[_a];
+            for (var _a4 = 0, parentKeys_1 = parentKeys; _a4 < parentKeys_1.length; _a4++) {
+              var key = parentKeys_1[_a4];
               var hasKey = set.has(key);
               if (!hasKey) {
                 set.add(key);
@@ -1120,10 +1120,11 @@ var dooboostoreSimpleWebComponent = (() => {
   __export(bundle_entry_exports, {
     ADD_EVENT_LISTENER_METADATA_KEY: () => ADD_EVENT_LISTENER_METADATA_KEY,
     APPLY_NODE_METADATA_KEY: () => APPLY_NODE_METADATA_KEY,
+    ATTRIBUTE_APPLY_METADATA_KEY: () => ATTRIBUTE_APPLY_METADATA_KEY,
     ATTRIBUTE_CHANGED_WILDCARD: () => ATTRIBUTE_CHANGED_WILDCARD,
-    ATTRIBUTE_METADATA_KEY: () => ATTRIBUTE_METADATA_KEY,
+    ATTRIBUTE_FIELD_METADATA_KEY: () => ATTRIBUTE_FIELD_METADATA_KEY,
     BROWSER_GLOBALS: () => BROWSER_GLOBALS,
-    CLASS_LIST_METADATA_KEY: () => CLASS_LIST_METADATA_KEY,
+    CLASS_METADATA_KEY: () => CLASS_METADATA_KEY,
     DOM_EVENT_NAMES: () => DOM_EVENT_NAMES,
     ELEMENT_CONFIG_KEY: () => ELEMENT_CONFIG_KEY,
     EMIT_CUSTOM_EVENT_METADATA_KEY: () => EMIT_CUSTOM_EVENT_METADATA_KEY,
@@ -1141,35 +1142,33 @@ var dooboostoreSimpleWebComponent = (() => {
     ON_CONSTRUCTOR_METADATA_KEY: () => ON_CONSTRUCTOR_METADATA_KEY,
     QUERY_ALL_METADATA_KEY: () => QUERY_ALL_METADATA_KEY,
     QUERY_METADATA_KEY: () => QUERY_METADATA_KEY,
-    SET_ATTRIBUTE_METADATA_KEY: () => SET_ATTRIBUTE_METADATA_KEY,
     STYLE_METADATA_KEY: () => STYLE_METADATA_KEY,
     SWC_NOT_FOUND: () => SWC_NOT_FOUND,
     SwcUtils: () => SwcUtils,
-    TemplateUtils: () => TemplateUtils,
-    addClassList: () => addClassList,
-    addClassListHost: () => addClassListHost,
+    addClass: () => addClass,
+    addClassHost: () => addClassHost,
     addEventListener: () => addEventListener,
     addEventListenerHost: () => addEventListenerHost,
-    applyAfterBeginNode: () => applyAfterBeginNode,
-    applyAfterBeginNodeHost: () => applyAfterBeginNodeHost,
-    applyAfterEndNode: () => applyAfterEndNode,
-    applyAfterEndNodeHost: () => applyAfterEndNodeHost,
-    applyBeforeBeginNode: () => applyBeforeBeginNode,
-    applyBeforeBeginNodeHost: () => applyBeforeBeginNodeHost,
-    applyBeforeEndNode: () => applyBeforeEndNode,
-    applyBeforeEndNodeHost: () => applyBeforeEndNodeHost,
+    allAppHost: () => allAppHost,
+    allFirstAppHost: () => allFirstAppHost,
+    allFirstHost: () => allFirstHost,
+    allHost: () => allHost,
+    allLastAppHost: () => allLastAppHost,
+    allLastHost: () => allLastHost,
+    allParentHost: () => allParentHost,
+    appHost: () => appHost,
+    applyAttribute: () => applyAttribute,
+    applyAttributeHost: () => applyAttributeHost,
+    applyClass: () => applyClass,
+    applyClassHost: () => applyClassHost,
     applyInnerHtmlNode: () => applyInnerHtmlNode,
     applyInnerHtmlNodeHost: () => applyInnerHtmlNodeHost,
-    applyInnerTextNode: () => applyInnerTextNode,
-    applyInnerTextNodeHost: () => applyInnerTextNodeHost,
     applyNode: () => applyNode,
     applyNodeHost: () => applyNodeHost,
-    applyRemoveNode: () => applyRemoveNode,
-    applyRemoveNodeHost: () => applyRemoveNodeHost,
     applyReplaceChildrenNode: () => applyReplaceChildrenNode,
     applyReplaceChildrenNodeHost: () => applyReplaceChildrenNodeHost,
-    applyReplaceNode: () => applyReplaceNode,
-    applyReplaceNodeHost: () => applyReplaceNodeHost,
+    applyStyle: () => applyStyle,
+    applyStyleHost: () => applyStyleHost,
     attribute: () => attribute,
     attributeHost: () => attributeHost,
     changedAttributeHost: () => changedAttributeHost,
@@ -1180,12 +1179,14 @@ var dooboostoreSimpleWebComponent = (() => {
     emitCustomEventHost: () => emitCustomEventHost,
     ensureInit: () => ensureInit2,
     findAllApplyNodeMetadata: () => findAllApplyNodeMetadata,
+    findAllAttributeApplyMetadata: () => findAllAttributeApplyMetadata,
     findAllAttributeChangedMetadata: () => findAllAttributeChangedMetadata,
     findAllAttributeMetadata: () => findAllAttributeMetadata,
-    findAllClassListMetadata: () => findAllClassListMetadata,
+    findAllClassMetadata: () => findAllClassMetadata,
     findAllLifecycleMetadata: () => findAllLifecycleMetadata,
-    findAllSetAttributeMetadata: () => findAllSetAttributeMetadata,
     findAllStyleMetadata: () => findAllStyleMetadata,
+    firstAppHost: () => firstAppHost,
+    firstHost: () => firstHost,
     getAddEventListenerMetadata: () => getAddEventListenerMetadata,
     getChangedAttributeMetadata: () => getChangedAttributeMetadata,
     getElementConfig: () => getElementConfig,
@@ -1193,24 +1194,20 @@ var dooboostoreSimpleWebComponent = (() => {
     getOnConnectedInnerHtmlMetadata: () => getOnConnectedInnerHtmlMetadata,
     getQueryAllMetadata: () => getQueryAllMetadata,
     getQueryMetadata: () => getQueryMetadata,
-    getSetAttributeMetadata: () => getSetAttributeMetadata,
+    host: () => host,
     htmlAElement: () => htmlAElement,
     htmlArticleElement: () => htmlArticleElement,
     htmlButtonElement: () => htmlButtonElement,
     htmlDivElement: () => htmlDivElement,
     htmlFragment: () => htmlFragment,
-    htmlH1Element: () => htmlH1Element,
-    htmlH2Element: () => htmlH2Element,
-    htmlH3Element: () => htmlH3Element,
-    htmlH4Element: () => htmlH4Element,
-    htmlH5Element: () => htmlH5Element,
-    htmlH6Element: () => htmlH6Element,
-    htmlInputElement: () => htmlInputElement,
+    htmlHeadingElement: () => htmlHeadingElement,
     htmlLiElement: () => htmlLiElement,
     htmlPElement: () => htmlPElement,
     htmlSectionElement: () => htmlSectionElement,
     htmlSpanElement: () => htmlSpanElement,
     htmlUlElement: () => htmlUlElement,
+    lastAppHost: () => lastAppHost,
+    lastHost: () => lastHost,
     onAddEventListener: () => onAddEventListener,
     onAdopted: () => onAdopted,
     onAfterAdopted: () => onAfterAdopted,
@@ -1223,33 +1220,38 @@ var dooboostoreSimpleWebComponent = (() => {
     onConnectedInnerHtml: () => onConnectedInnerHtml,
     onConstructor: () => onConstructor,
     onDisconnected: () => onDisconnected,
+    parentHost: () => parentHost,
     query: () => query,
     queryAll: () => queryAll,
     queryAllHost: () => queryAllHost,
     queryHost: () => queryHost,
-    removeClassList: () => removeClassList,
-    removeClassListHost: () => removeClassListHost,
+    removeAttribute: () => removeAttribute,
+    removeAttributeHost: () => removeAttributeHost,
+    removeClass: () => removeClass,
+    removeClassHost: () => removeClassHost,
     removeStyle: () => removeStyle,
     removeStyleHost: () => removeStyleHost,
     resolveTargetEls: () => resolveTargetEls,
     setAttribute: () => setAttribute,
     setAttributeHost: () => setAttributeHost,
-    setClassList: () => setClassList,
-    setClassListHost: () => setClassListHost,
+    setClass: () => setClass,
+    setClassHost: () => setClassHost,
     setStyle: () => setStyle,
     setStyleHost: () => setStyleHost,
     textNode: () => textNode,
-    toggleClassList: () => toggleClassList,
-    toggleClassListHost: () => toggleClassListHost,
-    updateClassList: () => updateClassList,
-    updateClassListHost: () => updateClassListHost,
+    toggleClass: () => toggleClass,
+    toggleClassHost: () => toggleClassHost,
+    updateAttribute: () => updateAttribute,
+    updateAttributeHost: () => updateAttributeHost,
+    updateClass: () => updateClass,
+    updateClassHost: () => updateClassHost,
     updateStyle: () => updateStyle,
     updateStyleHost: () => updateStyleHost
   });
-  var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+  var import_reflect_metadata3 = __toESM(require_Reflect(), 1);
 
   // src/index.ts
-  var import_reflect_metadata = __toESM(require_Reflect(), 1);
+  var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
   // ../core/dist/esm/valid/ValidUtils.js
   var ValidUtils;
@@ -4925,6 +4927,107 @@ var dooboostoreSimpleWebComponent = (() => {
     }
   };
 
+  // ../core/dist/esm/message/Subject.js
+  var Subject = class extends Observable {
+    constructor() {
+      super((subscriber) => {
+        return this._subscribeToSubject(subscriber);
+      });
+      this._observers = /* @__PURE__ */ new Set();
+      this._isStopped = false;
+      this._hasError = false;
+    }
+    _subscribeToSubject(subscriber) {
+      const partialObserver = {
+        next: subscriber.next.bind(subscriber),
+        error: subscriber.error.bind(subscriber),
+        complete: subscriber.complete.bind(subscriber)
+      };
+      if (this._isStopped) {
+        if (this._hasError) {
+          partialObserver.error?.(this._error);
+        } else {
+          partialObserver.complete?.();
+        }
+        return Subscription.EMPTY;
+      }
+      this._observers.add(partialObserver);
+      return new Subscription(() => {
+        this._observers.delete(partialObserver);
+      });
+    }
+    next(data) {
+      if (this._isStopped) {
+        return;
+      }
+      this._observers.forEach((observer) => {
+        observer.next?.(data);
+      });
+    }
+    error(err) {
+      if (this._isStopped) {
+        return;
+      }
+      this._hasError = true;
+      this._error = err;
+      this._isStopped = true;
+      this._observers.forEach((observer) => observer.error?.(err));
+      this._observers.clear();
+    }
+    complete() {
+      if (this._isStopped) {
+        return;
+      }
+      this._isStopped = true;
+      this._observers.forEach((observer) => observer.complete?.());
+      this._observers.clear();
+    }
+    asObservable() {
+      return new Observable((subscriber) => {
+        return this._subscribeToSubject(subscriber);
+      });
+    }
+  };
+
+  // ../core/dist/esm/message/ReplaySubject.js
+  var ReplaySubject = class extends Subject {
+    // Removed: private _error: E | undefined;
+    // Removed: private _isStopped = false;
+    constructor(bufferSize = Infinity) {
+      super();
+      this.bufferSize = bufferSize;
+      this._buffer = [];
+    }
+    next(data) {
+      if (this._isStopped) {
+        return;
+      }
+      this._buffer.push(data);
+      if (this._buffer.length > this.bufferSize) {
+        this._buffer.shift();
+      }
+      super.next(data);
+    }
+    error(err) {
+      super.error(err);
+    }
+    complete() {
+      super.complete();
+    }
+    _subscribeToSubject(subscriber) {
+      this._buffer.forEach((value) => subscriber.next(value));
+      if (this._isStopped) {
+        if (this._hasError) {
+          subscriber.error(this._error);
+        } else {
+          subscriber.complete();
+        }
+        return Subscription.EMPTY;
+      }
+      return super._subscribeToSubject(subscriber);
+    }
+  };
+
   // ../core/dist/esm/message/AutoCloseSubscription.js
   var AutoCloseSubscription = class extends Subscription {
     constructor(userUnsubscribe) {
@@ -5259,6 +5362,284 @@ var dooboostoreSimpleWebComponent = (() => {
     })(Result = Promises2.Result || (Promises2.Result = {}));
   })(Promises || (Promises = {}));
 
+  // ../core/dist/esm/fetch/Fetcher.js
+  var Fetcher = class {
+    createPipe(config) {
+      return {};
+    }
+    fetch(config) {
+      return new Promise((resolve, reject) => {
+        const pipe = this.createPipe(config);
+        Promise.resolve().then(() => {
+          this.before(config, pipe);
+          config?.before?.();
+        }).then(() => {
+          return this.execute(config);
+        }).then((data) => {
+          const hasError = config.config?.hasErrorChecker?.(data);
+          if (hasError) {
+            throw hasError;
+          }
+          pipe.responseData = data;
+          this.afterSuccess(config, pipe);
+          config?.afterSuccess?.();
+          const gdata = config?.transform ? config.transform(data) : data;
+          this.afterSuccessTransform(config, pipe);
+          resolve(gdata);
+        }).catch(async (e) => {
+          this.error(config, pipe, e);
+          config?.error?.();
+          if (config?.errorTransform) {
+            e = await config.errorTransform(e);
+          }
+          e = await this.errorTransform(e);
+          reject(e);
+        }).finally(() => {
+          this.finally(config, pipe);
+          config?.finally?.();
+        });
+      });
+    }
+  };
+
+  // ../core/dist/esm/fetch/HttpFetcher.js
+  var HttpResponseError = class extends Error {
+  };
+  var HttpFetcher = class extends Fetcher {
+    get(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "GET";
+      return this.fetch(config);
+    }
+    post(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "POST";
+      return this.fetch(config);
+    }
+    patch(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "PATCH";
+      return this.fetch(config);
+    }
+    put(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "PUT";
+      return this.fetch(config);
+    }
+    head(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "HEAD";
+      return this.fetch(config);
+    }
+    delete(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "DELETE";
+      return this.fetch(config);
+    }
+    async beforeProxyFetch(config) {
+      return config;
+    }
+    async afterProxyFetch(config) {
+      return config.response;
+    }
+    afterSuccess(config, pipe) {
+    }
+    afterSuccessTransform(config, pipe) {
+    }
+    before(config, pipe) {
+    }
+    error(config, pipe, e) {
+    }
+    finally(config, pipe) {
+    }
+    beforeFetch(fetch2) {
+    }
+    afterFetch(fetch2, response) {
+    }
+    // protected async errorTransform(e: any): Promise<HttpResponseError<any>> {
+    async errorTransform(e) {
+      const httpResponseError = new HttpResponseError();
+      httpResponseError.error = e;
+      if (e instanceof Response) {
+        httpResponseError.response = e;
+        try {
+          httpResponseError.body = await e.clone().text();
+          httpResponseError.message = e.statusText;
+        } catch (e2) {
+          httpResponseError.body = e2;
+          httpResponseError.message = e2.message;
+        }
+      } else {
+        httpResponseError.body = e;
+        httpResponseError.message = e.message;
+      }
+      return httpResponseError;
+    }
+    async execute(fetcherRequest) {
+      let target = fetcherRequest.target;
+      let config = fetcherRequest.config;
+      if (!(target instanceof URL) && typeof target !== "string") {
+        const searchParams = ConvertUtils.toURLSearchParams(target.searchParams ?? {});
+        try {
+          const url = typeof target.url === "string" ? new URL(target.url) : target.url;
+          searchParams.forEach((value, key) => {
+            url.searchParams.append(key, value);
+          });
+          target = url;
+        } catch (e) {
+          if (typeof target.url === "string") {
+            const searchParamString = searchParams.toString();
+            target = target.url + (searchParamString ? "?" + searchParamString : "");
+          } else {
+            target = "";
+          }
+        }
+      }
+      const beforeProxyData = { requestInfo: target, init: config?.fetch };
+      let beforeData = config?.beforeProxyFetch ? await config?.beforeProxyFetch(config) : beforeProxyData.requestInfo;
+      beforeData = config?.skipGlobalBeforeProxyFetch ? beforeProxyData : await this.beforeProxyFetch(beforeProxyData);
+      target = beforeData.requestInfo;
+      if (beforeData.init) {
+        config ?? (config = {});
+        config.fetch = beforeData.init;
+      }
+      let abortedTimeout;
+      if (config?.fetch && "timeout" in config.fetch) {
+        const abortController = new AbortController();
+        abortedTimeout = setTimeout(() => {
+          if (config?.fetch?.signal) {
+            const inputSignal = config.fetch.signal;
+            const listener = () => {
+              if (!abortController.signal.aborted) {
+                abortController.abort();
+              }
+              inputSignal.removeEventListener("abort", listener);
+            };
+            inputSignal.addEventListener("abort", listener);
+          }
+          if (!abortController.signal.aborted) {
+            abortController.abort();
+          }
+        }, config.fetch.timeout);
+        config.fetch.signal = abortController.signal;
+      }
+      this.beforeFetch({ target, requestInit: config?.fetch });
+      return (config.fetcher ?? fetch)(target, config?.fetch).then(async (it) => {
+        this.afterFetch({ target, requestInit: config?.fetch }, it);
+        const afterProxyData = {
+          fetch: { target, requestInit: config.fetch },
+          config: beforeData,
+          response: it
+        };
+        it = config?.afterProxyFetch ? await config.afterProxyFetch(afterProxyData) : it;
+        it = config?.skipGlobalAfterProxyFetch ? it : await this.afterProxyFetch(afterProxyData);
+        config?.fetchResponseAfterCallBack?.(it, config);
+        if (!config?.allowedResponseNotOk && !it.ok) {
+          throw it;
+        }
+        const data = config?.hasResponseErrorChecker?.(it, config);
+        if (data) {
+          throw data;
+        }
+        return it;
+      }).finally(() => {
+        if (abortedTimeout) {
+          clearTimeout(abortedTimeout);
+        }
+      });
+    }
+  };
+
+  // ../core/dist/esm/fetch/HttpJsonFetcher.js
+  var HttpJsonFetcher = class extends HttpFetcher {
+    updateJsonFetchConfigAndData(config) {
+      var _a4, _b2;
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/plain, */*"
+      };
+      config.config ?? (config.config = {});
+      (_a4 = config.config).fetch ?? (_a4.fetch = {});
+      (_b2 = config.config.fetch).headers ?? (_b2.headers = {});
+      config.config.fetch.headers = { ...headers, ...config.config.fetch?.headers };
+      if (config.config?.fetch?.body && typeof config.config?.fetch?.body !== "string") {
+        config.config.fetch.body = JSON.stringify(config.config.fetch.body);
+      }
+      return config;
+    }
+    get(config) {
+      return super.get(config);
+    }
+    delete(config) {
+      return super.delete(config);
+    }
+    post(config) {
+      return super.post(config);
+    }
+    patch(config) {
+      return super.patch(config);
+    }
+    put(config) {
+      return super.put(config);
+    }
+    head(config) {
+      return super.head(config);
+    }
+    postJson(config) {
+      return super.post(this.updateJsonFetchConfigAndData(config));
+    }
+    patchJson(config) {
+      return super.patch(this.updateJsonFetchConfigAndData(config));
+    }
+    putJson(config) {
+      return super.put(this.updateJsonFetchConfigAndData(config));
+    }
+    async errorTransform(e) {
+      const httpResponseError = new HttpResponseError();
+      httpResponseError.error = e;
+      if (e instanceof Response) {
+        httpResponseError.response = e;
+        try {
+          httpResponseError.body = await e.clone().json();
+          httpResponseError.message = e.statusText;
+        } catch (parseError) {
+          httpResponseError.body = parseError;
+          httpResponseError.message = parseError.message;
+        }
+      } else {
+        httpResponseError.body = e;
+        httpResponseError.message = e.message;
+      }
+      return httpResponseError;
+    }
+    // protected execute(target: HttpFetcherTarget, config?: HttpJsonFetcherConfig<C, any>): Promise<any> {
+    execute(fetcherRequest) {
+      return super.execute(fetcherRequest).then((response) => {
+        const config = fetcherRequest.config;
+        const transform = config?.responseTransform ?? (config?.bypassTransform ? "response" : config?.transformText ? "text" : void 0);
+        if (transform === "response") {
+          return response;
+        } else if (transform === "text") {
+          return response?.text();
+        } else if (typeof transform === "function") {
+          return transform(response);
+        } else {
+          return response?.text().then((it) => {
+            if ((it ?? "").length > 0) {
+              return JSON.parse(it);
+            }
+          });
+        }
+      });
+    }
+  };
+
   // ../core/dist/esm/entity/object/obj/RenderDrawObj.js
   var RenderDrawObj = class extends Obj {
     render(draw, config) {
@@ -5535,7 +5916,7 @@ var dooboostoreSimpleWebComponent = (() => {
   // ../core/dist/esm/schedule/Schedule.js
   var Schedule;
   ((Schedule2) => {
-    Schedule2.SYMBOL = Symbol("Schedule");
+    Schedule2.SYMBOL = Symbol.for("core:schedule-token");
   })(Schedule || (Schedule = {}));
 
   // ../core/dist/esm/url/UrlUtils.js
@@ -5689,6 +6070,17 @@ var dooboostoreSimpleWebComponent = (() => {
         Reflect.defineMetadata(metadataKey, value, target);
       }
     };
+    ReflectUtils2.copyMetadata = (from, to, propertyKey) => {
+      const keys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);
+      for (const key of keys) {
+        const data = propertyKey ? Reflect.getOwnMetadata(key, from, propertyKey) : Reflect.getOwnMetadata(key, from);
+        if (propertyKey) {
+          Reflect.defineMetadata(key, data, to, propertyKey);
+        } else {
+          Reflect.defineMetadata(key, data, to);
+        }
+      }
+    };
   })(ReflectUtils || (ReflectUtils = {}));
 
   // ../core/dist/esm/function/FunctionUtils.js
@@ -5852,7 +6244,7 @@ var dooboostoreSimpleWebComponent = (() => {
   })(Expression || (Expression = {}));
 
   // src/decorators/addEventListener.ts
-  var ADD_EVENT_LISTENER_METADATA_KEY = Symbol("simple-web-component:add-event-listener");
+  var ADD_EVENT_LISTENER_METADATA_KEY = Symbol.for("simple-web-component:add-event-listener");
   function addEventListener(selectorOrTarget, type, options = {}) {
     return (targetObj, propertyKey, descriptor) => {
       const constructor = targetObj.constructor;
@@ -5873,15 +6265,15 @@ var dooboostoreSimpleWebComponent = (() => {
   }
 
   // src/decorators/lifecycles.ts
-  var ON_CONSTRUCTOR_METADATA_KEY = Symbol("simple-web-component:on-constructor");
-  var ON_BEFORE_CONNECTED_METADATA_KEY = Symbol("simple-web-component:on-before-connected");
-  var ON_AFTER_CONNECTED_METADATA_KEY = Symbol("simple-web-component:on-after-connected");
-  var ON_BEFORE_DISCONNECTED_METADATA_KEY = Symbol("simple-web-component:on-before-disconnected");
-  var ON_AFTER_DISCONNECTED_METADATA_KEY = Symbol("simple-web-component:on-after-disconnected");
-  var ON_BEFORE_ADOPTED_METADATA_KEY = Symbol("simple-web-component:on-before-adopted");
-  var ON_AFTER_ADOPTED_METADATA_KEY = Symbol("simple-web-component:on-after-adopted");
-  var ON_ADD_EVENT_LISTENER_METADATA_KEY = Symbol("simple-web-component:on-add-event-listener");
-  var INNER_HTML_METADATA_KEY = Symbol("simple-web-component:inner-html");
+  var ON_CONSTRUCTOR_METADATA_KEY = Symbol.for("simple-web-component:on-constructor");
+  var ON_BEFORE_CONNECTED_METADATA_KEY = Symbol.for("simple-web-component:on-before-connected");
+  var ON_AFTER_CONNECTED_METADATA_KEY = Symbol.for("simple-web-component:on-after-connected");
+  var ON_BEFORE_DISCONNECTED_METADATA_KEY = Symbol.for("simple-web-component:on-before-disconnected");
+  var ON_AFTER_DISCONNECTED_METADATA_KEY = Symbol.for("simple-web-component:on-after-disconnected");
+  var ON_BEFORE_ADOPTED_METADATA_KEY = Symbol.for("simple-web-component:on-before-adopted");
+  var ON_AFTER_ADOPTED_METADATA_KEY = Symbol.for("simple-web-component:on-after-adopted");
+  var ON_ADD_EVENT_LISTENER_METADATA_KEY = Symbol.for("simple-web-component:on-add-event-listener");
+  var INNER_HTML_METADATA_KEY = Symbol.for("simple-web-component:inner-html");
   var ATTRIBUTE_CHANGED_WILDCARD = "*";
   function createLifecycleDecorator(metadataKey) {
     return (target, propertyKey) => {
@@ -5932,7 +6324,7 @@ var dooboostoreSimpleWebComponent = (() => {
   };
 
   // src/decorators/attribute.ts
-  var ATTRIBUTE_METADATA_KEY = Symbol("simple-web-component:attribute");
+  var ATTRIBUTE_FIELD_METADATA_KEY = Symbol.for("simple-web-component:attribute-field");
   var convertValue = (val, type) => {
     if (val === null || val === void 0) return val;
     if (type === Number) return Number(val);
@@ -5990,15 +6382,14 @@ var dooboostoreSimpleWebComponent = (() => {
       const constructor = target.constructor;
       const privateKey = Symbol(String(propertyKey));
       const designType = Reflect.getMetadata("design:type", target, propertyKey);
-      let metaList = ReflectUtils.getOwnMetadata(ATTRIBUTE_METADATA_KEY, constructor);
+      let metaList = ReflectUtils.getOwnMetadata(ATTRIBUTE_FIELD_METADATA_KEY, constructor);
       if (!metaList) {
         metaList = [];
-        ReflectUtils.defineMetadata(ATTRIBUTE_METADATA_KEY, metaList, constructor);
+        ReflectUtils.defineMetadata(ATTRIBUTE_FIELD_METADATA_KEY, metaList, constructor);
       }
       metaList.push({ propertyKey, selector, options, privateKey });
       const applySetAttribute = (inst, targets, attrName, nv) => {
         targets.forEach((it) => {
-          console.log("----->", it);
           if (it && typeof it.setAttribute === "function") {
             if (nv === null) {
               it.removeAttribute(attrName);
@@ -6016,7 +6407,6 @@ var dooboostoreSimpleWebComponent = (() => {
           const conf = getElementConfig(this);
           const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
           const targetType = options.type || designType;
-          console.log("type-->", propertyKey, targetType);
           if (this.__swc_syncing_init || options.connectedInitialize && !this.__swc_connected) {
             return convertValue(this[privateKey], targetType);
           }
@@ -6032,7 +6422,6 @@ var dooboostoreSimpleWebComponent = (() => {
           return convertValue(this[privateKey], targetType);
         },
         set(nv) {
-          const targetType = options.type || designType;
           const attrName = options.name || String(propertyKey);
           const conf = getElementConfig(this);
           const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
@@ -6057,15 +6446,31 @@ var dooboostoreSimpleWebComponent = (() => {
       });
     };
   }
+  function attributeHost(targetOrAttrOrOptions, propertyKeyOrOptions) {
+    if (propertyKeyOrOptions !== void 0 && (typeof propertyKeyOrOptions === "string" || typeof propertyKeyOrOptions === "symbol")) {
+      return attribute(":host", { name: String(propertyKeyOrOptions) })(targetOrAttrOrOptions, propertyKeyOrOptions);
+    }
+    if (typeof targetOrAttrOrOptions === "string") {
+      const attrName = targetOrAttrOrOptions;
+      const options = typeof propertyKeyOrOptions === "object" ? propertyKeyOrOptions : {};
+      return attribute(":host", { ...options, name: attrName });
+    } else if (typeof targetOrAttrOrOptions === "object") {
+      const options = targetOrAttrOrOptions;
+      return (target, propertyKey) => {
+        return attribute(":host", { ...options, name: String(propertyKey) })(target, propertyKey);
+      };
+    } else {
+      return (target, propertyKey) => {
+        return attribute(":host", { name: String(propertyKey) })(target, propertyKey);
+      };
+    }
+  }
   var findAllAttributeMetadata = (target) => {
-    return ReflectUtils.findAllMetadata(ATTRIBUTE_METADATA_KEY, target).flat();
+    return ReflectUtils.findAllMetadata(ATTRIBUTE_FIELD_METADATA_KEY, target).flat();
   };
-  function attributeHost(attrName, options = {}) {
-    return attribute(":host", { ...options, name: attrName });
-  }
 
   // src/decorators/changedAttributeHost.ts
-  var ON_ATTRIBUTE_CHANGED_METADATA_KEY = Symbol("simple-web-component:on-attribute-changed");
+  var ON_ATTRIBUTE_CHANGED_METADATA_KEY = Symbol.for("simple-web-component:on-attribute-changed");
   function changedAttributeHost(attributeName) {
     return (target, propertyKey) => {
       const constructor = target.constructor;
@@ -6091,102 +6496,43 @@ var dooboostoreSimpleWebComponent = (() => {
     return ReflectUtils.findAllMapMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, target);
   };
 
-  // src/decorators/setAttribute.ts
-  var SET_ATTRIBUTE_METADATA_KEY = Symbol("simple-web-component:set-attribute");
-  function setAttribute(selector, name, options = {}) {
-    return (target, propertyKey, descriptor) => {
-      const constructor = target.constructor;
-      let metaList = ReflectUtils.getOwnMetadata(SET_ATTRIBUTE_METADATA_KEY, constructor);
-      if (!metaList) {
-        metaList = /* @__PURE__ */ new Map();
-        ReflectUtils.defineMetadata(SET_ATTRIBUTE_METADATA_KEY, metaList, constructor);
-      }
-      metaList.set(propertyKey, { propertyKey, selector, name, options });
-      const original = descriptor.value;
-      descriptor.value = async function(...args) {
-        ensureInit2(this);
-        const res = await original.apply(this, args);
-        if (res !== void 0) {
-          const hostSet = SwcUtils.getHostSet(this);
-          const conf = getElementConfig(this);
-          const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
-          const targetEls = [];
-          const r = options.root || "auto";
-          const applyRoot = (t) => {
-            if (!t) return;
-            if (r === "auto") {
-              targetEls.push(t.shadowRoot || t);
-              return;
-            }
-            if (r === "light" || r === "all") targetEls.push(t);
-            if ((r === "shadow" || r === "all") && t.shadowRoot) targetEls.push(t.shadowRoot);
-          };
-          if (selector === ":window") targetEls.push(currentWin);
-          else if (selector === ":document") targetEls.push(currentWin.document);
-          else if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
-          else if (selector === ":appHost") applyRoot(hostSet.$appHost);
-          else if (selector === ":firstHost") applyRoot(hostSet.$firstHost);
-          else if (selector === ":lastHost") applyRoot(hostSet.$lastHost);
-          else if (selector === ":firstAppHost") applyRoot(hostSet.$firstAppHost);
-          else if (selector === ":lastAppHost") applyRoot(hostSet.$lastAppHost);
-          else if (selector === ":hosts") hostSet.$hosts.forEach(applyRoot);
-          else if (selector === ":appHosts") hostSet.$appHosts.forEach(applyRoot);
-          else if (selector === ":host" || !selector) applyRoot(this);
-          else {
-            const roots = [];
-            if (r === "shadow") {
-              if (this.shadowRoot) roots.push(this.shadowRoot);
-            } else if (r === "light") {
-              roots.push(this);
-            } else if (r === "all") {
-              roots.push(this);
-              if (this.shadowRoot) roots.push(this.shadowRoot);
-            } else {
-              roots.push(this.shadowRoot || this);
-            }
-            roots.forEach((root) => targetEls.push(...root.querySelectorAll(selector)));
-          }
-          targetEls.forEach((targetEl) => {
-            if (!targetEl || typeof targetEl.setAttribute !== "function") return;
-            if (res === null) targetEl.removeAttribute(name);
-            else targetEl.setAttribute(name, String(res));
-          });
-        }
-        return res;
-      };
-    };
-  }
-  var getSetAttributeMetadata = (target) => {
-    const constructor = target instanceof Function ? target : target.constructor;
-    return ReflectUtils.getMetadata(SET_ATTRIBUTE_METADATA_KEY, constructor);
-  };
-  var findAllSetAttributeMetadata = (target) => {
-    const result = /* @__PURE__ */ new Map();
-    const maps = ReflectUtils.findAllMetadata(SET_ATTRIBUTE_METADATA_KEY, target);
-    maps.forEach((map) => {
-      if (map instanceof Map) {
-        map.forEach((v, k) => result.set(k, v));
-      }
-    });
-    return result;
-  };
-  function setAttributeHost(name, options) {
-    return setAttribute(":host", name, options);
-  }
-
   // src/decorators/applyNode.ts
-  var APPLY_NODE_METADATA_KEY = Symbol("simple-web-component:apply-node");
+  var APPLY_NODE_METADATA_KEY = Symbol.for("simple-web-component:apply-node");
   var normalizeNodes = (res, doc) => {
     const items = Array.isArray(res) ? res : [res];
     return items.map((it) => {
-      if (it instanceof Node)
-        return it;
+      if (it instanceof Node) return it;
       return doc.createTextNode(it !== void 0 && it !== null ? String(it) : "");
     });
   };
+  var applyToDom = (targetEl, res, pos, doc) => {
+    if (!targetEl) return;
+    if (pos === "innerHtml") {
+      targetEl.innerHTML = res !== void 0 && res !== null ? String(res) : "";
+      return;
+    }
+    if (pos === "innerText") {
+      if (targetEl.innerText !== void 0) {
+        targetEl.innerText = res !== void 0 && res !== null ? String(res) : "";
+      }
+      return;
+    }
+    const isShadowRoot = targetEl instanceof ShadowRoot;
+    const nodes = normalizeNodes(res, doc);
+    if (pos === "replace") {
+      if (!isShadowRoot) targetEl.replaceWith(...nodes);
+    } else if (pos === "replaceChildren") {
+      targetEl.replaceChildren(...nodes);
+    } else {
+      if (pos === "beforeEnd") targetEl.append(...nodes);
+      else if (pos === "afterBegin") targetEl.prepend(...nodes);
+      else if (pos === "beforeBegin" && !isShadowRoot) targetEl.before(...nodes);
+      else if (pos === "afterEnd" && !isShadowRoot) targetEl.after(...nodes);
+    }
+  };
   function applyNode(selector, options = { position: "beforeEnd" }) {
-    return (target, propertyKey, descriptor) => {
-      const constructor = target.constructor;
+    return (targetObj, propertyKey, descriptor) => {
+      const constructor = targetObj.constructor;
       let metaList = ReflectUtils.getOwnMetadata(APPLY_NODE_METADATA_KEY, constructor);
       if (!metaList) {
         metaList = /* @__PURE__ */ new Map();
@@ -6194,81 +6540,58 @@ var dooboostoreSimpleWebComponent = (() => {
       }
       metaList.set(propertyKey, { propertyKey, selector, options });
       const original = descriptor.value;
-      descriptor.value = async function(...args) {
+      descriptor.value = function(...args) {
         ensureInit2(this);
-        const res = await original.apply(this, args);
-        if (res !== void 0) {
-          const conf = getElementConfig(this);
-          const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
-          const currentDoc = currentWin.document;
-          const pos = options.position || "beforeEnd";
+        const conf = getElementConfig(this);
+        const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+        const currentDoc = currentWin.document;
+        const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+        const getTarget = () => {
           const r = options.root || "auto";
-          const getTargetRoot = () => {
-            if (r === "shadow")
-              return this.shadowRoot;
-            if (r === "light")
-              return this;
-            if (r === "all")
-              return this.shadowRoot || this;
-            return this.shadowRoot || this;
+          const applyRoot = (t) => {
+            if (!t) return t;
+            if (r === "auto") return t.shadowRoot || t;
+            if (r === "shadow") return t.shadowRoot;
+            if (r === "light") return t;
+            if (r === "all") return t.shadowRoot || t;
+            return t;
           };
-          if (pos === "remove") {
-            if (res) {
-              if (selector === ":host" || !selector) {
-                if (r === "shadow" && this.shadowRoot) {
-                  this.shadowRoot.replaceChildren();
-                } else {
-                  this.remove();
-                }
-              } else {
-                const targetRoot = getTargetRoot();
-                if (targetRoot) {
-                  const targets = targetRoot.querySelectorAll(selector);
-                  targets.forEach((el) => el.remove());
-                }
-              }
-            }
-          } else {
-            let targetEl = null;
-            if (selector === ":host" || !selector) {
-              if (r === "shadow") {
-                targetEl = this.shadowRoot;
-              } else {
-                targetEl = this;
-              }
-            } else {
-              const targetRoot = getTargetRoot();
-              targetEl = targetRoot ? targetRoot.querySelector(selector) : null;
-            }
-            if (targetEl) {
-              const isShadowRoot = targetEl instanceof ShadowRoot;
-              const nodes = normalizeNodes(res, currentDoc);
-              if (pos === "replace") {
-                if (!isShadowRoot) {
-                  targetEl.replaceWith(...nodes);
-                }
-              } else if (pos === "replaceChildren") {
-                targetEl.replaceChildren(...nodes);
-              } else if (pos === "innerHtml") {
-                targetEl.innerHTML = res !== void 0 && res !== null ? String(res) : "";
-              } else if (pos === "innerText") {
-                if (targetEl.innerText !== void 0) {
-                  targetEl.innerText = res !== void 0 && res !== null ? String(res) : "";
-                }
-              } else {
-                if (pos === "beforeEnd")
-                  targetEl.append(...nodes);
-                else if (pos === "afterBegin")
-                  targetEl.prepend(...nodes);
-                else if (pos === "beforeBegin" && !isShadowRoot)
-                  targetEl.before(...nodes);
-                else if (pos === "afterEnd" && !isShadowRoot)
-                  targetEl.after(...nodes);
-              }
-            }
+          if (selector === ":host") return applyRoot(this);
+          if (selector === ":parentHost") return applyRoot(hostSet.$parentHost);
+          if (selector === ":appHost") return applyRoot(hostSet.$appHost);
+          if (selector === ":firstHost") return applyRoot(hostSet.$firstHost);
+          if (selector === ":lastHost") return applyRoot(hostSet.$lastHost);
+          const targetRoot = applyRoot(this);
+          return targetRoot ? targetRoot.querySelector(selector) : null;
+        };
+        const targetEl = getTarget();
+        const res = original.apply(this, args);
+        const runApply = (target, val) => {
+          const pos = options.position || "beforeEnd";
+          const defaultFilter = (t, v) => {
+            if (v instanceof Node) return !t.contains(v);
+            if (pos === "innerHtml" && typeof v === "string") return t.innerHTML !== v;
+            if (pos === "replaceChildren" && v instanceof Node) return !t.contains(v);
+            return true;
+          };
+          const activeFilter = options.filter || defaultFilter;
+          if (activeFilter(target, val, hostSet)) {
+            applyToDom(target, val, pos, currentDoc);
           }
+        };
+        if (res instanceof Promise) {
+          if (targetEl && options.loading) {
+            const loadingRes = options.loading.call(this, hostSet);
+            applyToDom(targetEl, loadingRes, options.position || "beforeEnd", currentDoc);
+          }
+          return res.then((finalRes) => {
+            if (finalRes !== void 0 && targetEl) runApply(targetEl, finalRes);
+            return finalRes;
+          });
+        } else {
+          if (res !== void 0 && targetEl) runApply(targetEl, res);
+          return res;
         }
-        return res;
       };
     };
   }
@@ -6282,30 +6605,30 @@ var dooboostoreSimpleWebComponent = (() => {
     });
     return result;
   };
-  function applyNodeHost(options = { position: "beforeEnd" }) {
-    return applyNode(":host", options);
+  function applyNodeHost(targetOrOptions, propertyKey, descriptor) {
+    if (propertyKey !== void 0) return applyNode(":host", { position: "beforeEnd" })(targetOrOptions, propertyKey, descriptor);
+    const opt = targetOrOptions || {};
+    return applyNode(":host", { position: "beforeEnd", ...opt });
+  }
+  function applyReplaceChildrenNodeHost(targetOrOptions, propertyKey, descriptor) {
+    if (propertyKey !== void 0) return applyNode(":host", { position: "replaceChildren" })(targetOrOptions, propertyKey, descriptor);
+    const opt = targetOrOptions || {};
+    return applyNode(":host", { position: "replaceChildren", ...opt });
+  }
+  function applyInnerHtmlNodeHost(targetOrOptions, propertyKey, descriptor) {
+    if (propertyKey !== void 0) return applyNode(":host", { position: "innerHtml" })(targetOrOptions, propertyKey, descriptor);
+    const opt = targetOrOptions || {};
+    return applyNode(":host", { position: "innerHtml", ...opt });
+  }
+  function applyReplaceChildrenNode(selector, options = {}) {
+    return applyNode(selector, { ...options, position: "replaceChildren" });
+  }
+  function applyInnerHtmlNode(selector, options = {}) {
+    return applyNode(selector, { ...options, position: "innerHtml" });
   }
-  var applyBeforeBeginNode = (selector, options = {}) => applyNode(selector, { ...options, position: "beforeBegin" });
-  var applyAfterBeginNode = (selector, options = {}) => applyNode(selector, { ...options, position: "afterBegin" });
-  var applyBeforeEndNode = (selector, options = {}) => applyNode(selector, { ...options, position: "beforeEnd" });
-  var applyAfterEndNode = (selector, options = {}) => applyNode(selector, { ...options, position: "afterEnd" });
-  var applyReplaceNode = (selector, options = {}) => applyNode(selector, { ...options, position: "replace" });
-  var applyReplaceChildrenNode = (selector, options = {}) => applyNode(selector, { ...options, position: "replaceChildren" });
-  var applyInnerHtmlNode = (selector, options = {}) => applyNode(selector, { ...options, position: "innerHtml" });
-  var applyInnerTextNode = (selector, options = {}) => applyNode(selector, { ...options, position: "innerText" });
-  var applyRemoveNode = (selector, options = {}) => applyNode(selector, { ...options, position: "remove" });
-  var applyBeforeBeginNodeHost = (options = {}) => applyNode(":host", { ...options, position: "beforeBegin" });
-  var applyAfterBeginNodeHost = (options = {}) => applyNode(":host", { ...options, position: "afterBegin" });
-  var applyBeforeEndNodeHost = (options = {}) => applyNode(":host", { ...options, position: "beforeEnd" });
-  var applyAfterEndNodeHost = (options = {}) => applyNode(":host", { ...options, position: "afterEnd" });
-  var applyReplaceNodeHost = (options = {}) => applyNode(":host", { ...options, position: "replace" });
-  var applyReplaceChildrenNodeHost = (options = {}) => applyNode(":host", { ...options, position: "replaceChildren" });
-  var applyInnerHtmlNodeHost = (options = {}) => applyNode(":host", { ...options, position: "innerHtml" });
-  var applyInnerTextNodeHost = (options = {}) => applyNode(":host", { ...options, position: "innerText" });
-  var applyRemoveNodeHost = (options = {}) => applyNode(":host", { ...options, position: "remove" });
 
   // src/decorators/query.ts
-  var QUERY_METADATA_KEY = Symbol("simple-web-component:query");
+  var QUERY_METADATA_KEY = Symbol.for("simple-web-component:query");
   function query(selectorOrTarget, options = {}) {
     return (targetObj, propertyKey, descriptor) => {
       if (descriptor !== void 0) {
@@ -6403,12 +6726,80 @@ var dooboostoreSimpleWebComponent = (() => {
     const constructor = target instanceof Function ? target : target.constructor;
     return ReflectUtils.getMetadata(QUERY_METADATA_KEY, constructor);
   };
-  function queryHost(options) {
-    return query(":host", options);
+  function queryHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":host", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":host", targetOrOptions);
+    } else {
+      return query(":host", {});
+    }
+  }
+  var host = queryHost;
+  function parentHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":parentHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":parentHost", targetOrOptions);
+    } else {
+      return query(":parentHost", {});
+    }
+  }
+  function appHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":appHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":appHost", targetOrOptions);
+    } else {
+      return query(":appHost", {});
+    }
+  }
+  function firstHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":firstHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":firstHost", targetOrOptions);
+    } else {
+      return query(":firstHost", {});
+    }
+  }
+  function lastHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":lastHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":lastHost", targetOrOptions);
+    } else {
+      return query(":lastHost", {});
+    }
+  }
+  function firstAppHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":firstAppHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":firstAppHost", targetOrOptions);
+    } else {
+      return query(":firstAppHost", {});
+    }
+  }
+  function lastAppHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return query(":lastAppHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return query(":lastAppHost", targetOrOptions);
+    } else {
+      return query(":lastAppHost", {});
+    }
   }
 
   // src/decorators/queryAll.ts
-  var QUERY_ALL_METADATA_KEY = Symbol("simple-web-component:query-all");
+  var QUERY_ALL_METADATA_KEY = Symbol.for("simple-web-component:query-all");
   function queryAll(selectorOrTarget, options = {}) {
     return (targetObj, propertyKey, descriptor) => {
       if (descriptor !== void 0) {
@@ -6503,101 +6894,197 @@ var dooboostoreSimpleWebComponent = (() => {
     const constructor = target instanceof Function ? target : target.constructor;
     return ReflectUtils.getMetadata(QUERY_ALL_METADATA_KEY, constructor);
   };
-  function queryAllHost(options) {
-    return queryAll(":host", options);
+  function queryAllHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":host", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":host", targetOrOptions);
+    } else {
+      return queryAll(":host", {});
+    }
   }
-
-  // src/decorators/classList.ts
-  var CLASS_LIST_METADATA_KEY = Symbol("simple-web-component:class-list");
-  function createClassListDecorator(action) {
-    return (selector, options = {}) => {
-      return (target, propertyKey, descriptor) => {
-        const constructor = target.constructor;
-        let metaList = ReflectUtils.getOwnMetadata(CLASS_LIST_METADATA_KEY, constructor);
-        if (!metaList) {
-          metaList = /* @__PURE__ */ new Map();
-          ReflectUtils.defineMetadata(CLASS_LIST_METADATA_KEY, metaList, constructor);
-        }
-        metaList.set(propertyKey, { propertyKey, selector, action, options });
-        const original = descriptor.value;
-        descriptor.value = async function(...args) {
-          ensureInit2(this);
+  var allHost = queryAllHost;
+  function allParentHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":parentHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":parentHost", targetOrOptions);
+    } else {
+      return queryAll(":parentHost", {});
+    }
+  }
+  function allAppHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":appHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":appHost", targetOrOptions);
+    } else {
+      return queryAll(":appHost", {});
+    }
+  }
+  function allFirstHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":firstHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":firstHost", targetOrOptions);
+    } else {
+      return queryAll(":firstHost", {});
+    }
+  }
+  function allLastHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":lastHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":lastHost", targetOrOptions);
+    } else {
+      return queryAll(":lastHost", {});
+    }
+  }
+  function allFirstAppHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":firstAppHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":firstAppHost", targetOrOptions);
+    } else {
+      return queryAll(":firstAppHost", {});
+    }
+  }
+  function allLastAppHost(targetOrOptions, propertyKey) {
+    if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+      return queryAll(":lastAppHost", {})(targetOrOptions, propertyKey);
+    }
+    if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
+      return queryAll(":lastAppHost", targetOrOptions);
+    } else {
+      return queryAll(":lastAppHost", {});
+    }
+  }
+
+  // src/decorators/applyClass.ts
+  var CLASS_METADATA_KEY = Symbol.for("simple-web-component:class");
+  function createClassDecorator(action) {
+    return (selector, classMapOrOptions, options = {}) => {
+      return (target, propertyKey, descriptor) => {
+        const constructor = target.constructor;
+        let metaList = ReflectUtils.getOwnMetadata(CLASS_METADATA_KEY, constructor);
+        if (!metaList) {
+          metaList = /* @__PURE__ */ new Map();
+          ReflectUtils.defineMetadata(CLASS_METADATA_KEY, metaList, constructor);
+        }
+        let classMap = void 0;
+        let finalOptions = options;
+        if (typeof classMapOrOptions === "string" || typeof classMapOrOptions === "object" && classMapOrOptions !== null && !("root" in classMapOrOptions)) {
+          classMap = classMapOrOptions;
+        } else if (typeof classMapOrOptions === "object" && classMapOrOptions !== null && "root" in classMapOrOptions) {
+          finalOptions = classMapOrOptions;
+        }
+        metaList.set(propertyKey, { propertyKey, selector, action, options: finalOptions });
+        const original = descriptor.value;
+        descriptor.value = async function(...args) {
+          ensureInit2(this);
           const res = await original.apply(this, args);
           if (res !== void 0) {
-            const r = options.root || "auto";
-            const hostSet = SwcUtils.getHostSet(this);
+            const win = this.ownerDocument?.defaultView || window;
+            const host2 = this;
+            const hostSet = { ...SwcUtils.getHelperAndHostSet(win, host2), $this: this };
+            const r = finalOptions.root || "auto";
             const targetEls = [];
-            if (selector === ":host" || !selector) {
-              targetEls.push(this);
-            } else if (selector === ":parentHost") {
-              if (hostSet.$parentHost) targetEls.push(hostSet.$parentHost);
-            } else if (selector === ":appHost") {
-              if (hostSet.$appHost) targetEls.push(hostSet.$appHost);
-            } else {
-              if (r === "shadow") {
-                const found = this.shadowRoot?.querySelectorAll(selector);
-                if (found) targetEls.push(...found);
-              } else if (r === "light") {
-                const found = this.querySelectorAll(selector);
-                if (found) targetEls.push(...found);
-              } else if (r === "all") {
-                const sFound = this.shadowRoot?.querySelectorAll(selector);
-                const lFound = this.querySelectorAll(selector);
-                if (sFound) targetEls.push(...sFound);
-                if (lFound) targetEls.push(...lFound);
-              } else {
-                const found = (this.shadowRoot || this).querySelectorAll(selector);
-                if (found) targetEls.push(...found);
+            const applyRoot = (t) => {
+              if (!t || !(t instanceof win.HTMLElement)) return;
+              targetEls.push(t);
+            };
+            if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
+            else if (selector === ":appHost") applyRoot(hostSet.$appHost);
+            else if (selector === ":firstHost") applyRoot(hostSet.$firstHost);
+            else if (selector === ":lastHost") applyRoot(hostSet.$lastHost);
+            else if (selector === ":firstAppHost") applyRoot(hostSet.$firstAppHost);
+            else if (selector === ":lastAppHost") applyRoot(hostSet.$lastAppHost);
+            else if (selector === ":hosts") hostSet.$hosts.forEach(applyRoot);
+            else if (selector === ":appHosts") hostSet.$appHosts.forEach(applyRoot);
+            else if (selector === ":host" || !selector) applyRoot(host2);
+            else {
+              const targetRoot = r === "auto" ? host2.shadowRoot || host2 : r === "shadow" ? host2.shadowRoot : host2;
+              if (targetRoot) {
+                const found = targetRoot.querySelectorAll(selector);
+                if (found) targetEls.push(...Array.from(found));
               }
             }
             targetEls.forEach((targetEl) => {
+              const resolvedRes = typeof res === "function" ? res(targetEl, hostSet) : res;
               if (action === "set") {
                 let classes = "";
-                if (typeof res === "object" && res !== null && !Array.isArray(res)) {
-                  classes = Object.entries(res).filter(([_, force]) => !!force).map(([cls]) => cls).join(" ");
+                if (classMap && typeof classMap === "string") {
+                  classes = resolvedRes ? classMap : "";
+                } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  classes = Object.entries(resolvedRes).filter(([_, force]) => typeof force === "function" ? force(targetEl, hostSet) : !!force).map(([cls]) => cls).join(" ");
                 } else {
-                  classes = Array.isArray(res) ? res.join(" ") : String(res);
+                  classes = Array.isArray(resolvedRes) ? resolvedRes.join(" ") : String(resolvedRes);
                 }
                 targetEl.className = classes;
-              } else if (action === "update") {
-                if (typeof res === "object" && res !== null && !Array.isArray(res)) {
-                  Object.entries(res).forEach(([cls, force]) => {
-                    targetEl.classList.toggle(cls, !!force);
+              } else if (action === "update" || action === "toggle") {
+                if (classMap && typeof classMap === "string") {
+                  targetEl.classList.toggle(classMap, !!resolvedRes);
+                } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([cls, force]) => {
+                    const isActive = typeof force === "function" ? force(targetEl, hostSet) : !!force;
+                    targetEl.classList.toggle(cls, isActive);
                   });
-                } else if (res !== void 0 && res !== null) {
-                  const classes = Array.isArray(res) ? res.map(String) : [String(res)];
-                  targetEl.classList.add(...classes);
+                } else {
+                  const classes = Array.isArray(resolvedRes) ? resolvedRes.map(String) : [String(resolvedRes)];
+                  if (action === "update") targetEl.classList.add(...classes);
+                  else classes.forEach((c) => targetEl.classList.toggle(c));
+                }
+              } else if (action === "add" || action === "remove") {
+                if (classMap && typeof classMap === "string" && !!resolvedRes) {
+                  if (action === "add") targetEl.classList.add(classMap);
+                  else targetEl.classList.remove(classMap);
+                } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([cls, force]) => {
+                    const shouldExecute = typeof force === "function" ? force(targetEl, hostSet) : !!force;
+                    if (shouldExecute) {
+                      if (action === "add") targetEl.classList.add(cls);
+                      else targetEl.classList.remove(cls);
+                    }
+                  });
+                } else {
+                  const classes = Array.isArray(resolvedRes) ? resolvedRes.map(String) : [String(resolvedRes)];
+                  if (action === "add") targetEl.classList.add(...classes);
+                  else targetEl.classList.remove(...classes);
                 }
-              } else if (action === "add") {
-                const classes = Array.isArray(res) ? res.map(String) : [String(res)];
-                targetEl.classList.add(...classes);
-              } else if (action === "remove") {
-                const classes = Array.isArray(res) ? res.map(String) : [String(res)];
-                targetEl.classList.remove(...classes);
-              } else if (action === "toggle") {
-                const classes = Array.isArray(res) ? res.map(String) : [String(res)];
-                classes.forEach((c) => targetEl.classList.toggle(c));
               }
             });
           }
           return res;
         };
+        return descriptor;
       };
     };
   }
-  var setClassList = (selector, options = {}) => createClassListDecorator("set")(selector, options);
-  var updateClassList = (selector, options = {}) => createClassListDecorator("update")(selector, options);
-  var addClassList = (selector, options = {}) => createClassListDecorator("add")(selector, options);
-  var removeClassList = (selector, options = {}) => createClassListDecorator("remove")(selector, options);
-  var toggleClassList = (selector, options = {}) => createClassListDecorator("toggle")(selector, options);
-  var setClassListHost = (options = {}) => createClassListDecorator("set")(":host", options);
-  var updateClassListHost = (options = {}) => createClassListDecorator("update")(":host", options);
-  var addClassListHost = (options = {}) => createClassListDecorator("add")(":host", options);
-  var removeClassListHost = (options = {}) => createClassListDecorator("remove")(":host", options);
-  var toggleClassListHost = (options = {}) => createClassListDecorator("toggle")(":host", options);
-  var findAllClassListMetadata = (target) => {
+  function applyClass(selector, action = "update", options = {}) {
+    return createClassDecorator(action)(selector, options);
+  }
+  var setClass = (selector, classMapOrOptions, options = {}) => createClassDecorator("set")(selector, classMapOrOptions, options);
+  var updateClass = (selector, classMapOrOptions, options = {}) => createClassDecorator("update")(selector, classMapOrOptions, options);
+  var addClass = (selector, classMapOrOptions, options = {}) => createClassDecorator("add")(selector, classMapOrOptions, options);
+  var removeClass = (selector, classMapOrOptions, options = {}) => createClassDecorator("remove")(selector, classMapOrOptions, options);
+  var toggleClass = (selector, classMapOrOptions, options = {}) => createClassDecorator("toggle")(selector, classMapOrOptions, options);
+  function applyClassHost(action = "update", options = {}) {
+    return createClassDecorator(action)(":host", options);
+  }
+  var setClassHost = (classMapOrOptions, options = {}) => createClassDecorator("set")(":host", classMapOrOptions, options);
+  var updateClassHost = (classMapOrOptions, options = {}) => createClassDecorator("update")(":host", classMapOrOptions, options);
+  var addClassHost = (classMapOrOptions, options = {}) => createClassDecorator("add")(":host", classMapOrOptions, options);
+  var removeClassHost = (classMapOrOptions, options = {}) => createClassDecorator("remove")(":host", classMapOrOptions, options);
+  var toggleClassHost = (classMapOrOptions, options = {}) => createClassDecorator("toggle")(":host", classMapOrOptions, options);
+  var findAllClassMetadata = (target) => {
     const result = /* @__PURE__ */ new Map();
-    const maps = ReflectUtils.findAllMetadata(CLASS_LIST_METADATA_KEY, target);
+    const maps = ReflectUtils.findAllMetadata(CLASS_METADATA_KEY, target);
     maps.forEach((map) => {
       if (map instanceof Map) {
         map.forEach((v, k) => result.set(k, v));
@@ -6606,8 +7093,8 @@ var dooboostoreSimpleWebComponent = (() => {
     return result;
   };
 
-  // src/decorators/style.ts
-  var STYLE_METADATA_KEY = Symbol("simple-web-component:style");
+  // src/decorators/applyStyle.ts
+  var STYLE_METADATA_KEY = Symbol.for("simple-web-component:style");
   function createStyleDecorator(action) {
     return (selector, options = {}) => {
       return (target, propertyKey, descriptor) => {
@@ -6623,60 +7110,79 @@ var dooboostoreSimpleWebComponent = (() => {
           ensureInit2(this);
           const res = await original.apply(this, args);
           if (res !== void 0) {
+            const win = this.ownerDocument?.defaultView || window;
+            const host2 = this;
+            const hostSet = { ...SwcUtils.getHelperAndHostSet(win, host2), $this: this };
             const r = options.root || "auto";
-            const hostSet = SwcUtils.getHostSet(this);
             const targetEls = [];
-            if (selector === ":host" || !selector) {
-              targetEls.push(this);
-            } else if (selector === ":parentHost") {
-              if (hostSet.$parentHost) targetEls.push(hostSet.$parentHost);
-            } else if (selector === ":appHost") {
-              if (hostSet.$appHost) targetEls.push(hostSet.$appHost);
-            } else {
-              if (r === "shadow") {
-                const found = this.shadowRoot?.querySelectorAll(selector);
-                if (found) targetEls.push(...found);
-              } else if (r === "light") {
-                const found = this.querySelectorAll(selector);
-                if (found) targetEls.push(...found);
-              } else if (r === "all") {
-                const sFound = this.shadowRoot?.querySelectorAll(selector);
-                const lFound = this.querySelectorAll(selector);
-                if (sFound) targetEls.push(...sFound);
-                if (lFound) targetEls.push(...lFound);
-              } else {
-                const found = (this.shadowRoot || this).querySelectorAll(selector);
-                if (found) targetEls.push(...found);
+            const applyRoot = (t) => {
+              if (!t || !(t instanceof win.HTMLElement)) return;
+              targetEls.push(t);
+            };
+            if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
+            else if (selector === ":appHost") applyRoot(hostSet.$appHost);
+            else if (selector === ":firstHost") applyRoot(hostSet.$firstHost);
+            else if (selector === ":lastHost") applyRoot(hostSet.$lastHost);
+            else if (selector === ":firstAppHost") applyRoot(hostSet.$firstAppHost);
+            else if (selector === ":lastAppHost") applyRoot(hostSet.$lastAppHost);
+            else if (selector === ":hosts") hostSet.$hosts.forEach(applyRoot);
+            else if (selector === ":appHosts") hostSet.$appHosts.forEach(applyRoot);
+            else if (selector === ":host" || !selector) applyRoot(host2);
+            else {
+              const targetRoot = r === "auto" ? host2.shadowRoot || host2 : r === "shadow" ? host2.shadowRoot : host2;
+              if (targetRoot) {
+                const found = targetRoot.querySelectorAll(selector);
+                if (found) targetEls.push(...Array.from(found));
               }
             }
             targetEls.forEach((targetEl) => {
-              if (action === "set") {
-                targetEl.style.cssText = "";
-                if (typeof res === "object" && res !== null) {
-                  Object.assign(targetEl.style, res);
-                } else if (typeof res === "string") {
-                  targetEl.style.cssText = res;
-                }
-              } else if (action === "update") {
-                if (typeof res === "object" && res !== null) {
-                  Object.assign(targetEl.style, res);
+              const resolvedRes = typeof res === "function" ? res(targetEl, hostSet) : res;
+              if (action === "set" || action === "update") {
+                if (action === "set") targetEl.style.cssText = "";
+                if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([prop, val]) => {
+                    const finalVal = typeof val === "function" ? val(targetEl, hostSet) : val;
+                    if (finalVal === null || finalVal === void 0) {
+                      targetEl.style.removeProperty(prop);
+                    } else {
+                      targetEl.style[prop] = String(finalVal);
+                    }
+                  });
+                } else if (typeof resolvedRes === "string") {
+                  targetEl.style.cssText = resolvedRes;
                 }
               } else if (action === "remove") {
-                const props = Array.isArray(res) ? res : [res];
-                props.forEach((p) => targetEl.style.removeProperty(String(p)));
+                if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([prop, val]) => {
+                    const shouldRemove = typeof val === "function" ? val(targetEl, hostSet) : !!val;
+                    if (shouldRemove) {
+                      targetEl.style.removeProperty(prop);
+                    }
+                  });
+                } else {
+                  const props = Array.isArray(resolvedRes) ? resolvedRes : [resolvedRes];
+                  props.forEach((p) => targetEl.style.removeProperty(String(p)));
+                }
               }
             });
           }
           return res;
         };
+        return descriptor;
       };
     };
   }
+  function applyStyle(selector, action = "update", options = {}) {
+    return createStyleDecorator(action)(selector, options);
+  }
   var setStyle = (selector, options = {}) => createStyleDecorator("set")(selector, options);
-  var setStyleHost = (options = {}) => createStyleDecorator("set")(":host", options);
   var updateStyle = (selector, options = {}) => createStyleDecorator("update")(selector, options);
-  var updateStyleHost = (options = {}) => createStyleDecorator("update")(":host", options);
   var removeStyle = (selector, options = {}) => createStyleDecorator("remove")(selector, options);
+  function applyStyleHost(action = "update", options = {}) {
+    return createStyleDecorator(action)(":host", options);
+  }
+  var setStyleHost = (options = {}) => createStyleDecorator("set")(":host", options);
+  var updateStyleHost = (options = {}) => createStyleDecorator("update")(":host", options);
   var removeStyleHost = (options = {}) => createStyleDecorator("remove")(":host", options);
   var findAllStyleMetadata = (target) => {
     const result = /* @__PURE__ */ new Map();
@@ -6689,8 +7195,248 @@ var dooboostoreSimpleWebComponent = (() => {
     return result;
   };
 
+  // src/decorators/applyAttribute.ts
+  var ATTRIBUTE_APPLY_METADATA_KEY = Symbol.for("simple-web-component:attribute-apply");
+  function createAttributeDecorator(action) {
+    return (selector, nameOrOptions, options = {}) => {
+      return (target, propertyKey, descriptor) => {
+        const constructor = target.constructor;
+        let metaList = ReflectUtils.getOwnMetadata(ATTRIBUTE_APPLY_METADATA_KEY, constructor);
+        if (!metaList) {
+          metaList = /* @__PURE__ */ new Map();
+          ReflectUtils.defineMetadata(ATTRIBUTE_APPLY_METADATA_KEY, metaList, constructor);
+        }
+        let attributeName = typeof nameOrOptions === "string" ? nameOrOptions : void 0;
+        let finalOptions = options;
+        if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
+          finalOptions = nameOrOptions;
+        }
+        metaList.set(propertyKey, {
+          propertyKey,
+          selector,
+          action,
+          options: { ...finalOptions, name: attributeName }
+        });
+        const original = descriptor.value;
+        descriptor.value = async function(...args) {
+          ensureInit2(this);
+          const res = await original.apply(this, args);
+          if (res !== void 0) {
+            const win = this.ownerDocument?.defaultView || window;
+            const host2 = this;
+            const hostSet = { ...SwcUtils.getHelperAndHostSet(win, host2), $this: this };
+            const r = finalOptions.root || "auto";
+            const targetEls = [];
+            const applyRoot = (t) => {
+              if (!t || !(t instanceof win.HTMLElement)) return;
+              targetEls.push(t);
+            };
+            if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
+            else if (selector === ":appHost") applyRoot(hostSet.$appHost);
+            else if (selector === ":firstHost") applyRoot(hostSet.$firstHost);
+            else if (selector === ":lastHost") applyRoot(hostSet.$lastHost);
+            else if (selector === ":firstAppHost") applyRoot(hostSet.$firstAppHost);
+            else if (selector === ":lastAppHost") applyRoot(hostSet.$lastAppHost);
+            else if (selector === ":hosts") hostSet.$hosts.forEach(applyRoot);
+            else if (selector === ":appHosts") hostSet.$appHosts.forEach(applyRoot);
+            else if (selector === ":host" || !selector) applyRoot(host2);
+            else {
+              const targetRoot = r === "auto" ? host2.shadowRoot || host2 : r === "shadow" ? host2.shadowRoot : host2;
+              if (targetRoot) {
+                const found = targetRoot.querySelectorAll(selector);
+                if (found) targetEls.push(...Array.from(found));
+              }
+            }
+            targetEls.forEach((targetEl) => {
+              const resolvedRes = typeof res === "function" ? res(targetEl, hostSet) : res;
+              if (action === "set" || action === "update") {
+                if (attributeName) {
+                  if (resolvedRes === null || resolvedRes === void 0 || resolvedRes === false) {
+                    targetEl.removeAttribute(attributeName);
+                  } else {
+                    targetEl.setAttribute(attributeName, resolvedRes === true ? "" : String(resolvedRes));
+                  }
+                } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([attr, val]) => {
+                    const finalVal = typeof val === "function" ? val(targetEl, hostSet) : val;
+                    if (finalVal === null || finalVal === void 0 || finalVal === false) {
+                      targetEl.removeAttribute(attr);
+                    } else {
+                      targetEl.setAttribute(attr, finalVal === true ? "" : String(finalVal));
+                    }
+                  });
+                }
+              } else if (action === "remove") {
+                if (attributeName) {
+                  targetEl.removeAttribute(attributeName);
+                } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
+                  Object.entries(resolvedRes).forEach(([attr, val]) => {
+                    const shouldRemove = typeof val === "function" ? val(targetEl, hostSet) : !!val;
+                    if (shouldRemove) targetEl.removeAttribute(attr);
+                  });
+                } else {
+                  const attrs = Array.isArray(resolvedRes) ? resolvedRes : [resolvedRes];
+                  attrs.forEach((a) => targetEl.removeAttribute(String(a)));
+                }
+              }
+            });
+          }
+          return res;
+        };
+        return descriptor;
+      };
+    };
+  }
+  function applyAttribute(selector, action = "update", options = {}) {
+    return createAttributeDecorator(action)(selector, options);
+  }
+  var setAttribute = (selector, nameOrOptions, options = {}) => createAttributeDecorator("set")(selector, nameOrOptions, options);
+  var updateAttribute = (selector, nameOrOptions, options = {}) => createAttributeDecorator("update")(selector, nameOrOptions, options);
+  var removeAttribute = (selector, nameOrOptions, options = {}) => createAttributeDecorator("remove")(selector, nameOrOptions, options);
+  function applyAttributeHost(action = "update", options = {}) {
+    return createAttributeDecorator(action)(":host", options);
+  }
+  var setAttributeHost = (nameOrOptions, options = {}) => createAttributeDecorator("set")(":host", nameOrOptions, options);
+  var updateAttributeHost = (nameOrOptions, options = {}) => createAttributeDecorator("update")(":host", nameOrOptions, options);
+  var removeAttributeHost = (nameOrOptions, options = {}) => createAttributeDecorator("remove")(":host", nameOrOptions, options);
+  var findAllAttributeApplyMetadata = (target) => {
+    const result = /* @__PURE__ */ new Map();
+    const maps = ReflectUtils.findAllMetadata(ATTRIBUTE_APPLY_METADATA_KEY, target);
+    maps.forEach((map) => {
+      if (map instanceof Map) {
+        map.forEach((v, k) => result.set(k, v));
+      }
+    });
+    return result;
+  };
+
   // src/utils/Utils.ts
-  var SWC_NOT_FOUND = Symbol("SWC_NOT_FOUND");
+  var SWC_NOT_FOUND = Symbol.for("simple-web-component:not-found");
+  var htmlFragment = (html, doc) => {
+    const d = doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const template = d.createElement("template");
+    template.innerHTML = html.trim();
+    return template.content;
+  };
+  var textNode = (text, doc) => {
+    const d = doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    return d.createTextNode(text !== void 0 && text !== null ? String(text) : "");
+  };
+  var commentNode = (comment, doc) => {
+    const d = doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    return d.createComment(comment !== void 0 && comment !== null ? String(comment) : "");
+  };
+  var createElement = (tagName, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement(tagName);
+    if (options?.html) el.innerHTML = options.html;
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlDivElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("div");
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlSpanElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("span");
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlButtonElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("button");
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlUlElement = (options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("ul");
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlLiElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("li");
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlAElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("a");
+    el.innerHTML = html.trim();
+    if (options?.href) el.href = options.href;
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlPElement = (html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("p");
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlHeadingElement = (level, html, options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement(`h${level}`);
+    el.innerHTML = html.trim();
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlSectionElement = (options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("section");
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
+  var htmlArticleElement = (options) => {
+    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
+    if (!d) throw new Error("Document is not available");
+    const el = d.createElement("article");
+    if (options?.attrs) {
+      Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
+    }
+    return el;
+  };
   var SwcUtils;
   ((SwcUtils2) => {
     SwcUtils2.getHelperSet = (win) => {
@@ -6753,7 +7499,7 @@ var dooboostoreSimpleWebComponent = (() => {
     };
     SwcUtils2.getAppHosts = (el) => {
       const hosts = (0, SwcUtils2.getHosts)(el);
-      return hosts.filter((host) => host.tagName.toLowerCase() === "swc-app" || host.getAttribute("is")?.startsWith("swc-app-"));
+      return hosts.filter((host2) => host2.tagName.toLowerCase() === "swc-app" || host2.getAttribute("is")?.startsWith("swc-app-"));
     };
     SwcUtils2.getAppHost = (el) => {
       const appHosts = (0, SwcUtils2.getAppHosts)(el);
@@ -6802,7 +7548,7 @@ var dooboostoreSimpleWebComponent = (() => {
   })(SwcUtils || (SwcUtils = {}));
 
   // src/decorators/emitCustomEvent.ts
-  var EMIT_CUSTOM_EVENT_METADATA_KEY = Symbol("simple-web-component:emit-custom-event");
+  var EMIT_CUSTOM_EVENT_METADATA_KEY = Symbol.for("simple-web-component:emit-custom-event");
   function emitCustomEvent(selectorOrTarget, type, options = {}) {
     return (targetObj, propertyKey, descriptor) => {
       const constructor = targetObj.constructor;
@@ -6871,7 +7617,10 @@ var dooboostoreSimpleWebComponent = (() => {
     const constructor = target instanceof Function ? target : target.constructor;
     return ReflectUtils.getMetadata(EMIT_CUSTOM_EVENT_METADATA_KEY, constructor);
   };
-  function emitCustomEventHost(type, options) {
+  function emitCustomEventHost(type, options = {}) {
+    if (!options.attributeName) {
+      options.attributeName = `on-emit-${type}`;
+    }
     return emitCustomEvent(":host", type, options);
   }
 
@@ -6963,7 +7712,46 @@ var dooboostoreSimpleWebComponent = (() => {
       return this.containers.find(predicate);
     }
   };
-  var InjectMetadataKey = Symbol("Inject");
+  var isTargetSymbol = (config) => {
+    return "symbol" in config && config.symbol !== void 0;
+  };
+  var isTargetType = (config) => {
+    return "type" in config && config.type !== void 0;
+  };
+  var isTargetScheme = (config) => {
+    return "scheme" in config && config.scheme !== void 0;
+  };
+  var isTargetFactory = (config) => {
+    return "factory" in config && typeof config.factory === "function" && !("symbol" in config) && !("type" in config) && !("scheme" in config);
+  };
+  var InjectMetadataKey = Symbol.for("simple-boot:inject-metadata");
+  var injectProcess = (config, target, propertyKey, parameterIndex) => {
+    if (propertyKey && typeof target === "object") {
+      const otarget = target;
+      target = target.constructor;
+      const saves = Reflect.getOwnMetadata(InjectMetadataKey, target, propertyKey) || [];
+      const type = ReflectUtils.getParameterTypes(otarget, propertyKey)[parameterIndex];
+      saves.push({ index: parameterIndex, config, propertyKey, type });
+      ReflectUtils.defineMetadata(InjectMetadataKey, saves, target, propertyKey);
+    } else if (!propertyKey || typeof target === "function") {
+      const existingInjectdParameters = ReflectUtils.getMetadata(InjectMetadataKey, target) || [];
+      const type = ReflectUtils.getParameterTypes(target)[parameterIndex];
+      existingInjectdParameters.push({ index: parameterIndex, config, type });
+      ReflectUtils.defineMetadata(InjectMetadataKey, existingInjectdParameters, target);
+    }
+  };
+  function Inject(configOrTarget, propertyKey, parameterIndex) {
+    if (propertyKey && parameterIndex !== void 0) {
+      injectProcess({}, configOrTarget, propertyKey, parameterIndex);
+    } else {
+      return (target, propertyKey2, parameterIndex2) => {
+        injectProcess(configOrTarget, target, propertyKey2, parameterIndex2);
+      };
+    }
+  }
+  var getInject = (target, propertyKey) => {
+    return ReflectUtils.findMetadata(InjectMetadataKey, target, propertyKey) ?? [];
+  };
 
   // src/types.ts
   var InjectSituationType = /* @__PURE__ */ ((InjectSituationType2) => {
@@ -6981,7 +7769,7 @@ var dooboostoreSimpleWebComponent = (() => {
   })(InjectSituationType || {});
 
   // src/decorators/elementDefine.ts
-  var ELEMENT_CONFIG_KEY = Symbol("simple-web-component:element-config");
+  var ELEMENT_CONFIG_KEY = Symbol.for("simple-web-component:element-config");
   var getElementConfig = (target) => {
     const constructor = target instanceof Function ? target : target.constructor;
     return ReflectUtils.getMetadata(ELEMENT_CONFIG_KEY, constructor);
@@ -7010,9 +7798,9 @@ var dooboostoreSimpleWebComponent = (() => {
       if (!(node instanceof HTMLElement)) continue;
       const script = node.getAttribute?.(attrName);
       if (script && !getElementConfig(node)) {
-        const host = SwcUtils.findNearestSwcHost(node);
-        if (host && host.isConnected && typeof host.__swc_executeAttributeEvent === "function") {
-          await host.__swc_executeAttributeEvent(node, attrName, script, event);
+        const host2 = SwcUtils.findNearestSwcHost(node);
+        if (host2 && host2.isConnected && typeof host2.__swc_executeAttributeEvent === "function") {
+          await host2.__swc_executeAttributeEvent(node, attrName, script, event);
           event.__swc_handled = true;
           break;
         }
@@ -7096,7 +7884,6 @@ var dooboostoreSimpleWebComponent = (() => {
       const oldHandler = handlers.get(attrName);
       if (oldHandler) el.removeEventListener(eventName, oldHandler);
       const handler = async (event) => {
-        console.log("execute handler", event);
         const parent = SwcUtils.findNearestSwcHost(el);
         const hostSet = SwcUtils.getHostSet(parent || el);
         const conf = getElementConfig(this);
@@ -7117,7 +7904,6 @@ var dooboostoreSimpleWebComponent = (() => {
     };
     proto.__swc_executeAttributeEvent = async function(el, attrName, script, event) {
       ensureInit2(this);
-      console.log("execute handler2", event);
       const parent = SwcUtils.findNearestSwcHost(el);
       const hostSet = SwcUtils.getHostSet(parent || el);
       const conf = getElementConfig(this);
@@ -7157,12 +7943,22 @@ var dooboostoreSimpleWebComponent = (() => {
     const emitCustomEventList = getEmitCustomEventMetadataList(constructor) || [];
     const emitHostCustomEventList = emitCustomEventList.filter((meta) => meta.selector === ":host" || meta.selector === "");
     const addEventListenerList = getAddEventListenerMetadata(constructor) || [];
-    const addHostEventListenerList = addEventListenerList.filter((meta) => meta.selector === ":host" || meta.selector === "");
     const attrChangeMap = findAllAttributeChangedMetadata(constructor);
     const attributeList = findAllAttributeMetadata(constructor);
+    const applyAttributeMap = findAllAttributeApplyMetadata(constructor);
     const swcLifecycleAttributes = ["swc-on-constructor", "swc-on-connected", "swc-on-disconnected", "swc-on-before-connected", "swc-on-after-connected", "swc-on-before-disconnected", "swc-on-after-disconnected", "swc-on-before-adopted", "swc-on-after-adopted", "swc-on-attribute-changed"];
     const swcOnEvents = DOM_EVENT_NAMES.map((e) => `swc-on-${e}`);
-    const mergedObservedAttributes = [.../* @__PURE__ */ new Set([...metadata.observedAttributes ?? [], ...attrChangeMap.keys(), ...Array.from(findAllSetAttributeMetadata(constructor).values()).map((it) => it.name), ...attributeList.map((it) => it.options.name || String(it.propertyKey)), ...emitHostCustomEventList.map((it) => it.options.attributeName).filter(Boolean), ...swcLifecycleAttributes, ...swcOnEvents])];
+    const attributeApplyNames = Array.from(applyAttributeMap.values()).map((it) => it.options.name).filter(Boolean);
+    const attributeListNames = attributeList.map((it) => it.options.name || String(it.propertyKey));
+    const mergedObservedAttributes = [.../* @__PURE__ */ new Set([
+      ...metadata.observedAttributes ?? [],
+      ...attrChangeMap.keys(),
+      ...attributeApplyNames,
+      ...attributeListNames,
+      ...emitHostCustomEventList.map((it) => it.options.attributeName).filter(Boolean),
+      ...swcLifecycleAttributes,
+      ...swcOnEvents
+    ])];
     const connectedInnerHtmlList = getOnConnectedInnerHtmlMetadata(constructor) || [];
     const proto = constructor.prototype;
     setupPrototype(proto);
@@ -7181,7 +7977,6 @@ var dooboostoreSimpleWebComponent = (() => {
         for (const m of bMethods) this._invokeLifecycleMethod(m, hostSet);
       }
       attributeList.forEach((meta) => {
-        const attrName = meta.options.name || String(meta.propertyKey);
         if (meta.options.connectedInitialize === true) {
           this.__swc_syncing_init = true;
           try {
@@ -7321,22 +8116,6 @@ var dooboostoreSimpleWebComponent = (() => {
           }
         });
       });
-      addHostEventListenerList.forEach((meta) => {
-        const { type, options } = meta;
-        const opts = { capture: options.capture, once: options.once, passive: options.passive };
-        const handler = async (event) => {
-          if (options.stopPropagation) event.stopPropagation();
-          if (options.stopImmediatePropagation) event.stopImmediatePropagation();
-          if (options.preventDefault) event.preventDefault();
-          const currentHostSet = SwcUtils.getHostSet(this);
-          const args = { event, ...currentHostSet, $el: this, $root: this.getRootNode() };
-          await this[meta.propertyKey](event, currentHostSet, args);
-        };
-        this.addEventListener(type, handler, opts);
-        if (options.removeOnDisconnected === true) {
-          this._boundListeners.push({ target: this, type, handler, options: opts });
-        }
-      });
       if (originalConnected) originalConnected.apply(this);
       const aMethods = findAllLifecycleMetadata(this, ON_AFTER_CONNECTED_METADATA_KEY);
       if (aMethods) {
@@ -7375,67 +8154,1226 @@ var dooboostoreSimpleWebComponent = (() => {
       if (bMethods) {
         for (const m of bMethods) this._invokeLifecycleMethod(m, hostSet);
       }
-      if (originalAdopted) originalAdopted.apply(this);
-      const aMethods = findAllLifecycleMetadata(this, ON_AFTER_ADOPTED_METADATA_KEY);
-      if (aMethods) {
-        for (const m of aMethods) this._invokeLifecycleMethod(m, hostSet);
+      if (originalAdopted) originalAdopted.apply(this);
+      const aMethods = findAllLifecycleMetadata(this, ON_AFTER_ADOPTED_METADATA_KEY);
+      if (aMethods) {
+        for (const m of aMethods) this._invokeLifecycleMethod(m, hostSet);
+      }
+      this._executeSwcScript("swc-on-adopted", hostSet);
+      this._executeSwcScript("swc-on-after-adopted", hostSet);
+    };
+    const originalAttributeChanged = proto.attributeChangedCallback;
+    proto.attributeChangedCallback = function(name2, old, newVal) {
+      if (originalAttributeChanged) originalAttributeChanged.apply(this, [name2, old, newVal]);
+      const hSet = SwcUtils.getHostSet(this);
+      if (name2.startsWith("swc-on-") && !swcLifecycleAttributes.includes(name2)) {
+        if (newVal !== null) {
+          const eventName = name2.substring(7);
+          this._bindAttributeEvent(this, name2, newVal, eventName);
+        }
+      }
+      const hostCustomEventMeta = emitHostCustomEventList.find((it) => it.options.attributeName === name2);
+      if (hostCustomEventMeta && newVal !== null) {
+        this._bindAttributeEvent(this, name2, newVal, hostCustomEventMeta.type);
+      }
+      const mKeys = attrChangeMap.get(name2);
+      if (mKeys && Array.isArray(mKeys)) {
+        for (const key of mKeys) this[key](newVal, old, name2, hSet);
+      }
+    };
+    Object.defineProperty(constructor, "observedAttributes", {
+      get: () => mergedObservedAttributes,
+      configurable: true
+    });
+    ReflectUtils.defineMetadata(ELEMENT_CONFIG_KEY, metadata, constructor);
+    const registry = metadata.customElementRegistry || win?.customElements;
+    if (registry && !registry.get(metadata.name)) {
+      registry.define(metadata.name, constructor, metadata.extends ? { extends: metadata.extends } : void 0);
+    }
+    return constructor;
+  };
+
+  // ../simple-boot/dist/esm/throwable/SimError.js
+  var SimError = class {
+    constructor(message, name, stack) {
+      this.message = message;
+      this.name = name;
+      this.stack = stack;
+    }
+  };
+
+  // ../simple-boot/dist/esm/throwable/SimNoSuch.js
+  var SimNoSuch = class extends SimError {
+    constructor(message, name, stack) {
+      super(message, name, stack);
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/SimDecorator.js
+  var Lifecycle = /* @__PURE__ */ ((Lifecycle2) => {
+    Lifecycle2["Singleton"] = "Singleton";
+    Lifecycle2["Transient"] = "Transient";
+    return Lifecycle2;
+  })(Lifecycle || {});
+  var sims = /* @__PURE__ */ new Map();
+  var containers = /* @__PURE__ */ new Set();
+  var SimMetadataKey = Symbol.for("simple-boot:sim-metadata");
+  var isNotNullObjetInstance = (target) => target != null && target !== void 0 && typeof target === "object";
+  var simProcess = (config, inputTarget) => {
+    const target = (() => {
+      if (typeof inputTarget === "object") {
+        return config.scope === "Singleton" ? inputTarget : ValidUtils.isPlainObject(inputTarget) ? { ...inputTarget } : inputTarget;
+      }
+      if (ValidUtils.isArrowFunction(inputTarget)) {
+        return () => inputTarget();
+      }
+      return inputTarget;
+    })();
+    let targetType;
+    if (isNotNullObjetInstance(target)) {
+      targetType = target.constructor;
+    } else {
+      targetType = target;
+    }
+    config.scope = config?.scope ?? "Singleton";
+    ReflectUtils.defineMetadata(SimMetadataKey, config, targetType);
+    const adding = (targetKey, target2 = targetKey) => {
+      const items = sims.get(targetKey) ?? /* @__PURE__ */ new Set();
+      items.add(target2);
+      sims.set(targetKey, items);
+    };
+    if (Array.isArray(config?.type)) {
+      config?.type.forEach((it) => {
+        adding(it, target);
+      });
+    } else if (config.type) {
+      adding(config?.type, target);
+    } else {
+      adding(target);
+    }
+  };
+  function Sim(configOrTarget) {
+    if (typeof configOrTarget === "function") {
+      simProcess({}, configOrTarget);
+    } else {
+      return (target) => {
+        simProcess(configOrTarget, target);
+      };
+    }
+  }
+  var getSim = (target) => {
+    if (target != null && target !== void 0 && typeof target === "object") {
+      target = Object.getPrototypeOf(target).constructor;
+    }
+    try {
+      return ReflectUtils.getMetadata(SimMetadataKey, target);
+    } catch (e) {
+    }
+  };
+  var PostConstructMetadataKey = Symbol.for("simple-boot:post-construct-metadata");
+  var getPostConstructs = (target) => {
+    return ReflectUtils.getMetadata(PostConstructMetadataKey, target) ?? [];
+  };
+
+  // ../simple-boot/dist/esm/simstance/SimAtomic.js
+  var SimAtomic = class {
+    constructor(type, simstanceManager, config) {
+      this.type = type;
+      this.simstanceManager = simstanceManager;
+      this.config = config;
+      this.value = type.value;
+    }
+    getConfig(key = SimMetadataKey) {
+      return ReflectUtils.getMetadata(key, this.type.originalType);
+    }
+    getConfigs() {
+      return ReflectUtils.getMetadatas(this.type.originalType);
+    }
+    getValue(config) {
+      if (config?.refresh) {
+        this.value = void 0;
+      }
+      if (!this.value) {
+        if (typeof this.type.targetKeyType === "symbol") {
+          this.value = this.simstanceManager.findFirstSim(this.type.targetKeyType)?.getValue();
+        } else {
+          this.value = this.simstanceManager.getOrNewSim({ target: this.type.targetKeyType, originTypeTarget: this.type.originalType, newInstanceCarrier: config?.newInstanceCarrier });
+        }
+      }
+      return this.value;
+    }
+  };
+
+  // ../simple-boot/dist/esm/SimOption.js
+  var SimOption = class {
+    constructor({ rootRouter, container, cache, advice = [], excludeProxys, proxy, using } = {}) {
+      this.rootRouter = rootRouter;
+      this.container = container;
+      this.advice = advice;
+      this.excludeProxys = excludeProxys;
+      this.proxy = proxy;
+      this.using = using;
+      this.cache = cache;
+    }
+    addAdvicce(advice) {
+      this.advice ?? (this.advice = []);
+      this.advice.push(advice);
+    }
+    setAdvice(...advice) {
+      this.advice = advice;
+      return this;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/MetaDataAtomic.js
+  var MetaDataAtomic = class {
+    constructor(target, metaData) {
+      this.target = target;
+      this.metaData = metaData;
+    }
+  };
+  var MetaDataPropertyAtomic = class extends MetaDataAtomic {
+    constructor(target, metaData, property, parameter) {
+      super(target, metaData);
+      this.property = property;
+      this.parameter = parameter;
+    }
+    call(...parameter) {
+      return this.target[this.property](...parameter);
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/aop/AOPDecorator.js
+  var AfterMetadataKey = Symbol.for("simple-boot:after-metadata");
+  var BeforeMetadataKey = Symbol.for("simple-boot:before-metadata");
+  var AroundMetadataKey = Symbol.for("simple-boot:around-metadata");
+  var getAfter = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(AfterMetadataKey, target, propertyKey);
+  };
+  var getAfters = (target) => {
+    return ObjectUtils.allProtoTypeName(target).map((it) => new MetaDataPropertyAtomic(target, getAfter(target, it), it)).filter((it) => it.metaData !== void 0) || [];
+  };
+  var getProtoAfters = (target, propertyKey, type) => {
+    return getAfters(target).filter((it) => propertyKey === it.metaData?.property && type === it.metaData.type?.prototype) || [];
+  };
+  var getBefore = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(BeforeMetadataKey, target, propertyKey);
+  };
+  var getBefores = (target) => {
+    return ObjectUtils.allProtoTypeName(target).map((it) => new MetaDataPropertyAtomic(target, getBefore(target, it), it)).filter((it) => it.metaData !== void 0) || [];
+  };
+  var getProtoBefores = (target, propertyKey, type) => {
+    return getBefores(target).filter((it) => propertyKey === it.metaData?.property && type === it.metaData.type?.prototype) || [];
+  };
+
+  // ../simple-boot/dist/esm/decorators/exception/ExceptionDecorator.js
+  var ExceptionHandlerSituationType = /* @__PURE__ */ ((ExceptionHandlerSituationType2) => {
+    ExceptionHandlerSituationType2["ERROR_OBJECT"] = "SIMPLE_BOOT_CORE://ExceptionHandler/ERROR_OBJECT";
+    ExceptionHandlerSituationType2["PARAMETER"] = "SIMPLE_BOOT_CORE://ExceptionHandler/PARAMETER";
+    return ExceptionHandlerSituationType2;
+  })(ExceptionHandlerSituationType || {});
+  var ExceptionHandlerMetadataKey = Symbol.for("simple-boot:exception-handler-metadata");
+  var getExceptionHandlers = (target) => {
+    if (target !== null && void 0 !== target && typeof target === "object") {
+      target = target.constructor;
+    }
+    return ReflectUtils.getMetadata(ExceptionHandlerMetadataKey, target);
+  };
+  var targetExceptionHandlers = (target, error) => {
+    const exceptionHandlers = getExceptionHandlers(target);
+    const emptyTargets = exceptionHandlers?.filter((it) => it.config.type === void 0);
+    const targets = exceptionHandlers?.filter((it) => ObjectUtils.isPrototypeOfTarget(it.config.type, error));
+    const targetSorts = targets?.sort((a, b) => {
+      const aPrototypeOfDepth = ObjectUtils.prototypeOfDepth(error, a.config.type);
+      const bPrototypeOfDepth = ObjectUtils.prototypeOfDepth(error, b.config.type);
+      return aPrototypeOfDepth.length - bPrototypeOfDepth.length;
+    });
+    return (targetSorts ?? []).concat(...emptyTargets ?? []);
+  };
+  var targetExceptionHandler = (target, error, excludeMethods = []) => {
+    let exceptionHandlers = targetExceptionHandlers(target, error);
+    exceptionHandlers = exceptionHandlers?.filter((it) => !excludeMethods.includes(it.method));
+    if (exceptionHandlers && exceptionHandlers.length > 0) {
+      return exceptionHandlers[0];
+    } else {
+      return void 0;
+    }
+  };
+
+  // ../simple-boot/dist/esm/proxy/SimProxyHandler.js
+  var SimProxyHandler = class {
+    constructor(simpleApplication, simstanceManager, simOption) {
+      this.simpleApplication = simpleApplication;
+      this.simstanceManager = simstanceManager;
+      this.simOption = simOption;
+    }
+    // 잘받게 해놨네 ㅋㅋ  simstanceManager
+    get(target, name) {
+      if (name === "_SimpleBoot_application") {
+        return this.simpleApplication;
+      } else if (name === "_SimpleBoot_simstanceManager") {
+        return this.simstanceManager;
+      } else if (name === "_SimpleBoot_simOption") {
+        return this.simOption;
+      } else if (name === "_SimpleBoot_origin") {
+        return target;
+      } else {
+        return target[name];
+      }
+    }
+    set(obj, prop, value, receiver) {
+      value = this.simstanceManager?.proxy(value);
+      obj[prop] = value;
+      return true;
+    }
+    apply(target, thisArg, argumentsList) {
+      let r;
+      try {
+        this.aopBefore(thisArg, target);
+        try {
+          r = Reflect.apply(target, thisArg, argumentsList);
+        } catch (e) {
+          throw e;
+        } finally {
+          this.aopAfter(thisArg, target);
+        }
+      } catch (e) {
+        console.error(e);
+        const inHandlers = this.getExceptionHandler(e, thisArg, target);
+        if (inHandlers.length > 0 && inHandlers[0]) {
+          const inHandler = inHandlers[0];
+          this.executeExceptionHandler(e, inHandler, argumentsList);
+        } else {
+          throw e;
+        }
+      }
+      return r;
+    }
+    executeExceptionHandler(e, inHandler, argumentsList) {
+      const otherStorage = /* @__PURE__ */ new Map();
+      otherStorage.set(e.constructor, e);
+      const situationErrorTypeContainer = new SituationTypeContainer({
+        situationType: ExceptionHandlerSituationType.ERROR_OBJECT,
+        data: e
+      });
+      const situationParameterTypeContainer = new SituationTypeContainer({
+        situationType: ExceptionHandlerSituationType.PARAMETER,
+        data: argumentsList
+      });
+      otherStorage.set(SituationTypeContainers, new SituationTypeContainers([situationErrorTypeContainer, situationParameterTypeContainer]));
+      argumentsList?.forEach((it) => {
+        otherStorage.set(it.constructor, it);
+      });
+      try {
+        this.simstanceManager.executeBindParameterSim(
+          {
+            target: inHandler.thisArg,
+            targetKey: inHandler.config.propertyKey
+          },
+          otherStorage
+        );
+      } catch (es) {
+        e = es;
+      }
+      if (inHandler.config.config.throw) {
+        const exceptionHandler = this.getExceptionHandler(e, inHandler.thisArg, inHandler.config.method);
+        if ((exceptionHandler?.length ?? 0) > 0) {
+          this.executeExceptionHandler(e, exceptionHandler[0], argumentsList);
+        }
+      }
+    }
+    getExceptionHandler(e, thisArg, target) {
+      const globalConfigSets = this.simOption.advice.map((it) => this.simstanceManager?.getOrNewSim({ target: it })).filter((it) => it).map((it) => {
+        return { thisArg: it, config: targetExceptionHandler(it, e, [target]) };
+      }) ?? [];
+      const thisConfigSet = { thisArg, config: targetExceptionHandler(thisArg, e, [target]) };
+      const inHandlers = [thisConfigSet, ...globalConfigSets].filter((it) => it && it.config);
+      return inHandlers;
+    }
+    aopBefore(obj, protoType) {
+      const propertyName = ObjectUtils.prototypeName(obj, protoType);
+      if (propertyName && obj) {
+        getProtoBefores(obj, propertyName).forEach((it) => {
+          it.call(obj, protoType, propertyName);
+        });
+        for (let i = 0; i < this.simOption.advice.length; i++) {
+          const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
+          const protoBefores = getProtoBefores(sim, propertyName, Object.getPrototypeOf(obj));
+          protoBefores.forEach((it) => {
+            it.call(obj, protoType, propertyName);
+          });
+        }
+      }
+    }
+    aopAfter(obj, protoType) {
+      const propertyName = ObjectUtils.prototypeName(obj, protoType);
+      if (propertyName) {
+        getProtoAfters(obj, propertyName).forEach((it) => {
+          it.call(obj, protoType, propertyName);
+        });
+        for (let i = 0; i < this.simOption.advice.length; i++) {
+          const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
+          const protoBefores = getProtoAfters(sim, propertyName, Object.getPrototypeOf(obj));
+          protoBefores.forEach((it) => {
+            it.call(obj, protoType, propertyName);
+          });
+        }
+      }
+    }
+    has(target, key) {
+      if (key === "_SimpleBoot_isProxy") {
+        return true;
+      }
+      return key in target;
+    }
+  };
+
+  // ../simple-boot/dist/esm/lifecycle/OnSimCreate.js
+  var isOnSimCreate = (obj) => {
+    return typeof obj?.onSimCreate === "function";
+  };
+
+  // ../simple-boot/dist/esm/lifecycle/OnSimCreateCompleted.js
+  var isOnSimCreateProxyCompleted = (obj) => {
+    return typeof obj?.onSimCreateProxyCompleted === "function";
+  };
+
+  // ../simple-boot/dist/esm/decorators/SimNoProxy.js
+  var SimNoProxyKey = Symbol.for("simple-boot:sim-no-proxy-metadata");
+  var getSimNoProxy = (target, propertyKey) => {
+    try {
+      if (propertyKey === void 0) {
+        return Reflect.getMetadata(SimNoProxyKey, target);
+      }
+      return Reflect.getMetadata(SimNoProxyKey, target, propertyKey);
+    } catch (e) {
+      return void 0;
+    }
+  };
+  var isSimNoProxy = (target, propertyKey) => {
+    if (target === null || target === void 0) {
+      return false;
+    }
+    return getSimNoProxy(target, propertyKey) === true;
+  };
+
+  // ../simple-boot/dist/esm/simstance/SimstanceManager.js
+  var SimstanceManager = class _SimstanceManager {
+    // private otherInstanceSim?: Map<ConstructorType<any> | Function, any>;
+    constructor(simpleApplication, option) {
+      this.simpleApplication = simpleApplication;
+      this.option = option;
+      this._storage = /* @__PURE__ */ new Map();
+      this.name = "simstanceManager-" + RandomUtils.uuid4();
+      this.setStoreSet(SimpleApplication, this.simpleApplication);
+      this.setStoreSet(_SimstanceManager, this);
+      this.setStoreSet(option.constructor, option);
+      this.setStoreSet(SimOption, option);
+      this.simProxyHandler = new SimProxyHandler(this.simpleApplication, this, option);
+    }
+    get storage() {
+      return this._storage;
+    }
+    getSimAtomics() {
+      const r = [];
+      Array.from(this.storage.entries()).forEach(([targetKeyType, targetMap]) => {
+        r.push(
+          ...Array.from(Array.from(targetMap.keys())).map(
+            (sit) => new SimAtomic(
+              {
+                targetKeyType,
+                originalType: sit
+              },
+              this
+            )
+          )
+        );
+      });
+      return r;
+    }
+    getSimConfig(schemeOrSymbol) {
+      const newVar = this.getSimAtomics().filter((it) => {
+        const config = it?.getConfig();
+        const symbols = ConvertUtils.flatArray(config?.symbol);
+        const schemes = ConvertUtils.flatArray(config?.scheme);
+        if (typeof schemeOrSymbol === "symbol") {
+          return schemeOrSymbol && it && symbols.includes(schemeOrSymbol);
+        } else if (typeof schemeOrSymbol === "string") {
+          return schemeOrSymbol && it && schemes.includes(schemeOrSymbol);
+        } else {
+          return false;
+        }
+      }) || [];
+      return newVar;
+    }
+    findSims(data) {
+      let r = [];
+      if (data) {
+        const simAtomics = this.getSimAtomics();
+        r = simAtomics.filter((it) => {
+          let b = false;
+          const config = it.getConfig();
+          const symbols = ConvertUtils.flatArray(config?.symbol).filter(ValidUtils.isDefined);
+          const schemes = ConvertUtils.flatArray(config?.scheme).filter(ValidUtils.isDefined);
+          if (typeof data === "symbol") {
+            b = symbols.includes(data);
+          } else {
+            const { scheme, type } = data;
+            b = (scheme ? schemes.includes(scheme) : true) && (type ? it.type.targetKeyType === type : true);
+          }
+          return b;
+        });
+      }
+      return r;
+    }
+    findFirstSim(data) {
+      if (typeof data === "symbol") {
+        return this.findSims(data)[0];
+      } else {
+        return this.findSims(data)[0];
+      }
+    }
+    findLastSim(data) {
+      if (typeof data === "symbol") {
+        return this.findSims(data).reverse()[0];
+      } else {
+        return this.findSims(data).reverse()[0];
+      }
+    }
+    flatStoreSets() {
+      return new Map(
+        Array.from(this.storage.values()).map((it) => Array.from(it.entries())).flat()
+      );
+    }
+    getStoreSets(targetKey) {
+      const map = this.storage.get(targetKey);
+      const datas = (Array.from(map?.entries?.() ?? []) ?? []).reverse();
+      return datas.map((it) => ({ type: it[0], instance: it[1] }));
+    }
+    getStoreSet(targetKey, target) {
+      const sets = this.getStoreSets(targetKey);
+      let find = sets.find((it) => it.type === target);
+      if (!find && (!target || target === targetKey)) {
+        find = sets.find((it) => it.instance);
+      }
+      if (!find?.instance) {
+        const type = target ?? targetKey;
+        if (typeof type === "object") {
+          const find2 = this.storage.get(type);
+          if (find2) {
+            return { type, instance: type };
+          }
+        }
+        const flatStoreSets = this.flatStoreSets();
+        const data = flatStoreSets.get(type);
+        if (data) {
+          this.setStoreSet(targetKey, data, type);
+        }
+        return { type, instance: data };
+      } else {
+        return find;
+      }
+    }
+    getStoreInstance(targetKey, target) {
+      return this.getStoreSet(targetKey, target)?.instance;
+    }
+    getOrNewSim({ target, originTypeTarget = target, newInstanceCarrier }) {
+      if (target) {
+        const registed = this.getStoreSet(target, originTypeTarget);
+        if (registed?.type && !registed?.instance) {
+          return this.resolve({
+            targetKey: target,
+            target: originTypeTarget,
+            newInstanceCarrier
+          });
+        }
+        return registed?.instance;
+      }
+    }
+    setStoreSet(targetKey, obj, target = targetKey) {
+      const itemMap = this.storage.get(targetKey) ?? /* @__PURE__ */ new Map();
+      itemMap.set(target, obj);
+      this.storage.set(targetKey, itemMap);
+    }
+    registerStore(targetKey, regTyps) {
+      const itemMap = this.storage.get(targetKey) ?? /* @__PURE__ */ new Map();
+      regTyps.forEach((it) => {
+        const { type, value } = typeof it === "object" ? { type: it.constructor, value: it } : { type: it, value: void 0 };
+        if (!itemMap.has(type) || value !== void 0 && itemMap.get(type) === void 0) {
+          itemMap.set(type, value);
+        }
+      });
+      this.storage.set(targetKey, itemMap);
+    }
+    // 진입점
+    resolve({ target, targetKey, newInstanceCarrier = { newInstances: [], depth: 0 } }) {
+      const registed = this.getStoreSet(targetKey, target);
+      if (registed?.instance) {
+        return registed.instance;
+      }
+      if (this.storage.has(targetKey) && void 0 === registed?.instance) {
+        newInstanceCarrier.depth++;
+        const newSim = this.newSim({
+          target: registed?.type ?? targetKey,
+          newInstanceCarrier,
+          simCreateAfter: (data) => {
+            if (getSim(registed?.type ?? target ?? targetKey)?.scope === Lifecycle.Singleton) {
+              this.setStoreSet(targetKey, data, target);
+            }
+          }
+        });
+        newInstanceCarrier.depth--;
+        if (newInstanceCarrier.depth === 0) {
+          newInstanceCarrier.newInstances.forEach((it) => {
+            this.callBindPostConstruct(it);
+          });
+        }
+        if (isOnSimCreate(newSim)) {
+          newSim.onSimCreate();
+        }
+        return newSim;
+      }
+      const simNoSuch = new SimNoSuch("SimNoSuch: no simple instance(resolve) name:" + targetKey?.prototype?.constructor?.name + "," + targetKey);
+      console.error(simNoSuch);
+      throw simNoSuch;
+    }
+    newSim({ target, simCreateAfter, otherStorage, newInstanceCarrier }) {
+      const parameters = this.getParameterSim({
+        target,
+        otherStorage,
+        newInstanceCarrier
+      });
+      const r = ValidUtils.isFunction(target) && !target.prototype ? target(...parameters) : new target(...parameters);
+      let p = this.proxy(r);
+      const config = getSim(target);
+      if (config?.proxy) {
+        const proxys = (Array.isArray(config.proxy) ? config.proxy : [config.proxy]).filter(ValidUtils.isDefined);
+        proxys.forEach((it) => {
+          if (typeof it === "object") {
+            p = new Proxy(p, it);
+          } else {
+            const simConfig = getSim(it);
+            p = new Proxy(p, simConfig ? this.getOrNewSim({ target: it }) : this.newSim({ target: it }));
+          }
+        });
+      }
+      newInstanceCarrier?.newInstances.push(p);
+      simCreateAfter?.(p);
+      if (isOnSimCreateProxyCompleted(p)) {
+        p.onSimCreateProxyCompleted(p);
+      }
+      return p;
+    }
+    callBindPostConstruct(obj) {
+      const postConstruct = getPostConstructs(obj);
+      postConstruct.forEach((it) => {
+        obj[it.property](...this.getParameterSim({ target: obj, targetKey: it.property }));
+      });
+    }
+    async executeBindParameterSimPromise({ target, targetKey, firstCheckMaker, parameterCount, inputParameters }, otherStorage) {
+      const binds = this.getParameterSim({ target, targetKey, firstCheckMaker, otherStorage, parameterCount, inputParameters });
+      if (typeof target === "object" && targetKey) {
+        const targetMethod = target[targetKey];
+        return targetMethod?.bind(target)?.(...binds);
+      } else if (typeof target === "function" && !targetKey) {
+        return new target(...binds);
+      }
+    }
+    executeBindParameterSim({ target, targetKey, firstCheckMaker, parameterCount, inputParameters }, otherStorage) {
+      const binds = this.getParameterSim({ target, targetKey, firstCheckMaker, otherStorage, parameterCount, inputParameters });
+      if (typeof target === "object" && targetKey) {
+        const targetMethod = target[targetKey];
+        return targetMethod?.bind(target)?.(...binds);
+      } else if (typeof target === "function" && !targetKey) {
+        return new target(...binds);
+      }
+    }
+    getParameterSim({ target, targetKey, firstCheckMaker, otherStorage, newInstanceCarrier, parameterCount, inputParameters = [] }) {
+      const paramTypes = ReflectUtils.getParameterTypes(target, targetKey) || [];
+      let injections = [];
+      const injects = getInject(target, targetKey);
+      const loopCount = Math.max(paramTypes.length, parameterCount ?? 0);
+      const loopArray = new Array(loopCount).fill(void 0);
+      injections = loopArray.map((_, idx) => {
+        const token = paramTypes[idx];
+        const saveInject = injects?.find((it) => it.index === idx);
+        for (const f of firstCheckMaker ?? []) {
+          const firstCheckObj = f({ target, targetKey }, token, idx, saveInject);
+          if (void 0 !== firstCheckObj) {
+            return firstCheckObj;
+          }
+        }
+        if (saveInject) {
+          const inject = saveInject.config;
+          let obj = otherStorage?.get(token);
+          if (token === Array && (isTargetType(inject) || isTargetScheme(inject) || isTargetSymbol(inject))) {
+            const p = [];
+            if (isTargetType(inject) && inject.type) {
+              p.push(
+                ...this.getStoreSets(inject.type).map(
+                  (it) => this.resolve({
+                    targetKey: inject.type,
+                    target: it.type,
+                    newInstanceCarrier
+                  })
+                ).reverse()
+              );
+            }
+            if (isTargetSymbol(inject)) {
+              p.push(...this.getSimConfig(inject.symbol).map((it) => it.getValue({ newInstanceCarrier })));
+            }
+            if (isTargetScheme(inject)) {
+              p.push(...this.getSimConfig(inject.scheme).map((it) => it.getValue({ newInstanceCarrier })));
+            }
+            return p;
+          }
+          if (inject.situationType && otherStorage) {
+            const situations = otherStorage.get(SituationTypeContainers);
+            const situation = otherStorage.get(SituationTypeContainer);
+            if (inject.situationType === situation?.situationType) {
+              obj = situation.data;
+            } else if (situations && situations.length > 0) {
+              const find = situations.find((a) => {
+                if (a.index !== void 0) {
+                  return a.situationType === inject.situationType && a.index === idx;
+                } else {
+                  return a.situationType === inject.situationType;
+                }
+              });
+              if (find) {
+                obj = find.data;
+              }
+            }
+          }
+          if (!obj) {
+            const currentInstance = typeof target === "object" ? target : void 0;
+            if (isTargetFactory(inject)) {
+              obj = inject.factory({
+                instance: currentInstance,
+                methodName: String(targetKey),
+                parameter: inputParameters,
+                application: this.simpleApplication
+              });
+            } else {
+              let findLastSim;
+              if (isTargetSymbol(inject)) {
+                findLastSim = this.findLastSim(inject.symbol);
+              } else if (isTargetType(inject) || isTargetScheme(inject)) {
+                findLastSim = this.findLastSim(inject);
+              }
+              try {
+                obj = findLastSim ? this.resolve({
+                  targetKey: findLastSim?.type.targetKeyType ?? token,
+                  newInstanceCarrier
+                }) : this.resolve({
+                  targetKey: token,
+                  newInstanceCarrier
+                });
+                if (inject.factory && obj) {
+                  if (typeof inject.factory === "function") {
+                    obj = inject.factory({
+                      instance: currentInstance,
+                      methodName: String(targetKey),
+                      parameter: inputParameters,
+                      application: this.simpleApplication,
+                      injectInstance: obj
+                    });
+                  }
+                }
+              } catch (e) {
+                if (inject.optional) {
+                  return void 0;
+                } else {
+                  throw e;
+                }
+              }
+            }
+          }
+          if (inject.proxy && obj) {
+            if (ValidUtils.isConstructor(inject.proxy)) {
+              const handler = getSim(inject.proxy) ? this.getOrNewSim({ target: inject.proxy }) : new inject.proxy();
+              if (handler) {
+                obj = new Proxy(obj, handler);
+              }
+            } else if (typeof inject.proxy === "function") {
+              const handler = inject.proxy({
+                application: this.simpleApplication,
+                instance: obj
+              });
+              if (handler) {
+                obj = new Proxy(obj, handler);
+              }
+            }
+          }
+          return obj;
+        } else {
+          return otherStorage?.get(token) ?? (token ? this.resolve({ targetKey: token, newInstanceCarrier }) : void 0);
+        }
+      });
+      return injections;
+    }
+    proxy(target) {
+      try {
+        const noProxy = isSimNoProxy(target);
+        const isExcludeProxy = this.option.excludeProxys?.some((it) => target instanceof it);
+        if (!noProxy && !isExcludeProxy && target !== null && getSim(target) && typeof target === "object" && !("_SimpleBoot_isProxy" in target)) {
+          for (const key in target) {
+            if (!isSimNoProxy(target, key)) {
+              target[key] = this.proxy(target[key]);
+            }
+          }
+          const protoTypeName = ObjectUtils.ownPropertyNames(target);
+          protoTypeName.filter((it) => typeof target[it] === "function").filter((it) => !isSimNoProxy(target, it)).filter((it) => !("_SimpleBoot_isProxy" in target[it])).forEach((it) => {
+            target[it] = new Proxy(target[it], this.simProxyHandler);
+          });
+          if (this.simProxyHandler) {
+            target = new Proxy(target, this.simProxyHandler);
+          }
+        }
+        if (this.option.proxy) {
+          target = this.option.proxy.onAfterProxy(target);
+        }
+        return target;
+      } catch (e) {
+        console.log("sim proxy error");
+        throw e;
+      }
+    }
+    run(otherInstanceSim = /* @__PURE__ */ new Map()) {
+      for (const [k, v] of Array.from(otherInstanceSim.entries())) {
+        const storageKey = typeof k === "object" && k !== null && "type" in k ? k.type : k;
+        this.registerStore(storageKey, /* @__PURE__ */ new Set([v]));
+        if (typeof k === "object" && k !== null && "symbol" in k && k.symbol) {
+          this.registerStore(k.symbol, /* @__PURE__ */ new Set([v]));
+        }
+      }
+      const myContainers = ConvertUtils.flatArray(this.option.container).filter(ValidUtils.isDefined);
+      if (!myContainers.includes(this.simpleApplication)) {
+        myContainers.push(this.simpleApplication);
+      }
+      Array.from(sims.entries()).forEach(([type, implementations]) => {
+        const filteredSet = /* @__PURE__ */ new Set();
+        implementations.forEach((impl) => {
+          const config = getSim(impl);
+          const targetContainers = ConvertUtils.flatArray(config?.container).filter(ValidUtils.isDefined);
+          let isInclude = false;
+          if (targetContainers.length <= 0) {
+            isInclude = true;
+          } else {
+            isInclude = myContainers.some((it) => targetContainers.includes(it));
+          }
+          if (isInclude) {
+            filteredSet.add(impl);
+          }
+        });
+        if (filteredSet.size > 0) {
+          this.registerStore(type, filteredSet);
+        }
+      });
+      this.callBindPostConstruct(this);
+      this.getSimAtomics().forEach((it) => {
+        if (it.getConfig()?.autoCreate) {
+          it.getValue();
+        }
+      });
+    }
+  };
+
+  // ../simple-boot/dist/esm/intent/Intent.js
+  var Intent = class {
+    constructor(uri, data, event) {
+      this.uri = uri;
+      this.data = data;
+      this.event = event;
+      this.sessionData = /* @__PURE__ */ new Map();
+      if (typeof uri === "string") {
+        const match = uri.match(/^Symbol\.for\((.+)\):\/(.*)$/);
+        if (match) {
+          const symbol = Symbol.for(match[1]);
+          this.uri = {
+            symbol,
+            uri: match[2]
+          };
+        }
+      }
+    }
+    get symbols() {
+      if (typeof this.uri === "object") {
+        return Array.isArray(this.uri.symbol) ? this.uri.symbol : [this.uri.symbol];
+      }
+      return void 0;
+    }
+    get scheme() {
+      if (typeof this.uri === "string") {
+        const parts = this.uri.split("://");
+        if (parts.length > 1) {
+          return parts[0];
+        }
+        return void 0;
+      } else {
+        return void 0;
+      }
+    }
+    get paths() {
+      return this.pathname.split("/") ?? [];
+    }
+    get fullPath() {
+      const uri = typeof this.uri === "string" ? this.uri : this.uri.uri;
+      const paths = uri.split("://");
+      return paths[paths.length >= 2 ? 1 : 0] ?? "";
+    }
+    get pathname() {
+      const paths = this.fullPath.split("?");
+      return paths[0];
+    }
+    get query() {
+      const paths = this.fullPath.split("?");
+      return paths[1] ?? "";
+    }
+    getQueryParamDecodeURI(key) {
+      const p = this.queryParamsDecodeURI;
+      if (key) {
+        return p[key];
+      } else {
+        return p;
+      }
+    }
+    getQueryParamDecodeURIFirst(key) {
+      const param = this.getQueryParamDecodeURI(key);
+      if (Array.isArray(param)) {
+        return param[0];
+      } else {
+        return param;
+      }
+    }
+    getQueryParam(key) {
+      const p = this.queryParams;
+      if (key) {
+        return p[key];
+      } else {
+        return p;
+      }
+    }
+    getQueryParamFirst(key) {
+      const param = this.getQueryParam(key);
+      if (Array.isArray(param)) {
+        return param[0];
+      } else {
+        return param;
+      }
+    }
+    get queryParams() {
+      const param = {};
+      this.query.split("&")?.forEach((it) => {
+        const a = it.split("=");
+        if (param[a[0]]) {
+          if (Array.isArray(param[a[0]])) {
+            param[a[0]].push(a[1]);
+          } else {
+            param[a[0]] = [param[a[0]], a[1]];
+          }
+        } else {
+          param[a[0]] = a[1];
+        }
+      });
+      return param;
+    }
+    get queryParamsDecodeURI() {
+      const params = this.queryParams;
+      for (const key in params) {
+        if (params.hasOwnProperty(key)) {
+          const param = params[key];
+          if (Array.isArray(param)) {
+            params[key] = param.map((p) => decodeURIComponent(p));
+          } else {
+            params[key] = decodeURIComponent(param);
+          }
+        }
+      }
+      return params;
+    }
+    getPathnameData(urlExpression) {
+      return Expression.Path.pathNameData(this.pathname, urlExpression);
+    }
+    get isSymbolScheme() {
+      return this.symbols !== void 0;
+    }
+  };
+
+  // ../simple-boot/dist/esm/intent/IntentSubscribe.js
+  var isIntentSubscribe = (obj) => {
+    return !!obj && typeof obj.intentSubscribe === "function";
+  };
+
+  // ../simple-boot/dist/esm/intent/IntentManager.js
+  var isRouterPublishType = (it) => typeof it === "object" && it !== null && typeof it.router === "string" && typeof it.rootRouter === "function";
+  var isSymbolPublishType = (it) => typeof it === "object" && it !== null && "symbol" in it && "path" in it;
+  var isSchemePublishType = (it) => typeof it === "object" && it !== null && "scheme" in it && "path" in it;
+  var IntentManager = class {
+    constructor(simpleApplication, simstanceManager, routerManager, simOption) {
+      this.simpleApplication = simpleApplication;
+      this.simstanceManager = simstanceManager;
+      this.routerManager = routerManager;
+      this.simOption = simOption;
+      this.subject = new Subject();
+    }
+    get observable() {
+      return this.subject.asObservable();
+    }
+    async makeIntentData(it, data) {
+      const target = [];
+      const rootRouter = isRouterPublishType(it) ? it.rootRouter : this.simOption.rootRouter;
+      if (isRouterPublishType(it)) {
+        it = it.router;
+      }
+      const routerMatch = typeof it === "string" && it.match(/^Router\((.+)\):\/(.*)$/);
+      if (routerMatch && typeof it === "string") {
+        const routerBasePath = routerMatch[1];
+        const actualPath = routerMatch[2];
+        const routerModule = await this.routerManager.routing(routerBasePath, {
+          router: rootRouter
+        });
+        const instance = routerModule.getModuleInstance();
+        if (instance) {
+          target.push(instance);
+        }
+        it = new Intent(actualPath, data);
+      } else if (isSymbolPublishType(it)) {
+        it = new Intent({ symbol: it.symbol, uri: it.path }, data);
+      } else if (isSchemePublishType(it)) {
+        it = new Intent(`${it.scheme}://${it.path}`, data);
+      } else if (typeof it === "string") {
+        it = new Intent(it, data);
+      }
+      const intent = it;
+      if (!routerMatch) {
+        if (intent.symbols) {
+          target.push(...intent.symbols.map((sym) => this.simstanceManager.findSims(sym)).flat());
+        } else if (intent.scheme) {
+          target.push(...this.simstanceManager.getSimConfig(intent.scheme));
+        } else {
+          target.push(...this.simstanceManager.getSimAtomics());
+        }
+      }
+      return { intent, target };
+    }
+    async publishMeta(it, data) {
+      const { intent, target } = await this.makeIntentData(it, data);
+      const r = [];
+      const targetInstances = target.map((it2) => {
+        if (it2 instanceof SimAtomic) {
+          return it2.getValue();
+        } else {
+          return it2;
+        }
+      });
+      this.subject.next(intent);
+      for (let data2 of targetInstances) {
+        let orNewSim = data2;
+        if (orNewSim) {
+          const filteredPaths = intent.paths.filter((i) => i);
+          if (filteredPaths.length > 0) {
+            let callthis = orNewSim;
+            let lastProp = "";
+            filteredPaths.forEach((i) => {
+              callthis = orNewSim;
+              orNewSim = orNewSim?.[i];
+              lastProp = i;
+            });
+            if (orNewSim && typeof orNewSim === "function") {
+              const intentData = Array.isArray(intent.data) ? intent.data : intent.data !== void 0 ? [intent.data] : [];
+              const result = await this.simstanceManager.executeBindParameterSimPromise({
+                target: callthis,
+                targetKey: lastProp,
+                parameterCount: intentData.length,
+                inputParameters: intentData,
+                firstCheckMaker: [
+                  (obj, token, idx) => {
+                    if (idx < intentData.length) {
+                      return intentData[idx];
+                    }
+                    if (token === Intent && idx === 0) {
+                      return intent;
+                    }
+                  }
+                ]
+              });
+              r.push(result);
+            } else if (orNewSim) {
+              callthis[lastProp] = intent.data;
+              r.push(callthis[lastProp]);
+            }
+          } else {
+            const intentData = Array.isArray(intent.data) ? intent.data : intent.data !== void 0 ? [intent.data] : [];
+            if (isIntentSubscribe(orNewSim)) {
+              r.push(orNewSim.intentSubscribe(...intentData));
+            }
+          }
+        }
+      }
+      return { return: r, target };
+    }
+    async publish(it, data) {
+      const rdata = await this.publishMeta(it, data);
+      return rdata.return;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/inject/Injection.js
+  var InjectionMetadataKey = Symbol("Injection");
+  var getInjection = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(InjectionMetadataKey, target, propertyKey);
+  };
+
+  // ../simple-boot/dist/esm/throwable/MethodNoSuch.js
+  var MethodNoSuch = class extends SimError {
+    constructor(message, name, propertyKeys, stack) {
+      super(message, name, stack);
+      this.propertyKeys = propertyKeys;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/route/Router.js
+  var RouterMetadataKey = Symbol.for("simple-boot:router-metadata");
+  var getRouter = (target) => {
+    if (target != null && typeof target === "object") {
+      target = target.constructor;
+    }
+    try {
+      return ReflectUtils.getMetadata(RouterMetadataKey, target);
+    } catch (e) {
+    }
+  };
+  var RouteMetadataKey = Symbol.for("simple-boot:route-metadata");
+
+  // ../simple-boot/dist/esm/route/RouterModule.js
+  var RouterModule = class {
+    constructor(simstanceManager, router, module, routerChains = []) {
+      this.simstanceManager = simstanceManager;
+      this.router = router;
+      this.module = module;
+      this.routerChains = routerChains;
+    }
+    get path() {
+      return this._path;
+    }
+    set path(value) {
+      this._path = value;
+    }
+    get data() {
+      return this._data;
+    }
+    set data(value) {
+      this._data = value;
+    }
+    get intent() {
+      return this._intent;
+    }
+    set intent(value) {
+      this._intent = value;
+    }
+    get propertyKeys() {
+      return this._propertyKeys;
+    }
+    set propertyKeys(value) {
+      this._propertyKeys = value;
+    }
+    get pathData() {
+      return this._pathData;
+    }
+    getPathData() {
+      return this._pathData;
+    }
+    set pathData(value) {
+      this._pathData = value;
+    }
+    getRouterPath(join = "") {
+      return this.getRouterPaths().map((it) => it ?? "").join(join);
+    }
+    getRouterPaths() {
+      return this.routerChains.map((it) => getRouter(it instanceof SimAtomic ? it.type.targetKeyType : it)?.path);
+    }
+    getRouterPathData(pathName) {
+      return Expression.Path.pathNameData(pathName, this.getRouterPath());
+    }
+    getModuleInstance(propertyKey, instanceBind = true) {
+      const instance = this.simstanceManager.getOrNewSim({ target: this.module?.targetKeyType, originTypeTarget: this.module?.originalType });
+      if (propertyKey && this.propertyKeys && this.propertyKeys.includes(propertyKey)) {
+        let instanceElement = instance[propertyKey];
+        if (instanceBind && typeof instanceBind === "boolean") {
+          instanceElement = instanceElement.bind(instance);
+        } else if (instanceBind && typeof instanceBind === "object") {
+          instanceElement = instanceElement.bind(instanceBind);
+        }
+        return instanceElement;
+      } else {
+        return instance;
+      }
+    }
+    executeModuleProperty(propertyKey, ...param) {
+      const target = this.getModuleInstance();
+      if (propertyKey) {
+        const config = getInjection(target, propertyKey);
+        if (config) {
+          const other = /* @__PURE__ */ new Map();
+          param.forEach((it) => other.set(it.constructor, it));
+          return this.simstanceManager.executeBindParameterSim({ target, targetKey: propertyKey }, other);
+        } else {
+          if (target[propertyKey]) {
+            return target[propertyKey]?.(...param);
+          } else {
+            throw new MethodNoSuch(`${propertyKey.toString()} noSuch`, propertyKey.toString(), propertyKey);
+          }
+        }
+      }
+    }
+    get firstRouteChain() {
+      return this.routerChains[0];
+    }
+    get firstRouteChainValue() {
+      return this.firstRouteChain?.getValue();
+    }
+    get lastRouteChain() {
+      return this.routerChains[this.routerChains.length - 1];
+    }
+    get lastRouteChainValue() {
+      return this.lastRouteChain?.getValue();
+    }
+    hasActivateInLastRoute(obj) {
+      return this.lastRouteChainValue?.hasActivate(obj) === true;
+    }
+    getQueryParamDecodeURI(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamDecodeURI(key);
+      }
+    }
+    getQueryParamDecodeURIFirst(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamDecodeURIFirst(key);
+      }
+    }
+    getQueryParam(key) {
+      if (this.intent) {
+        return this.intent.getQueryParam(key);
       }
-      this._executeSwcScript("swc-on-adopted", hostSet);
-      this._executeSwcScript("swc-on-after-adopted", hostSet);
-    };
-    const originalAttributeChanged = proto.attributeChangedCallback;
-    proto.attributeChangedCallback = function(name2, old, newVal) {
-      if (originalAttributeChanged) originalAttributeChanged.apply(this, [name2, old, newVal]);
-      const hSet = SwcUtils.getHostSet(this);
-      if (name2.startsWith("swc-on-") && !swcLifecycleAttributes.includes(name2)) {
-        if (newVal !== null) {
-          const eventName = name2.substring(7);
-          this._bindAttributeEvent(this, name2, newVal, eventName);
-        }
+    }
+    getQueryParamFirst(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamFirst(key);
       }
-      const hostCustomEventMeta = emitHostCustomEventList.find((it) => it.options.attributeName === name2);
-      if (hostCustomEventMeta && newVal !== null) {
-        this._bindAttributeEvent(this, name2, newVal, hostCustomEventMeta.type);
+    }
+    get queryParams() {
+      if (this.intent) {
+        return this.intent.queryParams;
       }
-      const mKeys = attrChangeMap.get(name2);
-      if (mKeys && Array.isArray(mKeys)) {
-        for (const key of mKeys) this[key](newVal, old, name2, hSet);
+    }
+    get queryParamsAfterDecodeURI() {
+      if (this.intent) {
+        return this.intent.queryParamsDecodeURI;
       }
-    };
-    Object.defineProperty(constructor, "observedAttributes", {
-      get: () => mergedObservedAttributes,
-      configurable: true
-    });
-    ReflectUtils.defineMetadata(ELEMENT_CONFIG_KEY, metadata, constructor);
-    const registry = metadata.customElementRegistry || win?.customElements;
-    if (registry && !registry.get(metadata.name)) {
-      registry.define(metadata.name, constructor, metadata.extends ? { extends: metadata.extends } : void 0);
     }
-    return constructor;
   };
 
-  // ../simple-boot/dist/esm/decorators/SimDecorator.js
-  var SimMetadataKey = Symbol("Sim");
-  var PostConstructMetadataKey = Symbol("PostConstruct");
-
-  // ../simple-boot/dist/esm/decorators/aop/AOPDecorator.js
-  var AfterMetadataKey = Symbol("After");
-  var BeforeMetadataKey = Symbol("Before");
-  var AroundMetadataKey = Symbol("Around");
-
-  // ../simple-boot/dist/esm/decorators/exception/ExceptionDecorator.js
-  var ExceptionHandlerMetadataKey = Symbol("ExceptionHandler");
-
-  // ../simple-boot/dist/esm/decorators/SimNoProxy.js
-  var SimNoProxyKey = Symbol("Sim:NoProxy");
-
-  // ../simple-boot/dist/esm/decorators/inject/Injection.js
-  var InjectionMetadataKey = Symbol("Injection");
-
-  // ../simple-boot/dist/esm/decorators/route/Router.js
-  var RouterMetadataKey = Symbol("Router");
-  var RouteMetadataKey = Symbol("RouteMetadataKey");
-
   // ../simple-boot/dist/esm/route/RouterAction.js
   var RouterAction;
   ((RouterAction2) => {
@@ -7450,6 +9388,435 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   })(RouterAction || (RouterAction = {}));
 
+  // ../simple-boot/dist/esm/route/RouterManager.js
+  var RouterManager = class {
+    constructor(simpleApplication, simstanceManager, simOption) {
+      this.simpleApplication = simpleApplication;
+      this.simstanceManager = simstanceManager;
+      this.simOption = simOption;
+      this.subject = new Subject();
+    }
+    // @SimNoProxy
+    get observable() {
+      return this.subject.asObservable();
+    }
+    routingMap(option) {
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      if (!targetRouter) {
+        throw new Error("no router");
+      }
+      const map = {};
+      if (targetRouter) {
+        const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+        const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+        const routerAtomic = new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+        const routerData = routerAtomic.getConfig(RouterMetadataKey);
+        if (routerData) {
+          const currentPrefix = (option?.prefix ?? "") + routerData.path;
+          if (routerData.route && routerData.route[""]) {
+            map[currentPrefix] = routerData.route[""];
+          }
+          if (routerData.route) {
+            Object.entries(routerData.route).forEach(([key, value]) => {
+              map[currentPrefix + key] = value;
+            });
+          }
+          routerData.routers?.forEach((it) => {
+            Object.assign(map, this.routingMap({ ...option, router: it, prefix: currentPrefix }));
+          });
+        }
+      }
+      return map;
+    }
+    /** 일반적인 lifecycle 타지않는 그냥 find.. 의미가없을듯.
+     * @deprecated
+     */
+    async routings(intent, option) {
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      if (!targetRouter) {
+        throw new Error("no router");
+      }
+      const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+      const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+      const routerAtomic = new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+      const allMatches = this._collectAllMatchingModules(routerAtomic, intent, []);
+      const exactModuleMatches = allMatches.filter((rm) => rm.path === intent.pathname && rm.module);
+      if (exactModuleMatches.length > 0) {
+        exactModuleMatches.forEach((it) => this.subject.next({ intent, routerManager: this, routerModule: it }));
+        return exactModuleMatches;
+      }
+      const exactPathMatches = allMatches.filter((rm) => rm.path === intent.pathname);
+      if (exactPathMatches.length > 0) {
+        exactPathMatches.forEach((it) => this.subject.next({ intent, routerManager: this, routerModule: it }));
+        return exactPathMatches;
+      }
+      return [];
+    }
+    async routing(intent, option) {
+      if (typeof intent === "string") {
+        intent = new Intent(intent);
+      }
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      const callCheckOnRouting = option?.noOnRouting !== true;
+      if (!targetRouter) {
+        debugger;
+        throw new Error("no router");
+      }
+      const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+      const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+      const routerAtomic = typeof targetType === "symbol" ? this.simstanceManager.findFirstSim(targetType) : new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+      const rootRouter = routerAtomic.getValue();
+      const executeModuleResult = this.getExecuteModule(routerAtomic, intent, [], option);
+      if (executeModuleResult) {
+        const [executeModule, routerChains] = executeModuleResult;
+        executeModule.routerChains = routerChains;
+        this.activeRouterModule = executeModule;
+        const routingDataSet = { intent, routerModule: executeModule, routerManager: this };
+        if (routerChains.length > 0) {
+          for (let i = 0; i < routerChains.length; i++) {
+            const current = routerChains[i];
+            const next = routerChains[i + 1];
+            const value = current.getValue();
+            if (RouterAction.isCanActivate(value) && next) {
+              await value.canActivate(routingDataSet, next.getValue());
+            }
+            if (callCheckOnRouting && RouterAction.isOnRouting(value) && next) {
+              await value.onRouting(routingDataSet);
+            }
+          }
+        }
+        this.activeRouterModule = executeModule;
+        const moduleInstance = executeModule.getModuleInstance();
+        if (!executeModule?.module) {
+          const routerChain = executeModule.routerChains[executeModule.routerChains.length - 1];
+          const value = routerChain?.getValue();
+          if (RouterAction.isCanActivate(value)) {
+            await value.canActivate(routingDataSet, moduleInstance);
+          }
+          if (callCheckOnRouting && RouterAction.isOnRouting(value)) {
+            await value.onRouting(routingDataSet);
+          }
+        } else {
+          const value = executeModule.router?.getValue();
+          if (RouterAction.isCanActivate(value)) {
+            await value.canActivate(routingDataSet, moduleInstance);
+          }
+          if (callCheckOnRouting && RouterAction.isOnRouting(value)) {
+            await value.onRouting(routingDataSet);
+          }
+          if (moduleInstance && callCheckOnRouting && RouterAction.isOnRouting(moduleInstance)) {
+            await moduleInstance.onRouting(routingDataSet);
+          }
+        }
+        const find = this.activeRouterModule;
+        this.subject.next({ intent, routerModule: find, routerManager: this });
+        return find;
+      } else {
+        const empty = await this._handleNotFoundRouting(rootRouter, intent);
+        this.subject.next({ intent, routerModule: empty, routerManager: this });
+        return empty;
+      }
+    }
+    /**
+     * URL과 일치하는 라우트를 찾지 못했을 경우를 처리합니다.
+     * "Not Found" 상태를 나타내는 비어있는 RouterModule 객체를 생성하여 반환합니다.
+     * 이 과정에서 rootRouter의 라이프사이클을 호출하여 공통 레이아웃등을 처리할 수 있습니다.
+     * @param rootRouter 앱의 최상위 라우터 인스턴스
+     * @param intent 확인에 실패한 원본 Intent 객체
+     * @private
+     */
+    async _handleNotFoundRouting(rootRouter, intent) {
+      const routerModule = new RouterModule(this.simstanceManager, rootRouter, void 0, []);
+      const routingDataSet = { intent, routerModule, routerManager: this };
+      const value = rootRouter;
+      if (RouterAction.isCanActivate(value)) {
+        await value.canActivate(routingDataSet, null);
+      }
+      if (RouterAction.isOnRouting(value)) {
+        await value.onRouting(routingDataSet);
+      }
+      this.activeRouterModule = routerModule;
+      return this.activeRouterModule;
+    }
+    getExecuteModule(router, intent, parentRouters, option) {
+      const path = intent.pathname;
+      const routerConfig = router.getConfig(RouterMetadataKey);
+      if (routerConfig) {
+        const filters = [];
+        if (Array.isArray(routerConfig.filters)) {
+          filters.push(...routerConfig.filters);
+        } else if (routerConfig.filters) {
+          filters.push(routerConfig.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (noAccept) {
+          return;
+        }
+        const routerStrings = parentRouters.map((it) => it.getConfig(RouterMetadataKey)?.path || "");
+        const isRoot = this.isRootUrl(routerConfig.path, routerStrings, path);
+        if (isRoot) {
+          const currentParentRouters = [...parentRouters, router];
+          if (routerConfig.routers && routerConfig.routers.length > 0) {
+            let bestMatchModule = void 0;
+            let bestMatchLength = -1;
+            for (const child of routerConfig.routers) {
+              const routerAtomic = typeof child === "symbol" ? this.simstanceManager.findFirstSim(child) : new SimAtomic({ targetKeyType: child, originalType: child }, this.simstanceManager);
+              if (!routerAtomic) {
+                continue;
+              }
+              const executeModule = this.getExecuteModule(routerAtomic, intent, currentParentRouters, option);
+              if (executeModule) {
+                const [rm, chains] = executeModule;
+                const currentMatchLength = rm.path?.length || 0;
+                if (currentMatchLength > bestMatchLength) {
+                  bestMatchLength = currentMatchLength;
+                  bestMatchModule = executeModule;
+                } else if (currentMatchLength === bestMatchLength) {
+                  if (option?.find?.router === "last") {
+                    bestMatchModule = executeModule;
+                  }
+                }
+              }
+            }
+            if (bestMatchModule) {
+              return bestMatchModule;
+            }
+          }
+          const module = this.findRouterOrModule(router, routerConfig, routerStrings, intent);
+          if (module) {
+            return [module, currentParentRouters];
+          }
+        }
+      }
+    }
+    // path: 지금 내 라우터의 path,  parentRoots: 부모router path들,  url: 사용자가 원하는 full intent url
+    isRootUrl(path, parentRoots, url) {
+      const searchString = parentRoots.join("") + (path || "");
+      if (searchString === "/") {
+        return true;
+      }
+      const searchs = searchString.split("/");
+      const urls = url.split("/");
+      const trimmedUrls = urls.slice(0, searchs.length).join("/");
+      return !!Expression.Path.pathNameData(trimmedUrls, searchString);
+    }
+    _collectAllMatchingModules(router, intent, parentRouters) {
+      const matches = [];
+      const path = intent.pathname;
+      const routerConfig = router.getConfig(RouterMetadataKey);
+      if (routerConfig) {
+        const filters = [];
+        if (Array.isArray(routerConfig.filters)) {
+          filters.push(...routerConfig.filters);
+        } else if (routerConfig.filters) {
+          filters.push(routerConfig.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (noAccept) {
+          return matches;
+        }
+        const routerStrings = parentRouters.map((it) => it.getConfig(RouterMetadataKey)?.path || "");
+        const isRoot = this.isRootUrl(routerConfig.path, routerStrings, path);
+        if (isRoot) {
+          const currentParentRouters = [...parentRouters, router];
+          if (routerConfig.routers && routerConfig.routers.length > 0) {
+            for (const child of routerConfig.routers) {
+              const routerAtomic = typeof child === "symbol" ? this.simstanceManager.findFirstSim(child) : new SimAtomic({ targetKeyType: child, originalType: child }, this.simstanceManager);
+              if (!routerAtomic) {
+                continue;
+              }
+              matches.push(...this._collectAllMatchingModules(routerAtomic, intent, currentParentRouters));
+            }
+          }
+          const module = this.findRouterOrModule(router, routerConfig, routerStrings, intent);
+          if (module) {
+            module.routerChains = currentParentRouters;
+            matches.push(module);
+          }
+        }
+      }
+      return matches;
+    }
+    findRouterOrModule(router, routerData, parentRoots, intent) {
+      const module = this.findRouting(router, routerData, parentRoots, intent);
+      if (module?.module) {
+        module.intent = intent;
+        return module;
+      }
+      const urlRoot = parentRoots.join("") + (routerData.path || "");
+      if (this.isRootUrl(routerData.path, parentRoots, intent.pathname)) {
+        const rm = new RouterModule(this.simstanceManager, router);
+        rm.intent = intent;
+        rm.path = urlRoot;
+        rm.pathData = intent.getPathnameData(urlRoot);
+        return rm;
+      }
+      return void 0;
+    }
+    findRouting(router, routerData, parentRoots, intent) {
+      const urlRoot = parentRoots.join("") + routerData.path;
+      if (routerData.route) {
+        for (const it of Object.keys(routerData.route).filter((it2) => !it2.startsWith("_"))) {
+          const path = urlRoot + it;
+          const pathnameData = intent.getPathnameData(path);
+          if (pathnameData) {
+            try {
+              const dataSet = this.findRouteProperty(routerData.route, it, intent);
+              const rm = new RouterModule(this.simstanceManager, router, dataSet.child);
+              rm.data = dataSet.data;
+              rm.path = path;
+              rm.pathData = pathnameData;
+              rm.propertyKeys = dataSet.propertyKeys;
+              return rm;
+            } catch (e) {
+            }
+          }
+        }
+      }
+    }
+    findRouteProperty(route, propertyName, intent) {
+      let child;
+      let data;
+      let propertyKeys;
+      const routeElement = route[propertyName];
+      if (typeof routeElement === "function") {
+        child = { targetKeyType: routeElement, originalType: routeElement };
+      } else if (typeof routeElement === "symbol") {
+        const findSimType = this.simstanceManager.findLastSim(routeElement)?.type;
+        if (findSimType?.originalType) {
+          child = { targetKeyType: findSimType.originalType, originalType: findSimType.originalType };
+        }
+      } else if (typeof routeElement === "string") {
+        return this.findRouteProperty(route, routeElement, intent);
+      } else if (Array.isArray(routeElement)) {
+        const r = routeElement?.[0];
+        if (typeof r === "object" && "filters" in r && "target" in r) {
+          const filters = [];
+          if (Array.isArray(r.filters)) {
+            filters.push(...r.filters);
+          } else if (r.filters) {
+            filters.push(r.filters);
+          }
+          const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+          if (!noAccept) {
+            child = { targetKeyType: r.target, originalType: r.target };
+          }
+        } else {
+          child = { targetKeyType: r, originalType: r };
+        }
+        data = routeElement?.[1];
+      } else if (typeof routeElement === "object" && "target" in routeElement && "propertyKeys" in routeElement) {
+        const noAccept = routeElement.filters?.filter((it) => it).some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (!noAccept) {
+          child = { targetKeyType: routeElement.target, originalType: routeElement.target };
+          propertyKeys = routeElement.propertyKeys;
+        }
+      } else if (typeof routeElement === "object" && "filters" in routeElement && "target" in routeElement) {
+        const filters = [];
+        if (Array.isArray(routeElement.filters)) {
+          filters.push(...routeElement.filters);
+        } else if (routeElement.filters) {
+          filters.push(routeElement.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (!noAccept) {
+          child = { targetKeyType: routeElement.target, originalType: routeElement.target };
+        }
+      }
+      return {
+        child,
+        data,
+        propertyKeys
+      };
+    }
+  };
+
+  // ../simple-boot/dist/esm/SimpleApplication.js
+  var SimpleApplication = class _SimpleApplication {
+    // public rootRouter?: ConstructorType<any>;
+    // constructor();
+    // constructor(option: SimOption);
+    // constructor(rootRouter?: ConstructorType<Object> | Function);
+    // constructor(rootRouter?: ConstructorType<Object> | Function, option?: SimOption);
+    // constructor(rootRouter?: (ConstructorType<Object> | Function) | SimOption, option = new SimOption()) {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    constructor(option = new SimOption()) {
+      this.option = option;
+      this.simstanceManager = new SimstanceManager(this, option);
+      this.simstanceManager.setStoreSet(SimstanceManager, this.simstanceManager);
+      this.routerManager = new RouterManager(this, this.simstanceManager, option);
+      this.intentManager = new IntentManager(this, this.simstanceManager, this.routerManager, option);
+      this.simstanceManager.setStoreSet(IntentManager, this.intentManager);
+      this.simstanceManager.setStoreSet(RouterManager, this.routerManager);
+      containers.add(this);
+    }
+    getSimstanceManager() {
+      return this.simstanceManager;
+    }
+    getIntentManager() {
+      return this.intentManager;
+    }
+    getRouterManager() {
+      return this.routerManager;
+    }
+    run(otherInstanceSim) {
+      otherInstanceSim ?? (otherInstanceSim = /* @__PURE__ */ new Map());
+      otherInstanceSim.set(_SimpleApplication, this);
+      this.simstanceManager.run(otherInstanceSim);
+      return this;
+    }
+    simAtomic(type) {
+      if (typeof type === "symbol") {
+        return this.simstanceManager.findFirstSim(type);
+      } else if (typeof type === "function") {
+        return this.simstanceManager.findFirstSim({ type });
+      }
+    }
+    simAtomics(type) {
+      if (typeof type === "symbol") {
+        return this.simstanceManager.findSims(type) ?? [];
+      } else if (typeof type === "function") {
+        return this.simstanceManager.findSims({ type }) ?? [];
+      } else {
+        return [];
+      }
+    }
+    getInstance(type) {
+      const i = this.sim(type);
+      if (i) {
+        return i;
+      } else {
+        throw new SimNoSuch("SimNoSuch: no simple instance(getInstance) name:" + type?.prototype?.constructor?.name + "," + type);
+      }
+    }
+    sim(type) {
+      return this.simAtomic(type)?.getValue();
+    }
+    sims(type) {
+      return this.simAtomics(type).map((it) => it.getValue());
+    }
+    addSim(configOrTarget, target) {
+      const r = Sim(configOrTarget);
+      if (typeof r === "function" && target) {
+        r(target);
+      }
+    }
+    publishIntent(i, data) {
+      return this.intentManager.publish(i, data);
+    }
+    routing(i, option) {
+      if (i instanceof Intent) {
+        return this.routerManager.routing(i, option);
+      } else if (typeof i === "string") {
+        const intent = new Intent(i);
+        return this.routerManager.routing(intent, option);
+      } else {
+        const intent = new Intent(i.path, i.data);
+        return this.routerManager.routing(intent, option);
+      }
+    }
+  };
+
   // ../core-web/dist/esm/element/CanvasUtils.js
   var CanvasUtils;
   ((CanvasUtils2) => {
@@ -8211,73 +10578,391 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   })(ValidUtils2 || (ValidUtils2 = {}));
 
-  // src/utils/TemplateUtils.ts
-  var TemplateUtils;
-  ((TemplateUtils2) => {
-    TemplateUtils2.htmlFragment = (strings, ...values) => {
-      const raw = strings.reduce((acc, str, i) => acc + str + (values[i] !== void 0 ? values[i] : ""), "");
-      const template = document.createElement("template");
-      template.innerHTML = raw.trim();
-      return template.content;
-    };
-    TemplateUtils2.textNode = (strings, ...values) => {
-      const raw = strings.reduce((acc, str, i) => acc + str + (values[i] !== void 0 ? values[i] : ""), "");
-      return document.createTextNode(raw);
-    };
-    TemplateUtils2.commentNode = (strings, ...values) => {
-      const raw = strings.reduce((acc, str, i) => acc + str + (values[i] !== void 0 ? values[i] : ""), "");
-      return document.createComment(raw);
-    };
-    TemplateUtils2.createElement = (info, attrs = {}) => {
-      const el = document.createElement(info.tagName);
-      if (info.innerHtml !== void 0) el.innerHTML = info.innerHtml;
-      Object.entries(attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
-      return el;
-    };
-    const createTagFunction = (tagName) => {
-      return (strings, ...values) => {
-        const el = document.createElement(tagName);
-        el.innerHTML = strings.reduce((acc, str, i) => acc + str + (values[i] !== void 0 ? values[i] : ""), "");
-        return el;
-      };
+  // ../simple-boot/dist/esm/index.js
+  var import_reflect_metadata = __toESM(require_Reflect(), 1);
+
+  // ../simple-boot/dist/esm/alert/AlertAction.js
+  var AlertAction = /* @__PURE__ */ ((AlertAction2) => {
+    AlertAction2["ACTIVE"] = "ACTIVE";
+    AlertAction2["IN_ACTIVE"] = "IN_ACTIVE";
+    return AlertAction2;
+  })(AlertAction || {});
+
+  // ../simple-boot/dist/esm/alert/Alert.js
+  var Alert = class {
+    constructor(alertService, config) {
+      this.alertService = alertService;
+      this.config = config;
+      this.isActive = false;
+      this.activateBefore = [];
+      this.activateAfter = [];
+      this.deActivateBefore = [];
+      this.deActivateAfter = [];
+      this.data = /* @__PURE__ */ new Map();
+      if (config?.uuid) {
+        this.uuid = config.uuid;
+      } else {
+        this.uuid = RandomUtils.uuid();
+      }
+    }
+    addOpenBefore(fn) {
+      this.activateBefore.push(fn);
+    }
+    addOpenAfter(fn) {
+      this.activateAfter.push(fn);
+    }
+    addCloseBefore(fn) {
+      this.deActivateBefore.push(fn);
+    }
+    addCloseAfter(fn) {
+      this.deActivateAfter.push(fn);
+    }
+    setData(key, value) {
+      this.data.set(key, value);
+    }
+    getData(key) {
+      return this.data.get(key);
+    }
+    async activate() {
+      try {
+        await Promise.allSettled(this.activateBefore.map((it) => it())).then((it) => {
+          this.result = this.make();
+          this.alertService?.publish({ action: AlertAction.ACTIVE, alert: this });
+          this.isActive = true;
+          if (this.config?.closeTime !== void 0 && this.config?.closeTime > 0) {
+            setTimeout(() => {
+              this.deActivate();
+            }, this.config.closeTime);
+          }
+          this.config?.activate?.(this.result, this);
+        });
+      } catch (e) {
+      } finally {
+        await Promise.allSettled(this.activateAfter.map((it) => it())).then((it) => {
+        });
+      }
+    }
+    async deActivate() {
+      try {
+        await Promise.allSettled(this.deActivateBefore.map((it) => it())).then((it) => {
+          this.alertService?.publish({ action: AlertAction.IN_ACTIVE, alert: this });
+          this.isActive = false;
+          this.config?.deActivate?.(this.result, this);
+        });
+      } catch (e) {
+      } finally {
+        await Promise.allSettled(this.deActivateAfter.map((it) => it())).then((it) => {
+        });
+      }
+    }
+  };
+
+  // ../simple-boot/dist/esm/alert/AlertFactory.js
+  var __decorate = function(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  };
+  var AlertFactory;
+  (function(AlertFactory2) {
+    AlertFactory2.SYMBOL = Symbol.for("simple-boot:alert-factory-token");
+  })(AlertFactory || (AlertFactory = {}));
+  var DefaultAlertFactory = class DefaultAlertFactory2 {
+    create(data) {
+      return void 0;
+    }
+  };
+  DefaultAlertFactory = __decorate([
+    Sim({ symbol: AlertFactory.SYMBOL })
+  ], DefaultAlertFactory);
+
+  // ../simple-boot/dist/esm/alert/AlertType.js
+  var AlertType = /* @__PURE__ */ ((AlertType2) => {
+    AlertType2["DANGER"] = "DANGER";
+    AlertType2["NORMAL"] = "NORMAL";
+    AlertType2["PROGRESS"] = "PROGRESS";
+    AlertType2["SUCCESS"] = "SUCCESS";
+    AlertType2["ERROR"] = "ERROR";
+    AlertType2["INFO"] = "INFO";
+    AlertType2["WARNING"] = "WARNING";
+    AlertType2["CONSOLE"] = "CONSOLE";
+    AlertType2["ETC"] = "ETC";
+    return AlertType2;
+  })(AlertType || {});
+
+  // ../simple-boot/dist/esm/alert/AlertService.js
+  var __decorate2 = function(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  };
+  var __metadata = function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  var __param = function(paramIndex, decorator) {
+    return function(target, key) {
+      decorator(target, key, paramIndex);
+    };
+  };
+  var _a;
+  var AlertService = class AlertService2 {
+    constructor(alertFactory) {
+      this.name = (/* @__PURE__ */ new Date()).toUTCString();
+      this.subject = new ReplaySubject();
+      this.alertFactory = alertFactory;
+    }
+    // @PostConstruct
+    // postConstruct(
+    // ) {
+    //   this.alertFactory = alertFactory;
+    // }
+    get observable() {
+      return this.subject.asObservable();
+    }
+    publish(data) {
+      this.subject.next(data);
+    }
+    create(factory, config) {
+      return new class extends Alert {
+        make() {
+          return factory(this);
+        }
+      }(this, config);
+    }
+    createFromFactory(type, config) {
+      return this.alertFactory?.create({ caller: this, type, config });
+    }
+    danger(config) {
+      return this.createFromFactory(AlertType.DANGER, config);
+    }
+    progress(config) {
+      config = config ?? {};
+      return this.createFromFactory(AlertType.PROGRESS, config);
+    }
+    success(config) {
+      return this.createFromFactory(AlertType.SUCCESS, config);
+    }
+    info(config) {
+      return this.createFromFactory(AlertType.INFO, config);
+    }
+    error(config) {
+      return this.createFromFactory(AlertType.ERROR, config);
+    }
+    warning(config) {
+      return this.createFromFactory(AlertType.WARNING, config);
+    }
+  };
+  AlertService = __decorate2([
+    Sim,
+    __param(0, Inject({ symbol: AlertFactory.SYMBOL })),
+    __metadata("design:paramtypes", [typeof (_a = typeof AlertFactory !== "undefined" && AlertFactory) === "function" ? _a : Object])
+  ], AlertService);
+
+  // ../simple-boot/dist/esm/decorators/cache/CacheDecorator.js
+  var simpleApplicationCache = /* @__PURE__ */ new WeakMap();
+  var getCacheSet = (simpleApplication) => {
+    return simpleApplicationCache.get(simpleApplication);
+  };
+  var findCacheByKey = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      return Array.from(storage.config.entries()).find(([k, v]) => k === key);
+    }
+  };
+  var findCacheByKeyStartWith = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      return Array.from(storage.config.entries()).filter(([k, v]) => k.startsWith(key));
+    } else {
+      return [];
+    }
+  };
+  var deleteCacheByKey = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      storage.storage.delete(key);
+      findCacheByKeyStartWith(simpleApplication, key).forEach(([k, v]) => {
+        const data = storage.config.get(k);
+        if (data?.expireTimeout) {
+          clearTimeout(data.expireTimeout);
+        }
+        storage.config.delete(k);
+        storage.storage.delete(k);
+      });
+    }
+  };
+  var deleteCacheByKeyStartWith = (simpleApplication, key) => {
+    findCacheByKeyStartWith(simpleApplication, key).forEach(([key2, data]) => deleteCacheByKey(simpleApplication, key2));
+  };
+  var CacheMetadataKey = Symbol.for("simple-boot:cache-metadata");
+
+  // ../simple-boot/dist/esm/cache/CacheManager.js
+  var __decorate3 = function(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  };
+  var __metadata2 = function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  var _a2;
+  var CacheManager = class CacheManager2 {
+    constructor(simpleApplication) {
+      this.simpleApplication = simpleApplication;
+    }
+    findCacheByKey(key) {
+      return findCacheByKey(this.simpleApplication, key);
+    }
+    findCacheByKeyStartWith(key) {
+      return findCacheByKeyStartWith(this.simpleApplication, key);
+    }
+    deleteCacheByKey(key) {
+      return deleteCacheByKey(this.simpleApplication, key);
+    }
+    deleteCacheByKeyStartWith(key) {
+      return deleteCacheByKeyStartWith(this.simpleApplication, key);
+    }
+    getCacheSet() {
+      return getCacheSet(this.simpleApplication);
+    }
+  };
+  CacheManager = __decorate3([
+    Sim,
+    __metadata2("design:paramtypes", [typeof (_a2 = typeof SimpleApplication !== "undefined" && SimpleApplication) === "function" ? _a2 : Object])
+  ], CacheManager);
+
+  // ../simple-boot/dist/esm/decorators/event/EventListener.js
+  var EventListenerMetadataKey = Symbol.for("simple-boot:event-listener-metadata");
+
+  // ../simple-boot/dist/esm/decorators/validate/Validation.js
+  var ValidMetadataKey = Symbol.for("simple-boot:valid-metadata");
+  var ValidationMetadataKey = Symbol.for("simple-boot:validation-metadata");
+
+  // ../simple-boot/dist/esm/fetch/ApiService.js
+  var __decorate4 = function(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  };
+  var __metadata3 = function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  var _a3;
+  var _b;
+  var ApiServiceInterceptor;
+  (function(ApiServiceInterceptor2) {
+    ApiServiceInterceptor2.TOKEN = Symbol.for("simple-boot:api-service-interceptor-token");
+    ApiServiceInterceptor2.resolveAll = (simstanceManager) => {
+      try {
+        return (simstanceManager.findSims(ApiServiceInterceptor2.TOKEN) ?? []).map((it) => it.getValue()).filter(ValidUtils.isDefined);
+      } catch (e) {
+        return [];
+      }
     };
-    TemplateUtils2.htmlDivElement = createTagFunction("div");
-    TemplateUtils2.htmlSpanElement = createTagFunction("span");
-    TemplateUtils2.htmlButtonElement = createTagFunction("button");
-    TemplateUtils2.htmlUlElement = createTagFunction("ul");
-    TemplateUtils2.htmlLiElement = createTagFunction("li");
-    TemplateUtils2.htmlInputElement = createTagFunction("input");
-    TemplateUtils2.htmlAElement = createTagFunction("a");
-    TemplateUtils2.htmlPElement = createTagFunction("p");
-    TemplateUtils2.htmlH1Element = createTagFunction("h1");
-    TemplateUtils2.htmlH2Element = createTagFunction("h2");
-    TemplateUtils2.htmlH3Element = createTagFunction("h3");
-    TemplateUtils2.htmlH4Element = createTagFunction("h4");
-    TemplateUtils2.htmlH5Element = createTagFunction("h5");
-    TemplateUtils2.htmlH6Element = createTagFunction("h6");
-    TemplateUtils2.htmlSectionElement = createTagFunction("section");
-    TemplateUtils2.htmlArticleElement = createTagFunction("article");
-  })(TemplateUtils || (TemplateUtils = {}));
-  var htmlFragment = TemplateUtils.htmlFragment;
-  var textNode = TemplateUtils.textNode;
-  var commentNode = TemplateUtils.commentNode;
-  var createElement = TemplateUtils.createElement;
-  var htmlDivElement = TemplateUtils.htmlDivElement;
-  var htmlSpanElement = TemplateUtils.htmlSpanElement;
-  var htmlButtonElement = TemplateUtils.htmlButtonElement;
-  var htmlUlElement = TemplateUtils.htmlUlElement;
-  var htmlLiElement = TemplateUtils.htmlLiElement;
-  var htmlInputElement = TemplateUtils.htmlInputElement;
-  var htmlAElement = TemplateUtils.htmlAElement;
-  var htmlPElement = TemplateUtils.htmlPElement;
-  var htmlH1Element = TemplateUtils.htmlH1Element;
-  var htmlH2Element = TemplateUtils.htmlH2Element;
-  var htmlH3Element = TemplateUtils.htmlH3Element;
-  var htmlH4Element = TemplateUtils.htmlH4Element;
-  var htmlH5Element = TemplateUtils.htmlH5Element;
-  var htmlH6Element = TemplateUtils.htmlH6Element;
-  var htmlSectionElement = TemplateUtils.htmlSectionElement;
-  var htmlArticleElement = TemplateUtils.htmlArticleElement;
+  })(ApiServiceInterceptor || (ApiServiceInterceptor = {}));
+  var ApiService = class ApiService2 extends HttpJsonFetcher {
+    constructor(simstanceManager, alertService) {
+      super();
+      this.simstanceManager = simstanceManager;
+      this.subject = new Subject();
+      this.alertService = alertService;
+    }
+    // @PostConstruct
+    // postConstruct(alertService: AlertService<any>) {
+    //   this.alertService = alertService;
+    // }
+    get observable() {
+      return this.subject.asObservable();
+    }
+    createPipe(config) {
+      return {};
+    }
+    async beforeProxyFetch(config) {
+      let interceptors = ApiServiceInterceptor.resolveAll(this.simstanceManager);
+      for (const interceptor of interceptors) {
+        if (interceptor.beforeProxyFetch) {
+          config = await interceptor.beforeProxyFetch(config);
+        }
+      }
+      this.subject.next({ type: "beforeFetchData", config });
+      return config;
+    }
+    async afterProxyFetch(config) {
+      let interceptors = ApiServiceInterceptor.resolveAll(this.simstanceManager);
+      let r = config.response;
+      for (const interceptor of interceptors) {
+        if (interceptor.afterProxyFetch) {
+          r = await interceptor.afterProxyFetch(config);
+        }
+      }
+      this.subject.next({ type: "afterFetchData", response: r });
+      return r;
+    }
+    beforeFetch(fetch2) {
+      this.subject.next({ type: "beforeFetch", fetch: fetch2 });
+    }
+    afterFetch(fetch2, response) {
+      this.subject.next({ type: "afterFetch", fetch: fetch2, response });
+    }
+    before(config, pipe) {
+      this.subject.next({ type: "progress", config, pipe });
+      config.config?.config?.callBackProgress?.(config, pipe);
+      if (config.config?.config?.alertProgress) {
+        const alert = this.alertService?.progress({ title: config.config.config.title });
+        if (alert) {
+          pipe.progress = alert;
+          alert.activate();
+        }
+      }
+    }
+    afterSuccess(config, pipe) {
+      this.subject.next({ type: "success", config, pipe });
+      config.config?.config?.callBackSuccess?.(config, pipe);
+      if (config.config?.config?.alertSuccessMsg) {
+        this.alertService?.success({ title: config.config.config.title })?.activate();
+      }
+    }
+    afterSuccessTransform(config, pipe) {
+    }
+    finally(config, pipe) {
+      this.subject.next({ type: "final", config, pipe });
+      config.config?.config?.callBackFinal?.(config, pipe);
+      pipe.progress?.deActivate();
+    }
+    error(config, pipe, e) {
+      console.log("error", e);
+      this.subject.next({ type: "error", config, pipe, e });
+      config.config?.config?.callBackError?.(config, pipe, e);
+      if (config.config?.config?.alertErrorMsg) {
+        this.alertService?.danger({
+          title: `${config.config.config.title ? config.config.config.title : ""}${e.message ? `(${e.message})` : ""}`
+        })?.activate();
+      }
+      if (config.config?.config?.enableErrorConsole) {
+        console.error(`apiService Error ${config?.config?.config?.title}`, e);
+      }
+    }
+    async execute(fetcherRequest) {
+      const target = fetcherRequest.target;
+      const config = fetcherRequest.config;
+      let r = { target, config };
+      const interceptor = ApiServiceInterceptor.resolveAll(this.simstanceManager) ?? [];
+      for (const apiServiceInterceptor of interceptor) {
+        if (apiServiceInterceptor.beforeProxyExecute) {
+          r = await apiServiceInterceptor.beforeProxyExecute?.(r);
+        }
+      }
+      return super.execute(r);
+    }
+  };
+  ApiService = __decorate4([
+    Sim,
+    __metadata3("design:paramtypes", [typeof (_a3 = typeof SimstanceManager !== "undefined" && SimstanceManager) === "function" ? _a3 : Object, typeof (_b = typeof AlertService !== "undefined" && AlertService) === "function" ? _b : Object])
+  ], ApiService);
   return __toCommonJS(bundle_entry_exports);
 })();
 /*! Bundled license information: