@dooboostore/simple-web-component 1.0.24 → 1.0.26

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

@@ -297,8 +297,8 @@ var require_Reflect = __commonJS({
               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);
@@ -1110,10 +1110,10 @@ var require_Reflect = __commonJS({
 });
 
 // src/bundle-entry.ts
-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;
@@ -4789,6 +4789,107 @@ var Observable = class {
   }
 };
 
+// ../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) {
@@ -5123,6 +5224,284 @@ var Promises;
   })(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) {
@@ -5716,7 +6095,7 @@ var Expression;
 })(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;
@@ -5737,15 +6116,15 @@ function addEventListenerHost(type, options) {
 }
 
 // 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) => {
@@ -5796,7 +6175,7 @@ var getOnConnectedInnerHtmlMetadata = (target) => {
 };
 
 // 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);
@@ -5854,15 +6233,14 @@ function attribute(selector, options = {}) {
     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);
@@ -5880,7 +6258,6 @@ function attribute(selector, options = {}) {
         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);
         }
@@ -5896,7 +6273,6 @@ function attribute(selector, options = {}) {
         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);
@@ -5921,13 +6297,9 @@ function attribute(selector, options = {}) {
     });
   };
 }
-var findAllAttributeMetadata = (target) => {
-  return ReflectUtils.findAllMetadata(ATTRIBUTE_METADATA_KEY, target).flat();
-};
 function attributeHost(targetOrAttrOrOptions, propertyKeyOrOptions) {
   if (propertyKeyOrOptions !== void 0 && (typeof propertyKeyOrOptions === "string" || typeof propertyKeyOrOptions === "symbol")) {
-    const fieldName = String(propertyKeyOrOptions);
-    return attribute(":host", { name: fieldName })(targetOrAttrOrOptions, propertyKeyOrOptions);
+    return attribute(":host", { name: String(propertyKeyOrOptions) })(targetOrAttrOrOptions, propertyKeyOrOptions);
   }
   if (typeof targetOrAttrOrOptions === "string") {
     const attrName = targetOrAttrOrOptions;
@@ -5936,19 +6308,20 @@ function attributeHost(targetOrAttrOrOptions, propertyKeyOrOptions) {
   } else if (typeof targetOrAttrOrOptions === "object") {
     const options = targetOrAttrOrOptions;
     return (target, propertyKey) => {
-      const fieldName = String(propertyKey);
-      return attribute(":host", { ...options, name: fieldName })(target, propertyKey);
+      return attribute(":host", { ...options, name: String(propertyKey) })(target, propertyKey);
     };
   } else {
     return (target, propertyKey) => {
-      const fieldName = String(propertyKey);
-      return attribute(":host", { name: fieldName })(target, propertyKey);
+      return attribute(":host", { name: String(propertyKey) })(target, propertyKey);
     };
   }
 }
+var findAllAttributeMetadata = (target) => {
+  return ReflectUtils.findAllMetadata(ATTRIBUTE_FIELD_METADATA_KEY, target).flat();
+};
 
 // 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;
@@ -5974,102 +6347,43 @@ var findAllAttributeChangedMetadata = (target) => {
   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);
-          } else {
-            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();
@@ -6077,94 +6391,58 @@ function applyNode(selector, options = { position: "beforeEnd" }) {
     }
     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 applyRoot = (t) => {
-          if (!t || !(t instanceof HTMLElement))
-            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;
+          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;
         };
-        const hostSet = SwcUtils.getHostSet(this);
-        if (pos === "remove") {
-          if (res) {
-            if (selector === ":host" || !selector) {
-              if (r === "shadow" && this.shadowRoot) {
-                this.shadowRoot.replaceChildren();
-              } else {
-                this.remove();
-              }
-            } else {
-              const targetRoot = applyRoot(this);
-              if (targetRoot) {
-                const targets = targetRoot.querySelectorAll(selector);
-                targets.forEach((el) => el.remove());
-              }
-            }
-          }
-        } else {
-          let targetEl = null;
-          if (selector === ":host") {
-            targetEl = applyRoot(this);
-          } else if (selector === ":parentHost") {
-            targetEl = applyRoot(hostSet.$parentHost);
-          } else if (selector === ":appHost") {
-            targetEl = applyRoot(hostSet.$appHost);
-          } else if (selector === ":firstHost") {
-            targetEl = applyRoot(hostSet.$firstHost);
-          } else if (selector === ":lastHost") {
-            targetEl = applyRoot(hostSet.$lastHost);
-          } else if (selector === ":firstAppHost") {
-            targetEl = applyRoot(hostSet.$firstHost);
-          } else if (selector === ":lastAppHost") {
-            targetEl = applyRoot(hostSet.$lastAppHost);
-          } else {
-            const targetRoot = applyRoot(this);
-            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;
     };
   };
 }
@@ -6179,110 +6457,29 @@ var findAllApplyNodeMetadata = (target) => {
   return result;
 };
 function applyNodeHost(targetOrOptions, propertyKey, descriptor) {
-  console.log("vvvvv");
-  if (propertyKey !== void 0 && typeof propertyKey === "string" || typeof propertyKey === "symbol") {
-    return applyNode(":host", { position: "beforeEnd" })(targetOrOptions, propertyKey, descriptor);
-  }
-  if (typeof targetOrOptions === "object" && targetOrOptions !== null) {
-    const options = targetOrOptions;
-    return applyNode(":host", { ...options, position: options.position || "beforeEnd" });
-  } else {
-    return applyNode(":host", { position: "beforeEnd" });
-  }
-}
-function applyBeforeBeginNode(selector, options) {
-  return applyNode(selector, { ...options, position: "beforeBegin" });
-}
-function applyAfterBeginNode(selector, options) {
-  return applyNode(selector, { ...options, position: "afterBegin" });
+  if (propertyKey !== void 0) return applyNode(":host", { position: "beforeEnd" })(targetOrOptions, propertyKey, descriptor);
+  const opt = targetOrOptions || {};
+  return applyNode(":host", { position: "beforeEnd", ...opt });
 }
-function applyBeforeEndNode(selector, options) {
-  return applyNode(selector, { ...options, position: "beforeEnd" });
+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 applyAfterEndNode(selector, options) {
-  return applyNode(selector, { ...options, position: "afterEnd" });
+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 applyReplaceNode(selector, options) {
-  return applyNode(selector, { ...options, position: "replace" });
-}
-function applyReplaceChildrenNode(selector, options) {
+function applyReplaceChildrenNode(selector, options = {}) {
   return applyNode(selector, { ...options, position: "replaceChildren" });
 }
-function applyInnerHtmlNode(selector, options) {
+function applyInnerHtmlNode(selector, options = {}) {
   return applyNode(selector, { ...options, position: "innerHtml" });
 }
-function applyInnerTextNode(selector, options) {
-  return applyNode(selector, { ...options, position: "innerText" });
-}
-function applyRemoveNode(selector, options) {
-  return applyNode(selector, { ...options, position: "remove" });
-}
-function applyBeforeBeginNodeHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "beforeBegin" });
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...targetOrOptions || {}, position: "beforeBegin" });
-}
-function applyAfterBeginNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "afterBegin" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "afterBegin" });
-}
-function applyBeforeEndNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "beforeEnd" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "beforeEnd" });
-}
-function applyAfterEndNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "afterEnd" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "afterEnd" });
-}
-function applyReplaceNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "replace" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "replace" });
-}
-function applyReplaceChildrenNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "replaceChildren" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "replaceChildren" });
-}
-function applyInnerHtmlNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "innerHtml" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "innerHtml" });
-}
-function applyInnerTextNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "innerText" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, position: "innerText" });
-}
-function applyRemoveNodeHost(optionsOrTarget, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = applyNode(":host", { position: "remove" });
-    return decorator(optionsOrTarget, propertyKey, descriptor);
-  }
-  return applyNode(":host", { ...optionsOrTarget || {}, 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) {
@@ -6453,7 +6650,7 @@ function lastAppHost(targetOrOptions, propertyKey) {
 }
 
 // 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) {
@@ -6620,35 +6817,38 @@ function allLastAppHost(targetOrOptions, propertyKey) {
   }
 }
 
-// src/decorators/classList.ts
-var CLASS_LIST_METADATA_KEY = Symbol("simple-web-component:class-list");
-function createClassListDecorator(action) {
-  return (selector, options = {}) => {
+// 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_LIST_METADATA_KEY, constructor);
+      let metaList = ReflectUtils.getOwnMetadata(CLASS_METADATA_KEY, constructor);
       if (!metaList) {
         metaList = /* @__PURE__ */ new Map();
-        ReflectUtils.defineMetadata(CLASS_LIST_METADATA_KEY, metaList, constructor);
+        ReflectUtils.defineMetadata(CLASS_METADATA_KEY, metaList, constructor);
       }
-      metaList.set(propertyKey, { propertyKey, selector, action, options });
+      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 = [];
           const applyRoot = (t) => {
-            if (!t || !(t instanceof HTMLElement)) return;
-            if (r === "auto") {
-              targetEls.push(t);
-            } else {
-              if (r === "light" || r === "all") targetEls.push(t);
-              if ((r === "shadow" || r === "all") && t.shadowRoot) {
-              }
-            }
+            if (!t || !(t instanceof win.HTMLElement)) return;
+            targetEls.push(t);
           };
           if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
           else if (selector === ":appHost") applyRoot(hostSet.$appHost);
@@ -6658,102 +6858,84 @@ function createClassListDecorator(action) {
           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 if (selector === ":host" || !selector) applyRoot(host2);
           else {
-            if (r === "shadow") {
-              const found = this.shadowRoot?.querySelectorAll(selector);
-              if (found) targetEls.push(...Array.from(found));
-            } else if (r === "light") {
-              const found = this.querySelectorAll(selector);
-              if (found) targetEls.push(...Array.from(found));
-            } else if (r === "all") {
-              const sFound = this.shadowRoot?.querySelectorAll(selector);
-              const lFound = this.querySelectorAll(selector);
-              if (sFound) targetEls.push(...Array.from(sFound));
-              if (lFound) targetEls.push(...Array.from(lFound));
-            } else {
-              const found = (this.shadowRoot || this).querySelectorAll(selector);
+            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);
-function setClassListHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createClassListDecorator("set")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createClassListDecorator("set")(":host", targetOrOptions || {});
+function applyClass(selector, action = "update", options = {}) {
+  return createClassDecorator(action)(selector, options);
 }
-function updateClassListHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createClassListDecorator("update")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createClassListDecorator("update")(":host", targetOrOptions || {});
+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);
 }
-function addClassListHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createClassListDecorator("add")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createClassListDecorator("add")(":host", targetOrOptions || {});
-}
-function removeClassListHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createClassListDecorator("remove")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createClassListDecorator("remove")(":host", targetOrOptions || {});
-}
-function toggleClassListHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createClassListDecorator("toggle")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createClassListDecorator("toggle")(":host", targetOrOptions || {});
-}
-var findAllClassListMetadata = (target) => {
+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));
@@ -6762,8 +6944,8 @@ var findAllClassListMetadata = (target) => {
   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) => {
@@ -6779,18 +6961,14 @@ function createStyleDecorator(action) {
         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 = [];
           const applyRoot = (t) => {
-            if (!t || !(t instanceof HTMLElement)) return;
-            if (r === "auto") {
-              targetEls.push(t);
-            } else {
-              if (r === "light" || r === "all") targetEls.push(t);
-              if ((r === "shadow" || r === "all") && t.shadowRoot) {
-              }
-            }
+            if (!t || !(t instanceof win.HTMLElement)) return;
+            targetEls.push(t);
           };
           if (selector === ":parentHost") applyRoot(hostSet.$parentHost);
           else if (selector === ":appHost") applyRoot(hostSet.$appHost);
@@ -6800,71 +6978,63 @@ function createStyleDecorator(action) {
           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 if (selector === ":host" || !selector) applyRoot(host2);
           else {
-            if (r === "shadow") {
-              const found = this.shadowRoot?.querySelectorAll(selector);
-              if (found) targetEls.push(...Array.from(found));
-            } else if (r === "light") {
-              const found = this.querySelectorAll(selector);
-              if (found) targetEls.push(...Array.from(found));
-            } else if (r === "all") {
-              const sFound = this.shadowRoot?.querySelectorAll(selector);
-              const lFound = this.querySelectorAll(selector);
-              if (sFound) targetEls.push(...Array.from(sFound));
-              if (lFound) targetEls.push(...Array.from(lFound));
-            } else {
-              const found = (this.shadowRoot || this).querySelectorAll(selector);
+            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;
     };
   };
 }
-var setStyle = (selector, options = {}) => createStyleDecorator("set")(selector, options);
-function setStyleHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createStyleDecorator("set")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createStyleDecorator("set")(":host", targetOrOptions || {});
+function applyStyle(selector, action = "update", options = {}) {
+  return createStyleDecorator(action)(selector, options);
 }
+var setStyle = (selector, options = {}) => createStyleDecorator("set")(selector, options);
 var updateStyle = (selector, options = {}) => createStyleDecorator("update")(selector, options);
-function updateStyleHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createStyleDecorator("update")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createStyleDecorator("update")(":host", targetOrOptions || {});
-}
 var removeStyle = (selector, options = {}) => createStyleDecorator("remove")(selector, options);
-function removeStyleHost(targetOrOptions, propertyKey, descriptor) {
-  if (propertyKey !== void 0) {
-    const decorator = createStyleDecorator("remove")(":host", {});
-    return decorator(targetOrOptions, propertyKey, descriptor);
-  }
-  return createStyleDecorator("remove")(":host", targetOrOptions || {});
+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();
   const maps = ReflectUtils.findAllMetadata(STYLE_METADATA_KEY, target);
@@ -6876,8 +7046,123 @@ var findAllStyleMetadata = (target) => {
   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");
@@ -7114,7 +7399,7 @@ var SwcUtils;
 })(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;
@@ -7183,7 +7468,10 @@ var getEmitCustomEventMetadataList = (target) => {
   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);
 }
 
@@ -7275,7 +7563,46 @@ var SituationTypeContainers = class {
     return this.containers.find(predicate);
   }
 };
+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("Inject");
+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) => {
@@ -7293,7 +7620,7 @@ var InjectSituationType = /* @__PURE__ */ ((InjectSituationType2) => {
 })(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);
@@ -7408,7 +7735,6 @@ var setupPrototype = (proto) => {
     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);
@@ -7429,7 +7755,6 @@ var setupPrototype = (proto) => {
   };
   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);
@@ -7469,12 +7794,22 @@ var elementDefine = (name, config = {}) => (constructor) => {
   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);
@@ -7493,7 +7828,6 @@ var elementDefine = (name, config = {}) => (constructor) => {
       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 {
@@ -7633,22 +7967,6 @@ var elementDefine = (name, config = {}) => (constructor) => {
         }
       });
     });
-    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) {
@@ -7726,100 +8044,1680 @@ var elementDefine = (name, config = {}) => (constructor) => {
   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("Sim");
+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("PostConstruct");
+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("After");
 var BeforeMetadataKey = Symbol("Before");
 var AroundMetadataKey = Symbol("Around");
+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("ExceptionHandler");
+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/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) => {
-  RouterAction2.isCanActivate = (obj) => {
-    return typeof obj?.canActivate === "function";
-  };
-  RouterAction2.isOnRouting = (obj) => {
-    return typeof obj?.onRouting === "function";
-  };
-  RouterAction2.isHasActivate = (obj) => {
-    return typeof obj?.hasActivate === "function";
-  };
-})(RouterAction || (RouterAction = {}));
-
-// ../core-web/dist/esm/element/CanvasUtils.js
-var CanvasUtils;
-((CanvasUtils2) => {
-  let Context2D;
-  ((Context2D2) => {
-    Context2D2.resetTransform = (context) => {
-      context.setTransform(1, 0, 0, 1, 0, 0);
-    };
-  })(Context2D = CanvasUtils2.Context2D || (CanvasUtils2.Context2D = {}));
-  CanvasUtils2.fontSize = (ctx, config) => {
-    const { text, maxWidth, maxHeight, fontOption } = config;
-    if (!text || maxWidth <= 0 || maxHeight <= 0) {
-      return 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];
     }
-    const lines = text.split("\n").filter((line) => line.trim().length > 0);
-    if (lines.length === 0) {
-      return 0;
+  }
+  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;
+      }
     }
-    const lineHeightMultiplier = 1.2;
-    const maxFontSizeByHeight = Math.floor(maxHeight / (lines.length * lineHeightMultiplier));
-    if (maxFontSizeByHeight <= 0) {
-      return 0;
+    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;
     }
-    let minSizeForWidth = 1;
-    let maxSizeForWidth = maxFontSizeByHeight;
-    let bestSizeForWidth = 0;
-    const maxIterations = 100;
-    let iteration = 0;
-    while (minSizeForWidth <= maxSizeForWidth && iteration < maxIterations) {
-      const midSize = Math.floor((minSizeForWidth + maxSizeForWidth) / 2);
-      if (midSize === 0) break;
-      ctx.font = `${fontOption?.fontWeight || "normal"} ${midSize}px ${fontOption?.fontFamily || "sans-serif"}`;
-      const maxLineWidth = Math.max(...lines.map((line) => ctx.measureText(line).width));
-      if (maxLineWidth <= maxWidth) {
-        bestSizeForWidth = midSize;
-        minSizeForWidth = midSize + 1;
-      } else {
-        maxSizeForWidth = midSize - 1;
+    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);
       }
-      iteration++;
     }
-    return Math.min(bestSizeForWidth, maxFontSizeByHeight);
-  };
-  CanvasUtils2.textMetrics = (context, text) => {
-    return context.measureText(text);
-  };
-})(CanvasUtils || (CanvasUtils = {}));
-
-// ../core-web/dist/esm/element/ElementUtils.js
-var ElementUtils;
-((ElementUtils2) => {
-  function removeAllChildren(el, els) {
-    if (!els) {
-      el.replaceChildren();
-    } else if (Array.isArray(els)) {
-      el.replaceChildren(...els);
-    } else {
-      el.replaceChildren(els);
+  }
+  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("Sim:NoProxy");
+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())) {
+      if (typeof k === "symbol") {
+        simProcess({ symbol: k }, v);
+      } else if (typeof k === "object") {
+        simProcess(k, v);
+      } else {
+        simProcess({ type: k }, v);
+      }
+    }
+    const myContainers = ConvertUtils.flatArray(this.option.container).filter(ValidUtils.isDefined);
+    Array.from(sims.entries()).forEach(([type, value]) => {
+      const targetContainers = ConvertUtils.flatArray(getSim(type)?.container).filter(ValidUtils.isDefined);
+      let isInclude = false;
+      if (myContainers.length <= 0 && targetContainers.length <= 0) {
+        isInclude = true;
+      } else if (targetContainers.length <= 0) {
+        isInclude = true;
+      } else {
+        isInclude = myContainers.some((it) => targetContainers.includes(it));
+      }
+      this.registerStore(type, value);
+    });
+    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("Router");
+var getRouter = (target) => {
+  if (target != null && typeof target === "object") {
+    target = target.constructor;
+  }
+  try {
+    return ReflectUtils.getMetadata(RouterMetadataKey, target);
+  } catch (e) {
+  }
+};
+var RouteMetadataKey = Symbol("RouteMetadataKey");
+
+// ../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);
+    }
+  }
+  getQueryParamFirst(key) {
+    if (this.intent) {
+      return this.intent.getQueryParamFirst(key);
+    }
+  }
+  get queryParams() {
+    if (this.intent) {
+      return this.intent.queryParams;
+    }
+  }
+  get queryParamsAfterDecodeURI() {
+    if (this.intent) {
+      return this.intent.queryParamsDecodeURI;
+    }
+  }
+};
+
+// ../simple-boot/dist/esm/route/RouterAction.js
+var RouterAction;
+((RouterAction2) => {
+  RouterAction2.isCanActivate = (obj) => {
+    return typeof obj?.canActivate === "function";
+  };
+  RouterAction2.isOnRouting = (obj) => {
+    return typeof obj?.onRouting === "function";
+  };
+  RouterAction2.isHasActivate = (obj) => {
+    return typeof obj?.hasActivate === "function";
+  };
+})(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) => {
+  let Context2D;
+  ((Context2D2) => {
+    Context2D2.resetTransform = (context) => {
+      context.setTransform(1, 0, 0, 1, 0, 0);
+    };
+  })(Context2D = CanvasUtils2.Context2D || (CanvasUtils2.Context2D = {}));
+  CanvasUtils2.fontSize = (ctx, config) => {
+    const { text, maxWidth, maxHeight, fontOption } = config;
+    if (!text || maxWidth <= 0 || maxHeight <= 0) {
+      return 0;
+    }
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+      return 0;
+    }
+    const lineHeightMultiplier = 1.2;
+    const maxFontSizeByHeight = Math.floor(maxHeight / (lines.length * lineHeightMultiplier));
+    if (maxFontSizeByHeight <= 0) {
+      return 0;
+    }
+    let minSizeForWidth = 1;
+    let maxSizeForWidth = maxFontSizeByHeight;
+    let bestSizeForWidth = 0;
+    const maxIterations = 100;
+    let iteration = 0;
+    while (minSizeForWidth <= maxSizeForWidth && iteration < maxIterations) {
+      const midSize = Math.floor((minSizeForWidth + maxSizeForWidth) / 2);
+      if (midSize === 0) break;
+      ctx.font = `${fontOption?.fontWeight || "normal"} ${midSize}px ${fontOption?.fontFamily || "sans-serif"}`;
+      const maxLineWidth = Math.max(...lines.map((line) => ctx.measureText(line).width));
+      if (maxLineWidth <= maxWidth) {
+        bestSizeForWidth = midSize;
+        minSizeForWidth = midSize + 1;
+      } else {
+        maxSizeForWidth = midSize - 1;
+      }
+      iteration++;
+    }
+    return Math.min(bestSizeForWidth, maxFontSizeByHeight);
+  };
+  CanvasUtils2.textMetrics = (context, text) => {
+    return context.measureText(text);
+  };
+})(CanvasUtils || (CanvasUtils = {}));
+
+// ../core-web/dist/esm/element/ElementUtils.js
+var ElementUtils;
+((ElementUtils2) => {
+  function removeAllChildren(el, els) {
+    if (!els) {
+      el.replaceChildren();
+    } else if (Array.isArray(els)) {
+      el.replaceChildren(...els);
+    } else {
+      el.replaceChildren(els);
     }
   }
   ElementUtils2.removeAllChildren = removeAllChildren;
@@ -8522,13 +10420,400 @@ var ValidUtils2;
     return /Mobi/i.test(targetWindow.navigator.userAgent);
   };
 })(ValidUtils2 || (ValidUtils2 = {}));
+
+// ../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("AlertFactory");
+})(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("Cache");
+
+// ../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("EventListener");
+
+// ../simple-boot/dist/esm/decorators/validate/Validation.js
+var ValidMetadataKey = Symbol("ValidMetadataKey");
+var ValidationMetadataKey = Symbol("ValidationMetadataKey");
+
+// ../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("ApiServiceInterceptor");
+  ApiServiceInterceptor2.resolveAll = (simstanceManager) => {
+    try {
+      return (simstanceManager.findSims(ApiServiceInterceptor2.TOKEN) ?? []).map((it) => it.getValue()).filter(ValidUtils.isDefined);
+    } catch (e) {
+      return [];
+    }
+  };
+})(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);
 export {
   ADD_EVENT_LISTENER_METADATA_KEY,
   APPLY_NODE_METADATA_KEY,
+  ATTRIBUTE_APPLY_METADATA_KEY,
   ATTRIBUTE_CHANGED_WILDCARD,
-  ATTRIBUTE_METADATA_KEY,
+  ATTRIBUTE_FIELD_METADATA_KEY,
   BROWSER_GLOBALS,
-  CLASS_LIST_METADATA_KEY,
+  CLASS_METADATA_KEY,
   DOM_EVENT_NAMES,
   ELEMENT_CONFIG_KEY,
   EMIT_CUSTOM_EVENT_METADATA_KEY,
@@ -8546,12 +10831,11 @@ export {
   ON_CONSTRUCTOR_METADATA_KEY,
   QUERY_ALL_METADATA_KEY,
   QUERY_METADATA_KEY,
-  SET_ATTRIBUTE_METADATA_KEY,
   STYLE_METADATA_KEY,
   SWC_NOT_FOUND,
   SwcUtils,
-  addClassList,
-  addClassListHost,
+  addClass,
+  addClassHost,
   addEventListener,
   addEventListenerHost,
   allAppHost,
@@ -8562,26 +10846,18 @@ export {
   allLastHost,
   allParentHost,
   appHost,
-  applyAfterBeginNode,
-  applyAfterBeginNodeHost,
-  applyAfterEndNode,
-  applyAfterEndNodeHost,
-  applyBeforeBeginNode,
-  applyBeforeBeginNodeHost,
-  applyBeforeEndNode,
-  applyBeforeEndNodeHost,
+  applyAttribute,
+  applyAttributeHost,
+  applyClass,
+  applyClassHost,
   applyInnerHtmlNode,
   applyInnerHtmlNodeHost,
-  applyInnerTextNode,
-  applyInnerTextNodeHost,
   applyNode,
   applyNodeHost,
-  applyRemoveNode,
-  applyRemoveNodeHost,
   applyReplaceChildrenNode,
   applyReplaceChildrenNodeHost,
-  applyReplaceNode,
-  applyReplaceNodeHost,
+  applyStyle,
+  applyStyleHost,
   attribute,
   attributeHost,
   changedAttributeHost,
@@ -8592,11 +10868,11 @@ export {
   emitCustomEventHost,
   ensureInit2 as ensureInit,
   findAllApplyNodeMetadata,
+  findAllAttributeApplyMetadata,
   findAllAttributeChangedMetadata,
   findAllAttributeMetadata,
-  findAllClassListMetadata,
+  findAllClassMetadata,
   findAllLifecycleMetadata,
-  findAllSetAttributeMetadata,
   findAllStyleMetadata,
   firstAppHost,
   firstHost,
@@ -8607,7 +10883,6 @@ export {
   getOnConnectedInnerHtmlMetadata,
   getQueryAllMetadata,
   getQueryMetadata,
-  getSetAttributeMetadata,
   host,
   htmlAElement,
   htmlArticleElement,
@@ -8639,22 +10914,26 @@ export {
   queryAll,
   queryAllHost,
   queryHost,
-  removeClassList,
-  removeClassListHost,
+  removeAttribute,
+  removeAttributeHost,
+  removeClass,
+  removeClassHost,
   removeStyle,
   removeStyleHost,
   resolveTargetEls,
   setAttribute,
   setAttributeHost,
-  setClassList,
-  setClassListHost,
+  setClass,
+  setClassHost,
   setStyle,
   setStyleHost,
   textNode,
-  toggleClassList,
-  toggleClassListHost,
-  updateClassList,
-  updateClassListHost,
+  toggleClass,
+  toggleClassHost,
+  updateAttribute,
+  updateAttributeHost,
+  updateClass,
+  updateClassHost,
   updateStyle,
   updateStyleHost
 };