@dooboostore/simple-web-component 1.0.26 → 1.0.28

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

@@ -297,8 +297,8 @@ var require_Reflect = __commonJS({
               keys.push(key);
             }
           }
-          for (var _a4 = 0, parentKeys_1 = parentKeys; _a4 < parentKeys_1.length; _a4++) {
-            var key = parentKeys_1[_a4];
+          for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+            var key = parentKeys_1[_a];
             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_metadata3 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
 // src/index.ts
-var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata = __toESM(require_Reflect(), 1);
 
 // ../core/dist/esm/valid/ValidUtils.js
 var ValidUtils;
@@ -4789,107 +4789,6 @@ 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) {
@@ -5224,284 +5123,6 @@ 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) {
@@ -5778,7 +5399,7 @@ _RenderTransactionDrawObj.DEFAULT_BEZIER = { p1x: 0.61, p1y: 1, p2x: 0.88, p2y:
 // ../core/dist/esm/schedule/Schedule.js
 var Schedule;
 ((Schedule2) => {
-  Schedule2.SYMBOL = Symbol("Schedule");
+  Schedule2.SYMBOL = Symbol.for("core:schedule-token");
 })(Schedule || (Schedule = {}));
 
 // ../core/dist/esm/url/UrlUtils.js
@@ -5932,6 +5553,17 @@ var ReflectUtils;
       Reflect.defineMetadata(metadataKey, value, target);
     }
   };
+  ReflectUtils2.copyMetadata = (from, to, propertyKey) => {
+    const keys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);
+    for (const key of keys) {
+      const data = propertyKey ? Reflect.getOwnMetadata(key, from, propertyKey) : Reflect.getOwnMetadata(key, from);
+      if (propertyKey) {
+        Reflect.defineMetadata(key, data, to, propertyKey);
+      } else {
+        Reflect.defineMetadata(key, data, to);
+      }
+    }
+  };
 })(ReflectUtils || (ReflectUtils = {}));
 
 // ../core/dist/esm/function/FunctionUtils.js
@@ -6114,9 +5746,12 @@ var getAddEventListenerMetadata = (target) => {
 function addEventListenerHost(type, options) {
   return addEventListener(":host", type, options);
 }
+function addEventListenerAppHost(type, options) {
+  return addEventListener(":appHost", type, options);
+}
 
 // src/decorators/lifecycles.ts
-var ON_CONSTRUCTOR_METADATA_KEY = Symbol.for("simple-web-component:on-constructor");
+var ON_INITIALIZE_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");
@@ -6137,7 +5772,7 @@ function createLifecycleDecorator(metadataKey) {
     list.push(propertyKey);
   };
 }
-var onConstructor = createLifecycleDecorator(ON_CONSTRUCTOR_METADATA_KEY);
+var onInitialize = createLifecycleDecorator(ON_INITIALIZE_METADATA_KEY);
 var onBeforeConnected = createLifecycleDecorator(ON_BEFORE_CONNECTED_METADATA_KEY);
 var onAfterConnected = createLifecycleDecorator(ON_AFTER_CONNECTED_METADATA_KEY);
 var onConnected = onAfterConnected;
@@ -6252,49 +5887,37 @@ function attribute(selector, options = {}) {
         }
       });
     };
-    Object.defineProperty(target, propertyKey, {
-      get() {
-        const attrName = options.name || String(propertyKey);
-        const conf = getElementConfig(this);
-        const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
-        const targetType = options.type || designType;
-        if (this.__swc_syncing_init || options.connectedInitialize && !this.__swc_connected) {
-          return convertValue(this[privateKey], targetType);
-        }
-        const targets = resolveTargetEls(this, selector, options, currentWin);
-        const primaryTarget = targets[0];
-        if (primaryTarget && typeof primaryTarget.hasAttribute === "function") {
-          if (primaryTarget.hasAttribute(attrName)) {
-            const domVal = primaryTarget.getAttribute(attrName);
-            return convertValue(domVal, targetType);
-          }
-          return null;
-        }
-        return convertValue(this[privateKey], targetType);
-      },
-      set(nv) {
-        const attrName = options.name || String(propertyKey);
-        const conf = getElementConfig(this);
-        const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
-        if (this.__swc_syncing_init) {
-          if (options.connectedInitialize === true) {
-            const targets2 = resolveTargetEls(this, selector, options, currentWin);
-            applySetAttribute(this, targets2, attrName, nv);
-          } else {
-            this[privateKey] = nv;
+    try {
+      Object.defineProperty(target, propertyKey, {
+        get() {
+          const attrName = options.name || String(propertyKey);
+          const conf = getElementConfig(this);
+          const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+          const targetType = options.type || designType;
+          const targets = resolveTargetEls(this, selector, options, currentWin);
+          const primaryTarget = targets[0];
+          if (primaryTarget && typeof primaryTarget.hasAttribute === "function") {
+            if (primaryTarget.hasAttribute(attrName)) {
+              const domVal = primaryTarget.getAttribute(attrName);
+              return convertValue(domVal, targetType);
+            }
+            return null;
           }
-          return;
-        }
-        if (!this.__swc_connected) {
-          this[privateKey] = nv;
-          return;
-        }
-        const targets = resolveTargetEls(this, selector, options, currentWin);
-        applySetAttribute(this, targets, attrName, nv);
-      },
-      enumerable: true,
-      configurable: true
-    });
+          return convertValue(this[privateKey], targetType);
+        },
+        set(nv) {
+          const attrName = options.name || String(propertyKey);
+          const conf = getElementConfig(this);
+          const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+          const targets = resolveTargetEls(this, selector, options, currentWin);
+          applySetAttribute(this, targets, attrName, nv);
+        },
+        enumerable: true,
+        configurable: true
+      });
+    } catch (err) {
+      console.error("[SWC] defineProperty error:", err);
+    }
   };
 }
 function attributeHost(targetOrAttrOrOptions, propertyKeyOrOptions) {
@@ -6317,7 +5940,8 @@ function attributeHost(targetOrAttrOrOptions, propertyKeyOrOptions) {
   }
 }
 var findAllAttributeMetadata = (target) => {
-  return ReflectUtils.findAllMetadata(ATTRIBUTE_FIELD_METADATA_KEY, target).flat();
+  const actualTarget = target instanceof Function ? target : target.constructor;
+  return ReflectUtils.findAllMetadata(ATTRIBUTE_FIELD_METADATA_KEY, actualTarget).flat();
 };
 
 // src/decorators/changedAttributeHost.ts
@@ -6573,10 +6197,6 @@ function query(selectorOrTarget, options = {}) {
     });
   };
 }
-var getQueryMetadata = (target) => {
-  const constructor = target instanceof Function ? target : target.constructor;
-  return ReflectUtils.getMetadata(QUERY_METADATA_KEY, constructor);
-};
 function queryHost(targetOrOptions, propertyKey) {
   if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
     return query(":host", {})(targetOrOptions, propertyKey);
@@ -6648,6 +6268,10 @@ function lastAppHost(targetOrOptions, propertyKey) {
     return query(":lastAppHost", {});
   }
 }
+var getQueryMetadata = (target) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return ReflectUtils.getMetadata(QUERY_METADATA_KEY, constructor);
+};
 
 // src/decorators/queryAll.ts
 var QUERY_ALL_METADATA_KEY = Symbol.for("simple-web-component:query-all");
@@ -6741,10 +6365,6 @@ function queryAll(selectorOrTarget, options = {}) {
     });
   };
 }
-var getQueryAllMetadata = (target) => {
-  const constructor = target instanceof Function ? target : target.constructor;
-  return ReflectUtils.getMetadata(QUERY_ALL_METADATA_KEY, constructor);
-};
 function queryAllHost(targetOrOptions, propertyKey) {
   if (propertyKey !== void 0 && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
     return queryAll(":host", {})(targetOrOptions, propertyKey);
@@ -6816,6 +6436,10 @@ function allLastAppHost(targetOrOptions, propertyKey) {
     return queryAll(":lastAppHost", {});
   }
 }
+var getQueryAllMetadata = (target) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return ReflectUtils.getMetadata(QUERY_ALL_METADATA_KEY, constructor);
+};
 
 // src/decorators/applyClass.ts
 var CLASS_METADATA_KEY = Symbol.for("simple-web-component:class");
@@ -7161,6 +6785,41 @@ var findAllAttributeApplyMetadata = (target) => {
   return result;
 };
 
+// src/decorators/subscribeSwcAppRouteChange.ts
+var SUBSCRIBE_SWC_APP_ROUTE_CHANGE_METADATA_KEY = Symbol.for("simple-web-component:subscribe-swc-app-route-change");
+function createSwcAppRouteChangeSubscriber(options) {
+  return (target, propertyKey, descriptor) => {
+    const pathPattern = options?.path;
+    const filter = options?.filter;
+    const constructor = target.constructor;
+    let list = ReflectUtils.getOwnMetadata(SUBSCRIBE_SWC_APP_ROUTE_CHANGE_METADATA_KEY, constructor);
+    if (!list) {
+      list = [];
+      ReflectUtils.defineMetadata(SUBSCRIBE_SWC_APP_ROUTE_CHANGE_METADATA_KEY, list, constructor);
+    }
+    list.push({ propertyKey, pathPattern, filter });
+    return descriptor;
+  };
+}
+function subscribeSwcAppRouteChange(targetOrOptions, propertyKey, descriptor) {
+  if (propertyKey && (typeof propertyKey === "string" || typeof propertyKey === "symbol")) {
+    return createSwcAppRouteChangeSubscriber({})(targetOrOptions, propertyKey, descriptor);
+  }
+  let options = {};
+  if (Array.isArray(targetOrOptions)) {
+    options.path = targetOrOptions;
+  } else if (typeof targetOrOptions === "string") {
+    options.path = targetOrOptions;
+  } else if (targetOrOptions && typeof targetOrOptions === "object") {
+    options = targetOrOptions;
+  }
+  return createSwcAppRouteChangeSubscriber(options);
+}
+var getSubscribeSwcAppRouteChangeMetadata = (target) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return ReflectUtils.getOwnMetadata(SUBSCRIBE_SWC_APP_ROUTE_CHANGE_METADATA_KEY, constructor);
+};
+
 // src/utils/Utils.ts
 var SWC_NOT_FOUND = Symbol.for("simple-web-component:not-found");
 var htmlFragment = (html, doc) => {
@@ -7396,6 +7055,24 @@ var SwcUtils;
       ...loopContext
     };
   };
+  SwcUtils2.parsePathPattern = (pattern, currentPath) => {
+    if (pattern === null || pattern === void 0) return {};
+    const trimmedPattern = pattern.trim();
+    if (trimmedPattern === "" && pattern !== "") return {};
+    const paramNames = [];
+    const regexPattern = trimmedPattern.replace(/{(\w+)(?::(.+?))?}/g, (match2, paramName, customRegex) => {
+      paramNames.push(paramName);
+      return `(${customRegex || "[^/]+"})`;
+    });
+    const regex = new RegExp(`^${regexPattern}$`);
+    const match = currentPath.match(regex);
+    if (!match) return null;
+    const result = {};
+    paramNames.forEach((name, index) => {
+      result[name] = match[index + 1];
+    });
+    return result;
+  };
 })(SwcUtils || (SwcUtils = {}));
 
 // src/decorators/emitCustomEvent.ts
@@ -7563,46 +7240,7 @@ 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) ?? [];
-};
+var InjectMetadataKey = Symbol.for("simple-boot:inject-metadata");
 
 // src/types.ts
 var InjectSituationType = /* @__PURE__ */ ((InjectSituationType2) => {
@@ -7631,9 +7269,26 @@ var ensureInit2 = (inst) => {
     inst._emitHandlers = /* @__PURE__ */ new Map();
     inst._boundListeners = [];
     inst.__swc_initialized = true;
+    const target = inst instanceof Function ? inst : inst.constructor;
+    const attributeList = findAllAttributeMetadata(target);
+    attributeList.forEach((meta) => {
+      delete inst[meta.propertyKey];
+    });
+    const queryList = getQueryMetadata(target);
+    if (queryList) {
+      queryList.forEach((meta) => {
+        delete inst[meta.propertyKey];
+      });
+    }
+    const queryAllList = getQueryAllMetadata(target);
+    if (queryAllList) {
+      queryAllList.forEach((meta) => {
+        delete inst[meta.propertyKey];
+      });
+    }
     const hostSet = SwcUtils.getHostSet(inst);
     inst._executeSwcScript?.("swc-on-constructor", hostSet);
-    const cMethods = findAllLifecycleMetadata(inst, ON_CONSTRUCTOR_METADATA_KEY);
+    const cMethods = findAllLifecycleMetadata(inst, ON_INITIALIZE_METADATA_KEY);
     if (cMethods) {
       for (const m of cMethods) inst._invokeLifecycleMethod(m, hostSet);
     }
@@ -7800,12 +7455,12 @@ var elementDefine = (name, config = {}) => (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 attributeApplyNames = Array.from(applyAttributeMap.values()).map((it) => it.options.name).filter(Boolean);
-  const attributeListNames = attributeList.map((it) => it.options.name || String(it.propertyKey));
+  const hostAttributes = attributeList.filter((it) => it.selector === ":host").map((it) => it.options.name || String(it.propertyKey));
   const mergedObservedAttributes = [.../* @__PURE__ */ new Set([
     ...metadata.observedAttributes ?? [],
     ...attrChangeMap.keys(),
     ...attributeApplyNames,
-    ...attributeListNames,
+    ...hostAttributes,
     ...emitHostCustomEventList.map((it) => it.options.attributeName).filter(Boolean),
     ...swcLifecycleAttributes,
     ...swcOnEvents
@@ -7816,30 +7471,18 @@ var elementDefine = (name, config = {}) => (constructor) => {
   const originalConnected = proto.connectedCallback;
   proto.connectedCallback = function() {
     ensureInit2(this);
+    const hostSet = SwcUtils.getHostSet(this);
+    const appHost2 = hostSet.$appHost;
+    const conf = getElementConfig(this);
+    const currentWin = this._resolveWindow(conf);
     if (connectedInnerHtmlList.some((it) => it.options.useShadow === true) && !this.shadowRoot) {
       this.attachShadow({ mode: "open" });
     }
-    const conf = getElementConfig(this);
-    const currentWin = this._resolveWindow(conf);
-    const hostSet = SwcUtils.getHostSet(this);
     this._executeSwcScript("swc-on-before-connected", hostSet);
     const bMethods = findAllLifecycleMetadata(this, ON_BEFORE_CONNECTED_METADATA_KEY);
     if (bMethods) {
       for (const m of bMethods) this._invokeLifecycleMethod(m, hostSet);
     }
-    attributeList.forEach((meta) => {
-      if (meta.options.connectedInitialize === true) {
-        this.__swc_syncing_init = true;
-        try {
-          const memoryVal = this[meta.privateKey];
-          if (memoryVal !== void 0) {
-            this[meta.propertyKey] = memoryVal;
-          }
-        } finally {
-          this.__swc_syncing_init = false;
-        }
-      }
-    });
     if (connectedInnerHtmlList.length > 0) {
       let sContent = "", lContent = "";
       for (const meta of connectedInnerHtmlList) {
@@ -7900,6 +7543,12 @@ var elementDefine = (name, config = {}) => (constructor) => {
             const { selector, options } = meta;
             const matchedEl = event.target.closest(selector);
             if (matchedEl && br.contains(matchedEl)) {
+              if (options.filter) {
+                const helper = SwcUtils.getHelperAndHostSet(currentWin, matchedEl);
+                if (!options.filter(event, helper)) {
+                  continue;
+                }
+              }
               if (options.stopPropagation) event.stopPropagation();
               if (options.stopImmediatePropagation) event.stopImmediatePropagation();
               if (options.preventDefault) event.preventDefault();
@@ -7954,6 +7603,12 @@ var elementDefine = (name, config = {}) => (constructor) => {
       }
       bindTargets.forEach((t) => {
         const handler = async (event) => {
+          if (options.filter) {
+            const helper = SwcUtils.getHelperAndHostSet(currentWin, t);
+            if (!options.filter(event, helper)) {
+              return;
+            }
+          }
           if (options.stopPropagation) event.stopPropagation();
           if (options.stopImmediatePropagation) event.stopImmediatePropagation();
           if (options.preventDefault) event.preventDefault();
@@ -7975,6 +7630,9 @@ var elementDefine = (name, config = {}) => (constructor) => {
     this._executeSwcScript("swc-on-connected", hostSet);
     this._executeSwcScript("swc-on-after-connected", hostSet);
     this.__swc_connected = true;
+    if (appHost2 && typeof appHost2._connected === "function") {
+      appHost2._connected(this);
+    }
   };
   const originalDisconnected = proto.disconnectedCallback;
   proto.disconnectedCallback = function() {
@@ -7996,6 +7654,10 @@ var elementDefine = (name, config = {}) => (constructor) => {
     this._executeSwcScript("swc-on-disconnected", hostSet);
     this._executeSwcScript("swc-on-after-disconnected", hostSet);
     this.__swc_connected = false;
+    const appHost2 = hostSet.$appHost;
+    if (appHost2 && typeof appHost2._disconnected === "function") {
+      appHost2._disconnected(this);
+    }
   };
   const originalAdopted = proto.adoptedCallback;
   proto.adoptedCallback = function() {
@@ -8044,1178 +7706,27 @@ 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) ?? [];
-};
+var SimMetadataKey = Symbol.for("simple-boot:sim-metadata");
+var PostConstructMetadataKey = Symbol.for("simple-boot:post-construct-metadata");
 
-// ../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/decorators/aop/AOPDecorator.js
+var AfterMetadataKey = Symbol.for("simple-boot:after-metadata");
+var BeforeMetadataKey = Symbol.for("simple-boot:before-metadata");
+var AroundMetadataKey = Symbol.for("simple-boot:around-metadata");
 
-// ../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/exception/ExceptionDecorator.js
+var ExceptionHandlerMetadataKey = Symbol.for("simple-boot:exception-handler-metadata");
 
-// ../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/proxy/SimProxyHandler.js
-var SimProxyHandler = class {
-  constructor(simpleApplication, simstanceManager, simOption) {
-    this.simpleApplication = simpleApplication;
-    this.simstanceManager = simstanceManager;
-    this.simOption = simOption;
-  }
-  // 잘받게 해놨네 ㅋㅋ  simstanceManager
-  get(target, name) {
-    if (name === "_SimpleBoot_application") {
-      return this.simpleApplication;
-    } else if (name === "_SimpleBoot_simstanceManager") {
-      return this.simstanceManager;
-    } else if (name === "_SimpleBoot_simOption") {
-      return this.simOption;
-    } else if (name === "_SimpleBoot_origin") {
-      return target;
-    } else {
-      return target[name];
-    }
-  }
-  set(obj, prop, value, receiver) {
-    value = this.simstanceManager?.proxy(value);
-    obj[prop] = value;
-    return true;
-  }
-  apply(target, thisArg, argumentsList) {
-    let r;
-    try {
-      this.aopBefore(thisArg, target);
-      try {
-        r = Reflect.apply(target, thisArg, argumentsList);
-      } catch (e) {
-        throw e;
-      } finally {
-        this.aopAfter(thisArg, target);
-      }
-    } catch (e) {
-      console.error(e);
-      const inHandlers = this.getExceptionHandler(e, thisArg, target);
-      if (inHandlers.length > 0 && inHandlers[0]) {
-        const inHandler = inHandlers[0];
-        this.executeExceptionHandler(e, inHandler, argumentsList);
-      } else {
-        throw e;
-      }
-    }
-    return r;
-  }
-  executeExceptionHandler(e, inHandler, argumentsList) {
-    const otherStorage = /* @__PURE__ */ new Map();
-    otherStorage.set(e.constructor, e);
-    const situationErrorTypeContainer = new SituationTypeContainer({
-      situationType: ExceptionHandlerSituationType.ERROR_OBJECT,
-      data: e
-    });
-    const situationParameterTypeContainer = new SituationTypeContainer({
-      situationType: ExceptionHandlerSituationType.PARAMETER,
-      data: argumentsList
-    });
-    otherStorage.set(SituationTypeContainers, new SituationTypeContainers([situationErrorTypeContainer, situationParameterTypeContainer]));
-    argumentsList?.forEach((it) => {
-      otherStorage.set(it.constructor, it);
-    });
-    try {
-      this.simstanceManager.executeBindParameterSim(
-        {
-          target: inHandler.thisArg,
-          targetKey: inHandler.config.propertyKey
-        },
-        otherStorage
-      );
-    } catch (es) {
-      e = es;
-    }
-    if (inHandler.config.config.throw) {
-      const exceptionHandler = this.getExceptionHandler(e, inHandler.thisArg, inHandler.config.method);
-      if ((exceptionHandler?.length ?? 0) > 0) {
-        this.executeExceptionHandler(e, exceptionHandler[0], argumentsList);
-      }
-    }
-  }
-  getExceptionHandler(e, thisArg, target) {
-    const globalConfigSets = this.simOption.advice.map((it) => this.simstanceManager?.getOrNewSim({ target: it })).filter((it) => it).map((it) => {
-      return { thisArg: it, config: targetExceptionHandler(it, e, [target]) };
-    }) ?? [];
-    const thisConfigSet = { thisArg, config: targetExceptionHandler(thisArg, e, [target]) };
-    const inHandlers = [thisConfigSet, ...globalConfigSets].filter((it) => it && it.config);
-    return inHandlers;
-  }
-  aopBefore(obj, protoType) {
-    const propertyName = ObjectUtils.prototypeName(obj, protoType);
-    if (propertyName && obj) {
-      getProtoBefores(obj, propertyName).forEach((it) => {
-        it.call(obj, protoType, propertyName);
-      });
-      for (let i = 0; i < this.simOption.advice.length; i++) {
-        const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
-        const protoBefores = getProtoBefores(sim, propertyName, Object.getPrototypeOf(obj));
-        protoBefores.forEach((it) => {
-          it.call(obj, protoType, propertyName);
-        });
-      }
-    }
-  }
-  aopAfter(obj, protoType) {
-    const propertyName = ObjectUtils.prototypeName(obj, protoType);
-    if (propertyName) {
-      getProtoAfters(obj, propertyName).forEach((it) => {
-        it.call(obj, protoType, propertyName);
-      });
-      for (let i = 0; i < this.simOption.advice.length; i++) {
-        const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
-        const protoBefores = getProtoAfters(sim, propertyName, Object.getPrototypeOf(obj));
-        protoBefores.forEach((it) => {
-          it.call(obj, protoType, propertyName);
-        });
-      }
-    }
-  }
-  has(target, key) {
-    if (key === "_SimpleBoot_isProxy") {
-      return true;
-    }
-    return key in target;
-  }
-};
-
-// ../simple-boot/dist/esm/lifecycle/OnSimCreate.js
-var isOnSimCreate = (obj) => {
-  return typeof obj?.onSimCreate === "function";
-};
-
-// ../simple-boot/dist/esm/lifecycle/OnSimCreateCompleted.js
-var isOnSimCreateProxyCompleted = (obj) => {
-  return typeof obj?.onSimCreateProxyCompleted === "function";
-};
-
-// ../simple-boot/dist/esm/decorators/SimNoProxy.js
-var SimNoProxyKey = Symbol("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/SimNoProxy.js
+var SimNoProxyKey = Symbol.for("simple-boot:sim-no-proxy-metadata");
 
 // ../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;
-  }
-};
+var InjectionMetadataKey = Symbol("Injection");
 
 // ../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;
-    }
-  }
-};
+var RouterMetadataKey = Symbol.for("simple-boot:router-metadata");
+var RouteMetadataKey = Symbol.for("simple-boot:route-metadata");
 
 // ../simple-boot/dist/esm/route/RouterAction.js
 var RouterAction;
@@ -9231,435 +7742,6 @@ var RouterAction;
   };
 })(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) => {
@@ -10420,392 +8502,6 @@ 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,
@@ -10828,15 +8524,17 @@ export {
   ON_BEFORE_ADOPTED_METADATA_KEY,
   ON_BEFORE_CONNECTED_METADATA_KEY,
   ON_BEFORE_DISCONNECTED_METADATA_KEY,
-  ON_CONSTRUCTOR_METADATA_KEY,
+  ON_INITIALIZE_METADATA_KEY,
   QUERY_ALL_METADATA_KEY,
   QUERY_METADATA_KEY,
   STYLE_METADATA_KEY,
+  SUBSCRIBE_SWC_APP_ROUTE_CHANGE_METADATA_KEY,
   SWC_NOT_FOUND,
   SwcUtils,
   addClass,
   addClassHost,
   addEventListener,
+  addEventListenerAppHost,
   addEventListenerHost,
   allAppHost,
   allFirstAppHost,
@@ -10883,6 +8581,7 @@ export {
   getOnConnectedInnerHtmlMetadata,
   getQueryAllMetadata,
   getQueryMetadata,
+  getSubscribeSwcAppRouteChangeMetadata,
   host,
   htmlAElement,
   htmlArticleElement,
@@ -10907,8 +8606,8 @@ export {
   onBeforeDisconnected,
   onConnected,
   onConnectedInnerHtml,
-  onConstructor,
   onDisconnected,
+  onInitialize,
   parentHost,
   query,
   queryAll,
@@ -10927,6 +8626,7 @@ export {
   setClassHost,
   setStyle,
   setStyleHost,
+  subscribeSwcAppRouteChange,
   textNode,
   toggleClass,
   toggleClassHost,