@dooboostore/simple-web-component 1.0.36 → 1.0.37

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

@@ -5,6 +5,7 @@ var dooboostoreSimpleWebComponent = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -29,6 +30,7 @@ var dooboostoreSimpleWebComponent = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // ../../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
   var require_Reflect = __commonJS({
@@ -1120,6 +1122,7 @@ var dooboostoreSimpleWebComponent = (() => {
   __export(bundle_entry_exports, {
     ADD_EVENT_LISTENER_METADATA_KEY: () => ADD_EVENT_LISTENER_METADATA_KEY,
     APPLY_NODE_METADATA_KEY: () => APPLY_NODE_METADATA_KEY,
+    APPLY_SLOT_METADATA_KEY: () => APPLY_SLOT_METADATA_KEY,
     ATTRIBUTE_APPLY_METADATA_KEY: () => ATTRIBUTE_APPLY_METADATA_KEY,
     ATTRIBUTE_CHANGED_WILDCARD: () => ATTRIBUTE_CHANGED_WILDCARD,
     ATTRIBUTE_FIELD_METADATA_KEY: () => ATTRIBUTE_FIELD_METADATA_KEY,
@@ -1129,7 +1132,6 @@ var dooboostoreSimpleWebComponent = (() => {
     ELEMENT_CONFIG_KEY: () => ELEMENT_CONFIG_KEY,
     EMIT_CUSTOM_EVENT_METADATA_KEY: () => EMIT_CUSTOM_EVENT_METADATA_KEY,
     HTML_TAG_ENTRIES: () => HTML_TAG_ENTRIES,
-    INNER_HTML_METADATA_KEY: () => INNER_HTML_METADATA_KEY,
     InjectSituationType: () => InjectSituationType,
     ON_ADD_EVENT_LISTENER_METADATA_KEY: () => ON_ADD_EVENT_LISTENER_METADATA_KEY,
     ON_AFTER_ADOPTED_METADATA_KEY: () => ON_AFTER_ADOPTED_METADATA_KEY,
@@ -1139,6 +1141,8 @@ var dooboostoreSimpleWebComponent = (() => {
     ON_BEFORE_ADOPTED_METADATA_KEY: () => ON_BEFORE_ADOPTED_METADATA_KEY,
     ON_BEFORE_CONNECTED_METADATA_KEY: () => ON_BEFORE_CONNECTED_METADATA_KEY,
     ON_BEFORE_DISCONNECTED_METADATA_KEY: () => ON_BEFORE_DISCONNECTED_METADATA_KEY,
+    ON_CONNECTED_COMPLETED_METADATA_KEY: () => ON_CONNECTED_COMPLETED_METADATA_KEY,
+    ON_CONNECTED_INNER_HTML_METADATA_KEY: () => ON_CONNECTED_INNER_HTML_METADATA_KEY,
     ON_CONNECTED_SWC_APP_METADATA_KEY: () => ON_CONNECTED_SWC_APP_METADATA_KEY,
     ON_INITIALIZE_METADATA_KEY: () => ON_INITIALIZE_METADATA_KEY,
     PROPERTY_SET_METADATA_KEY: () => PROPERTY_SET_METADATA_KEY,
@@ -1163,15 +1167,26 @@ var dooboostoreSimpleWebComponent = (() => {
     applyAttributeThis: () => applyAttributeThis,
     applyClass: () => applyClass,
     applyClassThis: () => applyClassThis,
-    applyInnerHtmlNode: () => applyInnerHtmlNode,
-    applyInnerHtmlNodeThis: () => applyInnerHtmlNodeThis,
-    applyInnerTextNode: () => applyInnerTextNode,
     applyNode: () => applyNode,
+    applyNodeInnerHtml: () => applyNodeInnerHtml,
+    applyNodeInnerText: () => applyNodeInnerText,
+    applyNodeReplaceChildren: () => applyNodeReplaceChildren,
     applyNodeThis: () => applyNodeThis,
-    applyReplaceChildrenNode: () => applyReplaceChildrenNode,
-    applyReplaceChildrenNodeThis: () => applyReplaceChildrenNodeThis,
+    applyNodeThisReplaceChildren: () => applyNodeThisReplaceChildren,
+    applySlot: () => applySlot,
+    applySlotAppend: () => applySlotAppend,
+    applySlotAppendHtml: () => applySlotAppendHtml,
+    applySlotAppendText: () => applySlotAppendText,
+    applySlotClear: () => applySlotClear,
+    applySlotPrepend: () => applySlotPrepend,
+    applySlotPrependHtml: () => applySlotPrependHtml,
+    applySlotPrependText: () => applySlotPrependText,
+    applySlotReplaceChildren: () => applySlotReplaceChildren,
+    applySlotReplaceChildrenHtml: () => applySlotReplaceChildrenHtml,
+    applySlotReplaceChildrenText: () => applySlotReplaceChildrenText,
     applyStyle: () => applyStyle,
     applyStyleThis: () => applyStyleThis,
+    applyThisInnerHtmlNode: () => applyThisInnerHtmlNode,
     attribute: () => attribute,
     attributeThis: () => attributeThis,
     changedAttributeThis: () => changedAttributeThis,
@@ -1184,6 +1199,7 @@ var dooboostoreSimpleWebComponent = (() => {
     emitCustomEventThis: () => emitCustomEventThis,
     ensureInit: () => ensureInit,
     findAllApplyNodeMetadata: () => findAllApplyNodeMetadata,
+    findAllApplySlotMetadata: () => findAllApplySlotMetadata,
     findAllAttributeApplyMetadata: () => findAllAttributeApplyMetadata,
     findAllAttributeChangedMetadata: () => findAllAttributeChangedMetadata,
     findAllAttributeMetadata: () => findAllAttributeMetadata,
@@ -1195,6 +1211,8 @@ var dooboostoreSimpleWebComponent = (() => {
     getChangedAttributeMetadata: () => getChangedAttributeMetadata,
     getElementConfig: () => getElementConfig,
     getEmitCustomEventMetadataList: () => getEmitCustomEventMetadataList,
+    getOnConnectedAfterMetadata: () => getOnConnectedAfterMetadata,
+    getOnConnectedBeforeMetadata: () => getOnConnectedBeforeMetadata,
     getOnConnectedInnerHtmlMetadata: () => getOnConnectedInnerHtmlMetadata,
     getPublishSwcAppMessageMetadata: () => getPublishSwcAppMessageMetadata,
     getQueryAllMetadata: () => getQueryAllMetadata,
@@ -1219,7 +1237,9 @@ var dooboostoreSimpleWebComponent = (() => {
     onConnected: () => onConnected,
     onConnectedAfter: () => onConnectedAfter,
     onConnectedBefore: () => onConnectedBefore,
+    onConnectedCompleted: () => onConnectedCompleted,
     onConnectedInnerHtml: () => onConnectedInnerHtml,
+    onConnectedSwcApp: () => onConnectedSwcApp,
     onDisconnected: () => onDisconnected,
     onDisconnectedAfter: () => onDisconnectedAfter,
     onDisconnectedBefore: () => onDisconnectedBefore,
@@ -1233,6 +1253,8 @@ var dooboostoreSimpleWebComponent = (() => {
     queryHost: () => queryHost,
     queryThis: () => queryThis,
     queryWindow: () => queryWindow,
+    register: () => register,
+    registerSwcApp: () => registerSwcApp,
     removeAttribute: () => removeAttribute,
     removeAttributeThis: () => removeAttributeThis,
     removeClass: () => removeClass,
@@ -1260,10 +1282,10 @@ var dooboostoreSimpleWebComponent = (() => {
     updateStyle: () => updateStyle,
     updateStyleThis: () => updateStyleThis
   });
-  var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+  var import_reflect_metadata3 = __toESM(require_Reflect(), 1);
 
   // src/index.ts
-  var import_reflect_metadata = __toESM(require_Reflect(), 1);
+  var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
   // ../core/dist/esm/valid/ValidUtils.js
   var ValidUtils;
@@ -4939,6 +4961,137 @@ var dooboostoreSimpleWebComponent = (() => {
     }
   };
 
+  // ../core/dist/esm/message/Subject.js
+  var Subject = class extends Observable {
+    constructor() {
+      super((subscriber) => {
+        return this._subscribeToSubject(subscriber);
+      });
+      this._observers = /* @__PURE__ */ new Set();
+      this._isStopped = false;
+      this._hasError = false;
+    }
+    _subscribeToSubject(subscriber) {
+      const partialObserver = {
+        next: subscriber.next.bind(subscriber),
+        error: subscriber.error.bind(subscriber),
+        complete: subscriber.complete.bind(subscriber)
+      };
+      if (this._isStopped) {
+        if (this._hasError) {
+          partialObserver.error?.(this._error);
+        } else {
+          partialObserver.complete?.();
+        }
+        return Subscription.EMPTY;
+      }
+      this._observers.add(partialObserver);
+      return new Subscription(() => {
+        this._observers.delete(partialObserver);
+      });
+    }
+    next(data) {
+      if (this._isStopped) {
+        return;
+      }
+      this._observers.forEach((observer) => {
+        observer.next?.(data);
+      });
+    }
+    error(err) {
+      if (this._isStopped) {
+        return;
+      }
+      this._hasError = true;
+      this._error = err;
+      this._isStopped = true;
+      this._observers.forEach((observer) => observer.error?.(err));
+      this._observers.clear();
+    }
+    complete() {
+      if (this._isStopped) {
+        return;
+      }
+      this._isStopped = true;
+      this._observers.forEach((observer) => observer.complete?.());
+      this._observers.clear();
+    }
+    asObservable() {
+      return new Observable((subscriber) => {
+        return this._subscribeToSubject(subscriber);
+      });
+    }
+  };
+
+  // ../core/dist/esm/message/BehaviorSubject.js
+  var BehaviorSubject = class extends Subject {
+    // BehaviorSubject always has a current value
+    constructor(initialValue) {
+      super();
+      this._value = initialValue;
+    }
+    next(data) {
+      this._value = data;
+      super.next(data);
+    }
+    _subscribeToSubject(subscriber) {
+      const subscription = super._subscribeToSubject(subscriber);
+      if (!this._isStopped) {
+        subscriber.next(this._value);
+      } else if (this._hasError) {
+        subscriber.error(this._error);
+      } else {
+        subscriber.complete();
+      }
+      return subscription;
+    }
+    getValue() {
+      if (this._hasError) {
+        throw this._error;
+      }
+      return this._value;
+    }
+  };
+
+  // ../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) {
@@ -4946,6 +5099,19 @@ var dooboostoreSimpleWebComponent = (() => {
     }
   };
 
+  // ../core/dist/esm/message/index.js
+  var debounceTimeIntervalLock = (unlockChecker, unlocked, intervalTime, config) => {
+    const clearIntervalFn = config?.clearInterval || clearInterval;
+    const setIntervalFn = config?.setInterval || setInterval;
+    const nextIntervalId = setIntervalFn(() => {
+      if (unlockChecker()) {
+        clearIntervalFn(nextIntervalId);
+        unlocked();
+      }
+    }, intervalTime);
+    return nextIntervalId;
+  };
+
   // ../core/dist/esm/promise/AbortablePromise.js
   var AbortablePromise = class _AbortablePromise {
     constructor(executor, signal) {
@@ -5273,6 +5439,284 @@ var dooboostoreSimpleWebComponent = (() => {
     })(Result = Promises2.Result || (Promises2.Result = {}));
   })(Promises || (Promises = {}));
 
+  // ../core/dist/esm/fetch/Fetcher.js
+  var Fetcher = class {
+    createPipe(config) {
+      return {};
+    }
+    fetch(config) {
+      return new Promise((resolve, reject) => {
+        const pipe = this.createPipe(config);
+        Promise.resolve().then(() => {
+          this.before(config, pipe);
+          config?.before?.();
+        }).then(() => {
+          return this.execute(config);
+        }).then((data) => {
+          const hasError = config.config?.hasErrorChecker?.(data);
+          if (hasError) {
+            throw hasError;
+          }
+          pipe.responseData = data;
+          this.afterSuccess(config, pipe);
+          config?.afterSuccess?.();
+          const gdata = config?.transform ? config.transform(data) : data;
+          this.afterSuccessTransform(config, pipe);
+          resolve(gdata);
+        }).catch(async (e) => {
+          this.error(config, pipe, e);
+          config?.error?.();
+          if (config?.errorTransform) {
+            e = await config.errorTransform(e);
+          }
+          e = await this.errorTransform(e);
+          reject(e);
+        }).finally(() => {
+          this.finally(config, pipe);
+          config?.finally?.();
+        });
+      });
+    }
+  };
+
+  // ../core/dist/esm/fetch/HttpFetcher.js
+  var HttpResponseError = class extends Error {
+  };
+  var HttpFetcher = class extends Fetcher {
+    get(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "GET";
+      return this.fetch(config);
+    }
+    post(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "POST";
+      return this.fetch(config);
+    }
+    patch(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "PATCH";
+      return this.fetch(config);
+    }
+    put(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "PUT";
+      return this.fetch(config);
+    }
+    head(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "HEAD";
+      return this.fetch(config);
+    }
+    delete(config) {
+      config.config ?? (config.config = {});
+      config.config.fetch = config.config?.fetch ?? {};
+      config.config.fetch.method = "DELETE";
+      return this.fetch(config);
+    }
+    async beforeProxyFetch(config) {
+      return config;
+    }
+    async afterProxyFetch(config) {
+      return config.response;
+    }
+    afterSuccess(config, pipe) {
+    }
+    afterSuccessTransform(config, pipe) {
+    }
+    before(config, pipe) {
+    }
+    error(config, pipe, e) {
+    }
+    finally(config, pipe) {
+    }
+    beforeFetch(fetch2) {
+    }
+    afterFetch(fetch2, response) {
+    }
+    // protected async errorTransform(e: any): Promise<HttpResponseError<any>> {
+    async errorTransform(e) {
+      const httpResponseError = new HttpResponseError();
+      httpResponseError.error = e;
+      if (e instanceof Response) {
+        httpResponseError.response = e;
+        try {
+          httpResponseError.body = await e.clone().text();
+          httpResponseError.message = e.statusText;
+        } catch (e2) {
+          httpResponseError.body = e2;
+          httpResponseError.message = e2.message;
+        }
+      } else {
+        httpResponseError.body = e;
+        httpResponseError.message = e.message;
+      }
+      return httpResponseError;
+    }
+    async execute(fetcherRequest) {
+      let target = fetcherRequest.target;
+      let config = fetcherRequest.config;
+      if (!(target instanceof URL) && typeof target !== "string") {
+        const searchParams = ConvertUtils.toURLSearchParams(target.searchParams ?? {});
+        try {
+          const url = typeof target.url === "string" ? new URL(target.url) : target.url;
+          searchParams.forEach((value, key) => {
+            url.searchParams.append(key, value);
+          });
+          target = url;
+        } catch (e) {
+          if (typeof target.url === "string") {
+            const searchParamString = searchParams.toString();
+            target = target.url + (searchParamString ? "?" + searchParamString : "");
+          } else {
+            target = "";
+          }
+        }
+      }
+      const beforeProxyData = { requestInfo: target, init: config?.fetch };
+      let beforeData = config?.beforeProxyFetch ? await config?.beforeProxyFetch(config) : beforeProxyData.requestInfo;
+      beforeData = config?.skipGlobalBeforeProxyFetch ? beforeProxyData : await this.beforeProxyFetch(beforeProxyData);
+      target = beforeData.requestInfo;
+      if (beforeData.init) {
+        config ?? (config = {});
+        config.fetch = beforeData.init;
+      }
+      let abortedTimeout;
+      if (config?.fetch && "timeout" in config.fetch) {
+        const abortController = new AbortController();
+        abortedTimeout = setTimeout(() => {
+          if (config?.fetch?.signal) {
+            const inputSignal = config.fetch.signal;
+            const listener = () => {
+              if (!abortController.signal.aborted) {
+                abortController.abort();
+              }
+              inputSignal.removeEventListener("abort", listener);
+            };
+            inputSignal.addEventListener("abort", listener);
+          }
+          if (!abortController.signal.aborted) {
+            abortController.abort();
+          }
+        }, config.fetch.timeout);
+        config.fetch.signal = abortController.signal;
+      }
+      this.beforeFetch({ target, requestInit: config?.fetch });
+      return (config.fetcher ?? fetch)(target, config?.fetch).then(async (it) => {
+        this.afterFetch({ target, requestInit: config?.fetch }, it);
+        const afterProxyData = {
+          fetch: { target, requestInit: config.fetch },
+          config: beforeData,
+          response: it
+        };
+        it = config?.afterProxyFetch ? await config.afterProxyFetch(afterProxyData) : it;
+        it = config?.skipGlobalAfterProxyFetch ? it : await this.afterProxyFetch(afterProxyData);
+        config?.fetchResponseAfterCallBack?.(it, config);
+        if (!config?.allowedResponseNotOk && !it.ok) {
+          throw it;
+        }
+        const data = config?.hasResponseErrorChecker?.(it, config);
+        if (data) {
+          throw data;
+        }
+        return it;
+      }).finally(() => {
+        if (abortedTimeout) {
+          clearTimeout(abortedTimeout);
+        }
+      });
+    }
+  };
+
+  // ../core/dist/esm/fetch/HttpJsonFetcher.js
+  var HttpJsonFetcher = class extends HttpFetcher {
+    updateJsonFetchConfigAndData(config) {
+      var _a, _b;
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/plain, */*"
+      };
+      config.config ?? (config.config = {});
+      (_a = config.config).fetch ?? (_a.fetch = {});
+      (_b = config.config.fetch).headers ?? (_b.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) {
@@ -6045,9 +6489,44 @@ var dooboostoreSimpleWebComponent = (() => {
   var ON_BEFORE_ADOPTED_METADATA_KEY = Symbol.for("simple-web-component:on-before-adopted");
   var ON_AFTER_ADOPTED_METADATA_KEY = Symbol.for("simple-web-component:on-after-adopted");
   var ON_ADD_EVENT_LISTENER_METADATA_KEY = Symbol.for("simple-web-component:on-add-event-listener");
+  var ON_CONNECTED_INNER_HTML_METADATA_KEY = Symbol.for("simple-web-component:inner-html");
   var ON_CONNECTED_SWC_APP_METADATA_KEY = Symbol.for("simple-web-component:on-connected-swc-app");
-  var INNER_HTML_METADATA_KEY = Symbol.for("simple-web-component:inner-html");
+  var ON_CONNECTED_COMPLETED_METADATA_KEY = Symbol.for("simple-web-component:on-completed");
   var ATTRIBUTE_CHANGED_WILDCARD = "*";
+  function onConnectedBefore(arg1, arg2, arg3) {
+    const decorator = (options, target, propertyKey) => {
+      const constructor = target.constructor;
+      let list = ReflectUtils.getMetadata(ON_BEFORE_CONNECTED_METADATA_KEY, constructor);
+      if (!list) {
+        list = [];
+        ReflectUtils.defineMetadata(ON_BEFORE_CONNECTED_METADATA_KEY, list, constructor);
+      }
+      list.push({ propertyKey, options });
+    };
+    if (arg2) {
+      return decorator({}, arg1, arg2);
+    }
+    return (target, propertyKey) => {
+      decorator(arg1 || {}, target, propertyKey);
+    };
+  }
+  function onConnectedAfter(arg1, arg2, arg3) {
+    const decorator = (options, target, propertyKey) => {
+      const constructor = target.constructor;
+      let list = ReflectUtils.getMetadata(ON_AFTER_CONNECTED_METADATA_KEY, constructor);
+      if (!list) {
+        list = [];
+        ReflectUtils.defineMetadata(ON_AFTER_CONNECTED_METADATA_KEY, list, constructor);
+      }
+      list.push({ propertyKey, options });
+    };
+    if (arg2) {
+      return decorator({}, arg1, arg2);
+    }
+    return (target, propertyKey) => {
+      decorator(arg1 || {}, target, propertyKey);
+    };
+  }
   function createLifecycleDecorator(metadataKey) {
     return (target, propertyKey) => {
       const constructor = target.constructor;
@@ -6060,8 +6539,6 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   }
   var onInitialize = createLifecycleDecorator(ON_INITIALIZE_METADATA_KEY);
-  var onConnectedBefore = createLifecycleDecorator(ON_BEFORE_CONNECTED_METADATA_KEY);
-  var onConnectedAfter = createLifecycleDecorator(ON_AFTER_CONNECTED_METADATA_KEY);
   var onConnected = onConnectedAfter;
   var onDisconnectedBefore = createLifecycleDecorator(ON_BEFORE_DISCONNECTED_METADATA_KEY);
   var onDisconnectedAfter = createLifecycleDecorator(ON_AFTER_DISCONNECTED_METADATA_KEY);
@@ -6070,13 +6547,15 @@ var dooboostoreSimpleWebComponent = (() => {
   var onAdoptedAfter = createLifecycleDecorator(ON_AFTER_ADOPTED_METADATA_KEY);
   var onAdopted = onAdoptedAfter;
   var onAddEventListener = createLifecycleDecorator(ON_ADD_EVENT_LISTENER_METADATA_KEY);
+  var onConnectedSwcApp = createLifecycleDecorator(ON_CONNECTED_SWC_APP_METADATA_KEY);
+  var onConnectedCompleted = createLifecycleDecorator(ON_CONNECTED_COMPLETED_METADATA_KEY);
   function onConnectedInnerHtml(arg1, arg2, arg3) {
     const decorator = (options, target, propertyKey) => {
       const constructor = target.constructor;
-      let list = ReflectUtils.getMetadata(INNER_HTML_METADATA_KEY, constructor);
+      let list = ReflectUtils.getMetadata(ON_CONNECTED_INNER_HTML_METADATA_KEY, constructor);
       if (!list) {
         list = [];
-        ReflectUtils.defineMetadata(INNER_HTML_METADATA_KEY, list, constructor);
+        ReflectUtils.defineMetadata(ON_CONNECTED_INNER_HTML_METADATA_KEY, list, constructor);
       }
       list.push({ propertyKey, options });
     };
@@ -6089,11 +6568,19 @@ var dooboostoreSimpleWebComponent = (() => {
   }
   var findAllLifecycleMetadata = (target, metadataKey) => {
     const results = ReflectUtils.findAllMetadataFlatten(metadataKey, target);
-    return results.length > 0 ? results : void 0;
+    return results;
   };
   var getOnConnectedInnerHtmlMetadata = (target) => {
     const constructor = target instanceof Function ? target : target.constructor;
-    return ReflectUtils.getMetadata(INNER_HTML_METADATA_KEY, constructor);
+    return ReflectUtils.getMetadata(ON_CONNECTED_INNER_HTML_METADATA_KEY, constructor) ?? [];
+  };
+  var getOnConnectedBeforeMetadata = (target) => {
+    const constructor = target instanceof Function ? target : target.constructor;
+    return ReflectUtils.getMetadata(ON_BEFORE_CONNECTED_METADATA_KEY, constructor) ?? [];
+  };
+  var getOnConnectedAfterMetadata = (target) => {
+    const constructor = target instanceof Function ? target : target.constructor;
+    return ReflectUtils.getMetadata(ON_AFTER_CONNECTED_METADATA_KEY, constructor) ?? [];
   };
 
   // src/utils/Utils.ts
@@ -6115,14 +6602,17 @@ var dooboostoreSimpleWebComponent = (() => {
     if (!d) throw new Error("Document is not available");
     return d.createComment(comment !== void 0 && comment !== null ? String(comment) : "");
   };
-  var createElement = (tagName, options) => {
-    const d = options?.doc || (typeof document !== "undefined" ? document : void 0);
-    if (!d) throw new Error("Document is not available");
-    const el = d.createElement(tagName);
-    if (options?.html) el.innerHTML = options.html;
+  var createElement = (documentOrWindow, tagName2, options) => {
+    const doc = "document" in documentOrWindow ? documentOrWindow.document : documentOrWindow;
+    if (!doc) throw new Error("Document is not available");
+    const el = doc.createElement(tagName2);
+    if (options?.innerHtml) el.innerHTML = options.innerHtml;
     if (options?.attrs) {
       Object.entries(options.attrs).forEach(([k, v]) => el.setAttribute(k, String(v)));
     }
+    if (options?.property) {
+      Object.entries(options.property).forEach(([k, v]) => el[k] = v);
+    }
     return el;
   };
   var htmlDivElement = (html, options) => {
@@ -6376,7 +6866,7 @@ var dooboostoreSimpleWebComponent = (() => {
         $hosts,
         $firstHost,
         $lastHost: $host,
-        $templateHost: el.__swc_template_host,
+        // $templateHost: (el as any).__swc_template_host,
         $appHost,
         $appHosts,
         $firstAppHost,
@@ -7055,7 +7545,22 @@ var dooboostoreSimpleWebComponent = (() => {
       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.for("simple-boot:inject-metadata");
+  var getInject = (target, propertyKey) => {
+    return ReflectUtils.findMetadata(InjectMetadataKey, target, propertyKey) ?? [];
+  };
 
   // src/types.ts
   var InjectSituationType = /* @__PURE__ */ ((InjectSituationType2) => {
@@ -7327,6 +7832,379 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   })(NodeUtils || (NodeUtils = {}));
 
+  // ../core-web/dist/esm/node/slot/Slot.js
+  var Slot = class {
+    constructor(start, end) {
+      this.start = start;
+      this.end = end;
+    }
+    // Parse mixed Node|string items into Node[] within the context of this slot's
+    // document. This is a private helper that uses the slot's start comment to
+    // resolve the ownerDocument. mode: 'html'|'text'|'auto'
+    parseItems(items, mode = "html") {
+      const out = [];
+      const host = this.start;
+      const doc = host && host.ownerDocument ? host.ownerDocument : typeof document !== "undefined" ? document : void 0;
+      if (!doc) return out;
+      for (const it of items) {
+        if (typeof it === "string") {
+          if (mode === "text") {
+            out.push(doc.createTextNode(it));
+          } else {
+            const template = doc.createElement("template");
+            template.innerHTML = it;
+            const childNodes = Array.from(template.content.childNodes);
+            out.push(...childNodes);
+          }
+        } else {
+          out.push(it);
+        }
+      }
+      return out;
+    }
+    // Return nodes between start and end (exclusive) using nextSibling traversal
+    nodes() {
+      const out = [];
+      let cur = this.start.nextSibling;
+      while (cur && cur !== this.end) {
+        out.push(cur);
+        cur = cur.nextSibling;
+      }
+      return out;
+    }
+    append(...items) {
+      if (!items || items.length === 0) return;
+      const nodesToInsert = this.parseItems(items);
+      if (nodesToInsert.length === 0) return;
+      const parent = this.end ? this.end.parentNode : this.start.parentNode;
+      const ref = this.end || null;
+      for (const n of nodesToInsert) {
+        if (ref) parent.insertBefore(n, ref);
+        else parent.appendChild(n);
+      }
+    }
+    // Explicit HTML/text variants
+    appendHtml(...items) {
+      this.append(...items);
+    }
+    appendText(...items) {
+      const nodesToInsert = this.parseItems(items, "text");
+      if (!nodesToInsert || nodesToInsert.length === 0) return;
+      this.append(...nodesToInsert);
+    }
+    prepend(...items) {
+      if (!items || items.length === 0) return;
+      const nodesToInsert = this.parseItems(items);
+      if (nodesToInsert.length === 0) return;
+      const parent = this.start.parentNode;
+      const before = this.start.nextSibling;
+      for (let i = nodesToInsert.length - 1; i >= 0; i--) {
+        const n = nodesToInsert[i];
+        parent.insertBefore(n, before);
+      }
+    }
+    prependHtml(...items) {
+      this.prepend(...items);
+    }
+    prependText(...items) {
+      const nodesToInsert = this.parseItems(items, "text");
+      if (!nodesToInsert || nodesToInsert.length === 0) return;
+      this.prepend(...nodesToInsert);
+    }
+    clear() {
+      let cur = this.start.nextSibling;
+      while (cur && cur !== this.end) {
+        const next = cur.nextSibling;
+        if ("remove" in cur && typeof cur.remove === "function")
+          cur.remove();
+        cur = next;
+      }
+    }
+    // Replace all children between start and end with provided items.
+    // Items can be Node or string (HTML/text). Uses parseItems to create
+    // insertion nodes and then appends them (after clearing existing children).
+    replaceChildren(...items) {
+      this.clear();
+      if (!items || items.length === 0) return;
+      const nodesToInsert = this.parseItems(items);
+      if (!nodesToInsert || nodesToInsert.length === 0) return;
+      this.append(...nodesToInsert);
+    }
+    /**
+     * Explicit HTML variant of replaceChildren — alias for replaceChildren
+     * to make intent clear.
+     */
+    replaceChildrenHtml(...items) {
+      this.replaceChildren(...items);
+    }
+    /**
+     * Explicit text variant of replaceChildren — parses strings as text nodes
+     * and replaces the children with those text nodes.
+     */
+    replaceChildrenText(...items) {
+      this.clear();
+      if (!items || items.length === 0) return;
+      const nodesToInsert = this.parseItems(items, "text");
+      if (!nodesToInsert || nodesToInsert.length === 0) return;
+      this.append(...nodesToInsert);
+    }
+    findAll(predicate) {
+      if (!predicate) return this.nodes();
+      return this.nodes().filter(predicate);
+    }
+    querySelector(selector) {
+      if (!selector) return null;
+      for (const n of this.nodes()) {
+        if (n.nodeType === Node.ELEMENT_NODE) {
+          const el = n;
+          if (el.matches && el.matches(selector)) return el;
+          const found = el.querySelector(selector);
+          if (found) return found;
+        }
+      }
+      return null;
+    }
+    querySelectorAll(selector) {
+      if (!selector) return [];
+      const out = [];
+      for (const n of this.nodes()) {
+        if (n.nodeType === Node.ELEMENT_NODE) {
+          const el = n;
+          if (el.matches && el.matches(selector)) out.push(el);
+          const found = el.querySelectorAll(selector);
+          if (found && found.length) out.push(...Array.from(found));
+        }
+      }
+      return out;
+    }
+    /**
+     * Append clones of provided items into this slot.
+     * Strings will be parsed and resulting nodes cloned; Node items will be cloned.
+     */
+    appendCopy(...items) {
+      const parsed = this.parseItems(items);
+      if (!parsed || parsed.length === 0) return;
+      const clones = parsed.map((n) => n.cloneNode(true));
+      if (clones.length === 0) return;
+      this.append(...clones);
+    }
+    /**
+     * Prepend clones of provided items into this slot.
+     */
+    prependCopy(...items) {
+      const parsed = this.parseItems(items);
+      if (!parsed || parsed.length === 0) return;
+      const clones = parsed.map((n) => n.cloneNode(true));
+      if (clones.length === 0) return;
+      this.prepend(...clones);
+    }
+  };
+
+  // ../core-web/dist/esm/node/slot/NodeSlot.js
+  var NodeSlot = class _NodeSlot {
+    constructor(host, id) {
+      if (!host) throw new Error("host node is required");
+      if (!id) throw new Error("id is required");
+      this.host = host;
+      this.id = id;
+      const markerData = _NodeSlot.startEndMarkerData(id);
+      this.startMarkerData = markerData.start;
+      this.endMarkerData = markerData.end;
+    }
+    static startEndMarkerData(id) {
+      return {
+        start: `__slot_start__:${id}`,
+        end: `__slot_end__:${id}`
+      };
+    }
+    static slot(id) {
+      const uid = RandomUtils.uuid();
+      const markerData = _NodeSlot.startEndMarkerData(id);
+      const start = `<!--${markerData.start}:${uid}-->`;
+      const end = `<!--${markerData.end}:${uid}-->`;
+      return `${start}${end}`;
+    }
+    /**
+     * Return HTML comment string pair for embedding into templates.
+     * Example: host.innerHTML = `<div>...${nodeSlot}...</div>`
+     */
+    get slot() {
+      return _NodeSlot.slot(this.id);
+    }
+    // startCommentString and endCommentString getters removed — use slot() which
+    // generates the full start/end comment pair including a unique uid per
+    // insertion to ensure correct pairing when multiple slots with the same id
+    // are inserted into the DOM.
+    // toString removed intentionally to avoid accidental implicit string coercion.
+    // Note: Symbol.toPrimitive removed to avoid custom primitive coercion logic.
+    // valueOf and Symbol.toStringTag removed — prefer explicit use of slot getter/string conversion.
+    findSlots() {
+      const result = [];
+      const doc = this.host.ownerDocument || (typeof document !== "undefined" ? document : void 0);
+      const win = doc?.defaultView;
+      if (!doc || !win) return result;
+      const find = (target) => {
+        const walker = doc.createTreeWalker(target, win.NodeFilter.SHOW_COMMENT, null, false);
+        let node = walker.nextNode();
+        const startPrefix = this.startMarkerData + ":";
+        while (node) {
+          const data = node.data;
+          if (data && data.indexOf(startPrefix) === 0) {
+            const uid = data.substring(startPrefix.length);
+            const expectedEnd = `${this.endMarkerData}:${uid}`;
+            let sibling = node.nextSibling;
+            let foundEnd = null;
+            while (sibling) {
+              if (sibling.nodeType === win.Node.COMMENT_NODE && sibling.data === expectedEnd && sibling.parentNode === node.parentNode) {
+                foundEnd = sibling;
+                break;
+              }
+              sibling = sibling.nextSibling;
+            }
+            result.push(new Slot(node, foundEnd));
+          }
+          node = walker.nextNode();
+        }
+      };
+      if (this.host.shadowRoot) {
+        find(this.host.shadowRoot);
+      }
+      find(this.host);
+      return result;
+    }
+    /**
+     * Return an array of node arrays — for each found slot pair (via findSlots())
+     * returns the nodes between its start and end (exclusive). Uses sibling
+     * traversal (nextSibling) because findSlots pairs only same-parent markers.
+     */
+    nodes() {
+      const slots = this.findSlots();
+      return slots.map((s) => s.nodes());
+    }
+    append(...items) {
+      if (!items || items.length === 0) return;
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.append(...items);
+      }
+    }
+    appendHtml(...items) {
+      const slots = this.findSlots();
+      for (const s of slots) s.appendHtml(...items);
+    }
+    appendText(...items) {
+      const slots = this.findSlots();
+      for (const s of slots) s.appendText(...items);
+    }
+    /**
+     * Append copies of the provided items into each found slot.
+     */
+    appendCopy(...items) {
+      if (!items || items.length === 0) return;
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.appendCopy(...items);
+      }
+    }
+    prepend(...items) {
+      if (!items || items.length === 0) return;
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.prepend(...items);
+      }
+    }
+    prependHtml(...items) {
+      const slots = this.findSlots();
+      for (const s of slots) s.prependHtml(...items);
+    }
+    prependText(...items) {
+      const slots = this.findSlots();
+      for (const s of slots) s.prependText(...items);
+    }
+    /**
+     * Prepend copies of the provided items into each found slot.
+     */
+    prependCopy(...items) {
+      if (!items || items.length === 0) return;
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.prependCopy(...items);
+      }
+    }
+    clear() {
+      const slots = this.findSlots();
+      for (const s of slots) {
+        s.clear();
+      }
+    }
+    /**
+     * Replace children inside each found slot with the provided items.
+     * Items can be Node or string (HTML).
+     */
+    replaceChildren(...items) {
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.replaceChildren(...items);
+      }
+    }
+    replaceChildrenHtml(...items) {
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.replaceChildrenHtml(...items);
+      }
+    }
+    replaceChildrenText(...items) {
+      const slots = this.findSlots();
+      if (!slots || slots.length === 0) return;
+      for (const s of slots) {
+        s.replaceChildrenText(...items);
+      }
+    }
+    findAll(predicate) {
+      const groups = this.nodes();
+      const flat = groups.reduce((acc, cur) => acc.concat(cur), []);
+      if (!predicate) return flat;
+      return flat.filter(predicate);
+    }
+    querySelector(selector) {
+      if (!selector) return null;
+      const groups = this.nodes();
+      for (const nodes of groups) {
+        for (const n of nodes) {
+          if (n.nodeType === Node.ELEMENT_NODE) {
+            const el = n;
+            if (el.matches && el.matches(selector)) return el;
+            const found = el.querySelector(selector);
+            if (found) return found;
+          }
+        }
+      }
+      return null;
+    }
+    querySelectorAll(selector) {
+      if (!selector) return [];
+      const out = [];
+      const groups = this.nodes();
+      for (const nodes of groups) {
+        for (const n of nodes) {
+          if (n.nodeType === Node.ELEMENT_NODE) {
+            const el = n;
+            if (el.matches && el.matches(selector)) out.push(el);
+            const found = el.querySelectorAll(selector);
+            if (found && found.length) out.push(...Array.from(found));
+          }
+        }
+      }
+      return out;
+    }
+  };
+
   // ../core-web/dist/esm/document/DocumentUtils.js
   var DocumentUtils;
   ((DocumentUtils2) => {
@@ -7721,8 +8599,360 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   })(LocationUtils || (LocationUtils = {}));
 
-  // ../core-web/dist/esm/stylecss/StyleCssUtils.js
-  var StyleCssUtils;
+  // ../core-web/dist/esm/routers/Router.js
+  var ROUTER_NO_EVENT_MARKER = "__ROUTER_NO_EVENT__";
+  var Router = class {
+    constructor(config) {
+      this._config = config;
+      let routeData;
+      if (config?.firstUrl) {
+        const path = config.firstUrl.split("?");
+        const urlSearchParams = new URLSearchParams(path[1] ?? "");
+        routeData = {
+          url: config.firstUrl,
+          path: path[0],
+          searchParams: urlSearchParams,
+          router: this,
+          search: urlSearchParams.size > 0 ? `?${urlSearchParams.toString()}` : "",
+          triggerPoint: "first-end"
+        };
+        this.behaviorSubject = new BehaviorSubject(routeData);
+        this.go(config.firstUrl);
+      } else {
+        routeData = { ...this.getRouteData(), triggerPoint: "first-end" };
+        this.behaviorSubject = new BehaviorSubject(routeData);
+      }
+      this.config.window.addEventListener("popstate", (event) => {
+        const routeData2 = { ...this.getRouteData(), triggerPoint: "end" };
+        this.behaviorSubject.next(routeData2);
+      });
+    }
+    get value() {
+      return this.behaviorSubject.getValue();
+    }
+    get observable() {
+      return this.behaviorSubject.asObservable();
+    }
+    get searchParamObject() {
+      return ConvertUtils.toObject(this.getSearchParams());
+    }
+    getSearchParamObject() {
+      return this.searchParamObject;
+    }
+    get config() {
+      return this._config;
+    }
+    getSearchFirstParamsObject(defaultValue) {
+      const a = ConvertUtils.toObject(this.getSearchParams(), { firstValue: true });
+      return Object.assign({}, defaultValue, a);
+    }
+    getHashSearchFirstParamsObject() {
+      return ConvertUtils.toObject(this.getHashSearchParams(), { firstValue: true });
+    }
+    // async attach(): Promise<void> {
+    //   // const proxy = getDomRenderProxy(this.config.rootObject)
+    //   // if (proxy) {
+    //   //   const key = `___${EventManager.ROUTER_VARNAME}`;
+    //   //   await proxy.render(key);
+    //   // }
+    // }
+    testRegexp(regexp) {
+      if (regexp) {
+        const b = RegExp(regexp).test(this.getPathName());
+        return b;
+      } else {
+        return false;
+      }
+    }
+    test(urlExpression) {
+      if (urlExpression && this.getPathData(urlExpression)) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    getRouteData(config) {
+      let path = this.getPathName();
+      let url = this.getUrl();
+      let searchParams = this.getSearchParams();
+      let search = this.getSearch();
+      if (config?.pathOrUrl) {
+        const paths = config.pathOrUrl.split("?");
+        search = paths[1] ? `?${paths[1]}` : "";
+        searchParams = new URLSearchParams(search);
+        const firstUrl = paths[0];
+        if (ValidUtils.isUrl(firstUrl)) {
+          path = new URL(firstUrl).pathname;
+        } else {
+          path = firstUrl;
+        }
+        url = config.pathOrUrl;
+      }
+      const newVar = {
+        path,
+        url,
+        searchParams,
+        // 이렇게 하면 진짜 문자열이 변형이 될수 있다 따라서 그냥 문자열 자른 원본을넣어줘야한다
+        // search: searchParams.size > 0 ? `?${searchParams.toString()}` : '',
+        search,
+        router: this
+      };
+      const data = this.getData();
+      if (data) {
+        newVar.data = data;
+      }
+      if (config?.urlExpression) {
+        const data2 = this.getPathData(config.urlExpression);
+        if (data2) {
+          newVar.pathData = data2;
+        }
+      }
+      return Object.freeze(newVar);
+    }
+    pushState(data, title, path, config) {
+      const stateData = config?.noEventAndPublish ? { ...data, [ROUTER_NO_EVENT_MARKER]: true } : data;
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      }
+      this.config.window.history?.pushState(stateData, title ?? "", path);
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
+      }
+      return { data: stateData };
+    }
+    replaceState(data, title, path, config) {
+      const stateData = config?.noEventAndPublish ? { ...data, [ROUTER_NO_EVENT_MARKER]: true } : data;
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      }
+      this.config.window.history?.replaceState(stateData, title ?? "", path);
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
+      }
+      return { data: stateData };
+    }
+    getData() {
+      return this.config.window.history?.state;
+    }
+    getPathData(urlExpression, currentUrl = this.getPathName()) {
+      return Expression.Path.pathNameData(currentUrl, urlExpression);
+    }
+    back(config) {
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+      }
+      this.config.window.history.back();
+    }
+    forward(config) {
+      if (!config?.noEventAndPublish) {
+        this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+      }
+      this.config.window.history?.forward();
+    }
+    go(config, changeStateConfig) {
+      if (typeof config === "number") {
+        if (!changeStateConfig?.noEventAndPublish) {
+          this.behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+        }
+        this.config.window.history?.go(config);
+        return;
+      }
+      if (typeof config === "string") {
+        config = { path: config };
+      }
+      if (config?.replace) {
+        this.replace(config.path, config.state);
+      } else {
+        this.push(config.path, config.state);
+      }
+      if (config.scrollToTop !== false) {
+        try {
+          this._config.window?.scrollTo?.(0, 0);
+        } catch (e) {
+        }
+      }
+    }
+    toUrl(data) {
+      let targetPath;
+      if (typeof data === "string") {
+        targetPath = data;
+      } else {
+        const tpath = data.path ?? this.getPathName();
+        const s = data.searchParams ? ConvertUtils.toRawQueryString(data.searchParams, { valueEncodeURIComponent: true }) : "";
+        targetPath = `${tpath}${s.length > 0 ? "?" : ""}${s}`;
+      }
+      return targetPath;
+    }
+    reload() {
+      const currentUrl = this.getUrl();
+      this.replace(currentUrl);
+    }
+  };
+
+  // ../core-web/dist/esm/routers/HashRouter.js
+  var HashRouter = class extends Router {
+    constructor(config) {
+      super(config);
+    }
+    getSearchParams(data) {
+      const hashSearch = LocationUtils.hashSearch(this.config.window);
+      const searchParams = hashSearch ? new URLSearchParams(hashSearch) : new URL(this.config.window.document.location.href).searchParams;
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+    push(path, state) {
+      if (path === "/") {
+        return super.pushState(state?.data, state?.title, "/", state?.config);
+      } else {
+        return super.pushState(state?.data, state?.title, `#${this.toUrl(path)}`, state?.config);
+      }
+    }
+    replace(path, state) {
+      if (path === "/") {
+        return super.replaceState(state?.data, state?.title, "/", state?.config);
+      } else {
+        return super.replaceState(state?.data, state?.title, `#${this.toUrl(path)}`, state?.config);
+      }
+    }
+    setDeleteHashSearchParam(name, state) {
+    }
+    pushDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const size = Array.from(s.entries()).length;
+      const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? "#" + s.toString() : ""}`;
+      super.pushState(state?.data, state?.title, href, state?.config);
+    }
+    pushDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.push({ searchParams: s }, state);
+    }
+    pushAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.push({ searchParams: s }, state);
+    }
+    pushUpsertSearchParam(params, state) {
+      const s = this.getSearchParams();
+      UrlUtils.upsertSearchParam(s, params);
+      this.push({ searchParams: s }, state);
+    }
+    replaceDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const size = Array.from(s.entries()).length;
+      const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? "#" + s.toString() : ""}`;
+      super.pushState(state?.data, state?.title, href, state?.config);
+    }
+    replaceDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.push({ searchParams: s }, state);
+    }
+    replaceAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.push({ searchParams: s }, state);
+    }
+    replaceUpsertSearchParam(params, state) {
+      const s = this.getSearchParams();
+      UrlUtils.upsertSearchParam(s, params);
+      this.replace({ searchParams: s }, state);
+    }
+    getUrl() {
+      return LocationUtils.hash(this.config.window) || "/";
+    }
+    getHref() {
+      return this.config.window.location.href;
+    }
+    getPathName() {
+      return LocationUtils.hashPath(this.config.window) || "/";
+    }
+    getSearch() {
+      return LocationUtils.hashSearch(this.config.window);
+    }
+    getHashSearchParams(data) {
+      const hash = this.config.window.location.hash;
+      const queryIndex = hash.indexOf("?");
+      const searchParams = queryIndex !== -1 ? new URLSearchParams(hash.slice(queryIndex + 1)) : new URLSearchParams();
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+  };
+
+  // ../core-web/dist/esm/routers/PathRouter.js
+  var PathRouter = class extends Router {
+    constructor(config) {
+      super(config);
+    }
+    getSearchParams(data) {
+      if (!this.config.window.document?.location?.href) {
+        return new URLSearchParams();
+      }
+      const searchParams = new URL(this.config.window.document.location?.href).searchParams;
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+    push(path, state) {
+      return super.pushState(state?.data, state?.title, this.toUrl(path), state?.config);
+    }
+    replace(path, state) {
+      return super.replaceState(state?.data, state?.title, this.toUrl(path), state?.config);
+    }
+    pushDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.push({ searchParams: s }, state);
+    }
+    pushDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const size = Array.from(s.entries()).length;
+      const href = `${this.config.window.location?.pathname ?? "/"}${this.config.window.location?.search}${size > 0 ? "#" + s.toString() : ""}`;
+      super.pushState(state?.data, state?.title, href, state?.config);
+    }
+    pushAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.push({ searchParams: s }, state);
+    }
+    pushUpsertSearchParam(params, state) {
+      const s = this.getSearchParams();
+      UrlUtils.upsertSearchParam(s, params);
+      this.push({ searchParams: s }, state);
+    }
+    replaceDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.replace({ searchParams: s }, state);
+    }
+    replaceDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const size = Array.from(s.entries()).length;
+      const href = `${this.config.window.location?.pathname ?? "/"}${this.config.window.location?.search}${size > 0 ? "#" + s.toString() : ""}`;
+      super.replaceState(state?.data, state?.title, href, state?.config);
+    }
+    replaceAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.replace({ searchParams: s }, state);
+    }
+    replaceUpsertSearchParam(params, state) {
+      const s = this.getSearchParams();
+      UrlUtils.upsertSearchParam(s, params);
+      this.replace({ searchParams: s }, state);
+    }
+    getUrl() {
+      if (!this.config.window.document?.location?.href) {
+        return "/";
+      }
+      const url = new URL(this.config.window.document.location?.href);
+      return url.pathname + url.search;
+    }
+    getHref() {
+      return this.config.window.location?.href ?? "/";
+    }
+    getPathName() {
+      return this.config.window.location?.pathname ?? "/";
+    }
+    getSearch() {
+      return this.config.window.location?.search ?? "";
+    }
+    getHashSearchParams(data) {
+      const searchParams = new URLSearchParams(this.config.window.location?.hash.slice(1) ?? "");
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+  };
+
+  // ../core-web/dist/esm/stylecss/StyleCssUtils.js
+  var StyleCssUtils;
   ((StyleCssUtils2) => {
     StyleCssUtils2.getPropertyValue = (valueName, config) => {
       return config.window.getComputedStyle(config.el).getPropertyValue(valueName);
@@ -7839,6 +9069,91 @@ var dooboostoreSimpleWebComponent = (() => {
     };
   })(ValidUtils2 || (ValidUtils2 = {}));
 
+  // src/decorators/applySlot.ts
+  var APPLY_SLOT_METADATA_KEY = Symbol.for("simple-web-component:apply-slot");
+  function applySlot(id, options = { position: "replaceChildrenHtml" }) {
+    return (targetObj, propertyKey, descriptor) => {
+      const type = descriptor === void 0 ? "property" : "method";
+      if (type === "property") {
+        Object.defineProperty(targetObj, propertyKey, {
+          get() {
+            const nodeSlot = new NodeSlot(this, `${this._swcId}-${id}`);
+            return nodeSlot;
+          },
+          configurable: true,
+          enumerable: true
+        });
+      }
+      const constructor = targetObj.constructor;
+      let metaList = ReflectUtils.getOwnMetadata(APPLY_SLOT_METADATA_KEY, constructor);
+      if (!metaList) {
+        metaList = [];
+        ReflectUtils.defineMetadata(APPLY_SLOT_METADATA_KEY, metaList, constructor);
+      }
+      metaList.push({ propertyKey, id, type, options });
+      if (type === "method") {
+        const original = descriptor.value;
+        descriptor.value = function(...args) {
+          ensureInit(this);
+          const conf = getElementConfig(this);
+          const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+          const currentDoc = currentWin.document;
+          const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+          const res = original.apply(this, args);
+          if (res) {
+            const nodeSlot = new NodeSlot(this, `${this._swcId}-${id}`);
+            const pos = options.position || "replaceChildrenHtml";
+            const doc = currentWin.document;
+            if (pos === "replaceChildrenHtml") {
+              nodeSlot.replaceChildrenHtml(res);
+            } else if (pos === "replaceChildrenText") {
+              nodeSlot.replaceChildrenText(res);
+            } else if (pos === "appendHtml") {
+              nodeSlot.appendHtml(res);
+            } else if (pos === "appendText") {
+              nodeSlot.appendText(res);
+            } else if (pos === "prependHtml") {
+              nodeSlot.prependHtml(res);
+            } else if (pos === "prependText") {
+              nodeSlot.prependText(res);
+            } else if (pos === "clear") {
+              nodeSlot.clear();
+            }
+          }
+          return res;
+        };
+      }
+    };
+  }
+  var findAllApplySlotMetadata = (target) => {
+    const constructor = target instanceof Function ? target : target.constructor;
+    return ReflectUtils.getMetadata(APPLY_SLOT_METADATA_KEY, constructor);
+  };
+  function applySlotClear(id) {
+    return applySlot(id, { position: "clear" });
+  }
+  function applySlotPrependHtml(id) {
+    return applySlot(id, { position: "prependHtml" });
+  }
+  var applySlotPrepend = applySlotPrependHtml;
+  function applySlotPrependText(id) {
+    return applySlot(id, { position: "prependText" });
+  }
+  function applySlotAppendHtml(id) {
+    return applySlot(id, { position: "appendHtml" });
+  }
+  function applySlotAppendText(id) {
+    return applySlot(id, { position: "appendText" });
+  }
+  var applySlotAppend = applySlotAppendHtml;
+  function applySlotReplaceChildrenHtml(id) {
+    return applySlot(id, { position: "replaceChildrenHtml" });
+  }
+  var applySlotReplaceChildren = applySlotReplaceChildrenHtml;
+  function applySlotReplaceChildrenText(id) {
+    return applySlot(id, { position: "replaceChildrenText" });
+  }
+
   // src/decorators/elementDefine.ts
   var ELEMENT_CONFIG_KEY = Symbol.for("simple-web-component:element-config");
   var getElementConfig = (target) => {
@@ -7847,7 +9162,7 @@ var dooboostoreSimpleWebComponent = (() => {
   };
   var ensureInit = (inst) => {
     if (!inst.__swc_initialized) {
-      inst._swcId = Math.random().toString(36).substring(2, 11);
+      inst._swcId = inst?.getAttribute?.("swc-use-ssr") ?? Math.random().toString(36).substring(2, 11);
       inst._emitHandlers = /* @__PURE__ */ new Map();
       inst._boundListeners = [];
       inst.__swc_initialized = true;
@@ -7868,6 +9183,12 @@ var dooboostoreSimpleWebComponent = (() => {
           delete inst[meta.propertyKey];
         });
       }
+      const slotAllList = findAllApplySlotMetadata(target);
+      if (slotAllList) {
+        slotAllList.filter((it) => it.type === "property").forEach((meta) => {
+          delete inst[meta.propertyKey];
+        });
+      }
       const hostSet = SwcUtils.getHostSet(inst);
       const appHosts = SwcUtils.findAllAppHostsIncludingSelfDirect(inst);
       inst._executeSwcScript?.("swc-on-constructor", hostSet);
@@ -7910,7 +9231,7 @@ var dooboostoreSimpleWebComponent = (() => {
     if (!inst.__swc_attributeEventHandlers) inst.__swc_attributeEventHandlers = /* @__PURE__ */ new Map();
     return inst.__swc_attributeEventHandlers;
   };
-  var setupPrototype = (proto) => {
+  var setupPrototype = (proto, win) => {
     if (proto.__swc_proto_setup) return;
     proto.__swc_proto_setup = true;
     proto._executeSwcScript = function(attrName, hostSet, extraArgs = {}) {
@@ -7941,7 +9262,7 @@ var dooboostoreSimpleWebComponent = (() => {
     proto._invokeLifecycleMethod = function(methodName, hostSet, extraArgs = []) {
       ensureInit(this);
       if (typeof this[methodName] !== "function") return;
-      const useHostSet = hostSet ?? SwcUtils.getHostSet(this);
+      const useHostSet = hostSet ?? SwcUtils.getHelperAndHostSet(win, this);
       const app = useHostSet?.$appHost?.simpleApplication;
       if (app) {
         const otherStorage = /* @__PURE__ */ new Map();
@@ -8046,61 +9367,57 @@ var dooboostoreSimpleWebComponent = (() => {
     const hostAttributes = attributeList.filter((it) => it.selector === "$this").map((it) => it.options.name || String(it.propertyKey));
     const originalStaticObservedAttributes = constructor.observedAttributes ?? [];
     const mergedObservedAttributes = [.../* @__PURE__ */ new Set([...metadata.observedAttributes ?? [], ...originalStaticObservedAttributes, ...attrChangeMap.keys(), ...attributeApplyNames, ...hostAttributes, ...emitHostCustomEventList.map((it) => it.options.attributeName).filter(Boolean), ...swcLifecycleAttributes, ...swcOnEvents])];
-    const connectedInnerHtmlList = getOnConnectedInnerHtmlMetadata(constructor) || [];
     const proto = constructor.prototype;
-    setupPrototype(proto);
+    setupPrototype(proto, win);
     let helperHostSet = null;
     const originalConnected = proto.connectedCallback;
     proto.connectedCallback = async function() {
       ensureInit(this);
       helperHostSet = SwcUtils.getHelperAndHostSet(win, this);
       const appHost = helperHostSet.$appHost;
+      const useSsr = isSSR(this);
       try {
         if (appHost && typeof appHost._connected === "function") {
           await appHost._connected(this);
         } else if (appHost && typeof appHost) {
-          appHost._connected_safari ?? (appHost._connected_safari = []);
-          appHost._connected_safari.push(this);
+          appHost._connected_safari_and_standby ?? (appHost._connected_safari_and_standby = []);
+          appHost._connected_safari_and_standby.push(this);
         }
         const conf = getElementConfig(this);
         const currentWin = this._resolveWindow(conf);
-        const shadowMode = conf?.useShadow || connectedInnerHtmlList.find((it) => it.options.useShadow)?.options.useShadow;
+        const bMethods = getOnConnectedBeforeMetadata(this).filter((it) => useSsr ? !it.options.ssrFirst : true);
+        if (bMethods) {
+          for (const m of bMethods) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
+        }
+        this._executeSwcScript("swc-on-before-connected", helperHostSet);
+        const targetConnectedInnerHtmlList = getOnConnectedInnerHtmlMetadata(constructor).filter((it) => useSsr ? !it.options.ssrFirst : true);
+        const shadowMode = conf?.useShadow || targetConnectedInnerHtmlList.find((it) => it.options.useShadow)?.options.useShadow;
         if (shadowMode && !this.shadowRoot) {
           const mode = shadowMode === true ? "open" : shadowMode;
           this.attachShadow({ mode });
         }
-        const bMethods = findAllLifecycleMetadata(this, ON_BEFORE_CONNECTED_METADATA_KEY);
-        if (bMethods) {
-          for (const m of bMethods) await this._invokeLifecycleMethod(m, helperHostSet);
-        }
-        this._executeSwcScript("swc-on-before-connected", helperHostSet);
-        if (connectedInnerHtmlList.length > 0) {
+        if (targetConnectedInnerHtmlList.length > 0) {
           let sContent = "", lContent = "";
-          for (const meta of connectedInnerHtmlList) {
+          for (const meta of targetConnectedInnerHtmlList) {
             let res = await this._invokeLifecycleMethod(meta.propertyKey, helperHostSet);
             const actionExpression = new ActionExpression(res, {
               expression: {
                 replace: {
-                  start: meta.options.replaceWrap?.start || "{%{",
-                  end: meta.options.replaceWrap?.end || "}%}"
+                  start: meta.options.replaceWrap?.start || "[[",
+                  end: meta.options.replaceWrap?.end || "]]"
                 },
                 callReturn: {
-                  start: meta.options.replaceWrap?.start || "{%{=",
-                  end: meta.options.replaceWrap?.end || "}%}"
+                  start: meta.options.replaceWrap?.start || "[[=",
+                  end: meta.options.replaceWrap?.end || "]]"
                 },
                 call: {
-                  start: meta.options.replaceWrap?.start || "{%{@",
-                  end: meta.options.replaceWrap?.end || "}%}"
+                  start: meta.options.replaceWrap?.start || "[[@",
+                  end: meta.options.replaceWrap?.end || "]]"
                 }
               }
             });
             actionExpression.getExpressions().filter((it) => it.type === "replace").forEach((it) => {
-              try {
-                const sr = FunctionUtils.executeReturn({ script: it.script, context: this, args: helperHostSet });
-                actionExpression.replace(it, sr);
-              } catch (e) {
-                console.error(`[SWC] Failed to execute connectedInnerHTML:`, e);
-              }
+              actionExpression.replace(it, NodeSlot.slot(`${this._swcId}-${it.script}`));
             });
             res = actionExpression.getUnprocessedTemplate();
             if (res !== void 0) {
@@ -8248,9 +9565,11 @@ var dooboostoreSimpleWebComponent = (() => {
           });
         });
         if (originalConnected) await originalConnected.apply(this);
-        const aMethods = findAllLifecycleMetadata(this, ON_AFTER_CONNECTED_METADATA_KEY);
+        const aMethods = getOnConnectedAfterMetadata(this).filter((it) => {
+          return useSsr ? !it.options.ssrFirst : true;
+        });
         if (aMethods) {
-          for (const m of aMethods) await this._invokeLifecycleMethod(m, helperHostSet);
+          for (const m of aMethods) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
         }
         this._executeSwcScript("swc-on-connected", helperHostSet);
         this._executeSwcScript("swc-on-after-connected", helperHostSet);
@@ -8266,6 +9585,9 @@ var dooboostoreSimpleWebComponent = (() => {
           }
         }
       } finally {
+        for (let mPropertyKey of findAllLifecycleMetadata(this, ON_CONNECTED_COMPLETED_METADATA_KEY)) {
+          await this._invokeLifecycleMethod(mPropertyKey, helperHostSet);
+        }
         if (appHost && typeof appHost._connectedDone === "function") {
           await appHost._connectedDone(this);
         }
@@ -8273,7 +9595,6 @@ var dooboostoreSimpleWebComponent = (() => {
     };
     const originalDisconnected = proto.disconnectedCallback;
     proto.disconnectedCallback = function() {
-      console.log("disconnnnnnnnnnnnnnnnnnn", helperHostSet, this);
       const appHost = helperHostSet.$appHost;
       if (appHost && typeof appHost._disconnected === "function") {
         appHost._disconnected(this);
@@ -8535,8 +9856,9 @@ var dooboostoreSimpleWebComponent = (() => {
       return doc.createTextNode(it !== void 0 && it !== null ? String(it) : "");
     });
   };
-  var applyToDom = (targetEl, res, pos, doc) => {
+  var applyToDom = (targetEl, res, pos, win) => {
     if (!targetEl) return;
+    const doc = win.document;
     if (pos === "innerHtml") {
       targetEl.innerHTML = res !== void 0 && res !== null ? String(res) : "";
       return;
@@ -8547,7 +9869,7 @@ var dooboostoreSimpleWebComponent = (() => {
       }
       return;
     }
-    const isShadowRoot = targetEl instanceof ShadowRoot;
+    const isShadowRoot = targetEl instanceof win.ShadowRoot;
     const nodes = normalizeNodes(res, doc);
     if (pos === "replace") {
       if (!isShadowRoot) targetEl.replaceWith(...nodes);
@@ -8600,7 +9922,7 @@ var dooboostoreSimpleWebComponent = (() => {
         const runApply = (target, val) => {
           const pos = options.position || "beforeEnd";
           if (!options.filter || options.filter(target, val, { currentThis: this, helper: hostSet })) {
-            applyToDom(target, val, pos, currentDoc);
+            applyToDom(target, val, pos, currentWin);
           }
         };
         if (res instanceof Promise) {
@@ -8634,23 +9956,23 @@ var dooboostoreSimpleWebComponent = (() => {
     const opt = targetOrOptions || {};
     return applyNode("$this", { position: "beforeEnd", ...opt });
   }
-  function applyReplaceChildrenNodeThis(targetOrOptions, propertyKey, descriptor) {
+  function applyNodeThisReplaceChildren(targetOrOptions, propertyKey, descriptor) {
     if (propertyKey !== void 0) return applyNode("$this", { position: "replaceChildren" })(targetOrOptions, propertyKey, descriptor);
     const opt = targetOrOptions || {};
     return applyNode("$this", { position: "replaceChildren", ...opt });
   }
-  function applyInnerHtmlNodeThis(targetOrOptions, propertyKey, descriptor) {
+  function applyThisInnerHtmlNode(targetOrOptions, propertyKey, descriptor) {
     if (propertyKey !== void 0) return applyNode("$this", { position: "innerHtml" })(targetOrOptions, propertyKey, descriptor);
     const opt = targetOrOptions || {};
     return applyNode("$this", { position: "innerHtml", ...opt });
   }
-  function applyReplaceChildrenNode(selector, options = {}) {
+  function applyNodeReplaceChildren(selector, options = {}) {
     return applyNode(selector, { ...options, position: "replaceChildren" });
   }
-  function applyInnerHtmlNode(selector, options = {}) {
+  function applyNodeInnerHtml(selector, options = {}) {
     return applyNode(selector, { ...options, position: "innerHtml" });
   }
-  function applyInnerTextNode(selector, options = {}) {
+  function applyNodeInnerText(selector, options = {}) {
     return applyNode(selector, { ...options, position: "innerText" });
   }
 
@@ -9122,57 +10444,2505 @@ var dooboostoreSimpleWebComponent = (() => {
     return ReflectUtils.getOwnMetadata(PUBLISH_SWC_APP_MESSAGE_METADATA_KEY, constructor);
   };
 
+  // ../simple-boot/dist/esm/index.js
+  var import_reflect_metadata = __toESM(require_Reflect(), 1);
+
+  // ../simple-boot/dist/esm/throwable/SimError.js
+  var SimError = class {
+    constructor(message, name, stack) {
+      this.message = message;
+      this.name = name;
+      this.stack = stack;
+    }
+  };
+
+  // ../simple-boot/dist/esm/throwable/SimNoSuch.js
+  var SimNoSuch = class extends SimError {
+    constructor(message, name, stack) {
+      super(message, name, stack);
+    }
+  };
+
   // ../simple-boot/dist/esm/decorators/SimDecorator.js
+  var Lifecycle = /* @__PURE__ */ ((Lifecycle2) => {
+    Lifecycle2["Singleton"] = "Singleton";
+    Lifecycle2["Transient"] = "Transient";
+    return Lifecycle2;
+  })(Lifecycle || {});
+  var sims = /* @__PURE__ */ new Map();
+  var containers = /* @__PURE__ */ new Set();
   var SimMetadataKey = Symbol.for("simple-boot:sim-metadata");
+  var isNotNullObjetInstance = (target) => target != null && target !== void 0 && typeof target === "object";
+  var simProcess = (config, inputTarget) => {
+    const target = (() => {
+      if (typeof inputTarget === "object") {
+        return config.scope === "Singleton" ? inputTarget : ValidUtils.isPlainObject(inputTarget) ? { ...inputTarget } : inputTarget;
+      }
+      if (ValidUtils.isArrowFunction(inputTarget)) {
+        return () => inputTarget();
+      }
+      return inputTarget;
+    })();
+    let targetType;
+    if (isNotNullObjetInstance(target)) {
+      targetType = target.constructor;
+    } else {
+      targetType = target;
+    }
+    config.scope = config?.scope ?? "Singleton";
+    ReflectUtils.defineMetadata(SimMetadataKey, config, targetType);
+    const adding = (targetKey, target2 = targetKey) => {
+      const items = sims.get(targetKey) ?? /* @__PURE__ */ new Set();
+      items.add(target2);
+      sims.set(targetKey, items);
+    };
+    if (Array.isArray(config?.type)) {
+      config?.type.forEach((it) => {
+        adding(it, target);
+      });
+    } else if (config.type) {
+      adding(config?.type, target);
+    } else {
+      adding(target);
+    }
+  };
+  function Sim(configOrTarget) {
+    if (typeof configOrTarget === "symbol") {
+      return (target) => {
+        simProcess({ symbol: configOrTarget }, target);
+      };
+    } else if (typeof configOrTarget === "function") {
+      simProcess({}, configOrTarget);
+    } else {
+      return (target) => {
+        simProcess(configOrTarget, target);
+      };
+    }
+  }
+  var getSim = (target) => {
+    if (target != null && target !== void 0 && typeof target === "object") {
+      target = Object.getPrototypeOf(target).constructor;
+    }
+    try {
+      return ReflectUtils.getMetadata(SimMetadataKey, target);
+    } catch (e) {
+    }
+  };
   var PostConstructMetadataKey = Symbol.for("simple-boot:post-construct-metadata");
+  var getPostConstructs = (target) => {
+    return ReflectUtils.getMetadata(PostConstructMetadataKey, target) ?? [];
+  };
+
+  // ../simple-boot/dist/esm/simstance/SimAtomic.js
+  var SimAtomic = class {
+    constructor(type, simstanceManager, config) {
+      this.type = type;
+      this.simstanceManager = simstanceManager;
+      this.config = config;
+      this.value = type.value;
+    }
+    getConfig(key = SimMetadataKey) {
+      return ReflectUtils.getMetadata(key, this.type.originalType);
+    }
+    getConfigs() {
+      return ReflectUtils.getMetadatas(this.type.originalType);
+    }
+    getValue(config) {
+      if (config?.refresh) {
+        this.value = void 0;
+      }
+      if (!this.value) {
+        if (typeof this.type.targetKeyType === "symbol") {
+          this.value = this.simstanceManager.findFirstSim(this.type.targetKeyType)?.getValue();
+        } else {
+          this.value = this.simstanceManager.getOrNewSim({ target: this.type.targetKeyType, originTypeTarget: this.type.originalType, newInstanceCarrier: config?.newInstanceCarrier });
+        }
+      }
+      return this.value;
+    }
+  };
+
+  // ../simple-boot/dist/esm/SimOption.js
+  var SimOption = class {
+    constructor({ rootRouter, container, cache, advice = [], excludeProxys, proxy, using } = {}) {
+      this.rootRouter = rootRouter;
+      this.container = container;
+      this.advice = advice;
+      this.excludeProxys = excludeProxys;
+      this.proxy = proxy;
+      this.using = using;
+      this.cache = cache;
+    }
+    addAdvicce(advice) {
+      this.advice ?? (this.advice = []);
+      this.advice.push(advice);
+    }
+    setAdvice(...advice) {
+      this.advice = advice;
+      return this;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/MetaDataAtomic.js
+  var MetaDataAtomic = class {
+    constructor(target, metaData) {
+      this.target = target;
+      this.metaData = metaData;
+    }
+  };
+  var MetaDataPropertyAtomic = class extends MetaDataAtomic {
+    constructor(target, metaData, property, parameter) {
+      super(target, metaData);
+      this.property = property;
+      this.parameter = parameter;
+    }
+    call(...parameter) {
+      return this.target[this.property](...parameter);
+    }
+  };
 
   // ../simple-boot/dist/esm/decorators/aop/AOPDecorator.js
   var AfterMetadataKey = Symbol.for("simple-boot:after-metadata");
   var BeforeMetadataKey = Symbol.for("simple-boot:before-metadata");
   var AroundMetadataKey = Symbol.for("simple-boot:around-metadata");
+  var getAfter = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(AfterMetadataKey, target, propertyKey);
+  };
+  var getAfters = (target) => {
+    return ObjectUtils.allProtoTypeName(target).map((it) => new MetaDataPropertyAtomic(target, getAfter(target, it), it)).filter((it) => it.metaData !== void 0) || [];
+  };
+  var getProtoAfters = (target, propertyKey, type) => {
+    return getAfters(target).filter((it) => propertyKey === it.metaData?.property && type === it.metaData.type?.prototype) || [];
+  };
+  var getBefore = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(BeforeMetadataKey, target, propertyKey);
+  };
+  var getBefores = (target) => {
+    return ObjectUtils.allProtoTypeName(target).map((it) => new MetaDataPropertyAtomic(target, getBefore(target, it), it)).filter((it) => it.metaData !== void 0) || [];
+  };
+  var getProtoBefores = (target, propertyKey, type) => {
+    return getBefores(target).filter((it) => propertyKey === it.metaData?.property && type === it.metaData.type?.prototype) || [];
+  };
 
   // ../simple-boot/dist/esm/decorators/exception/ExceptionDecorator.js
+  var ExceptionHandlerSituationType = /* @__PURE__ */ ((ExceptionHandlerSituationType2) => {
+    ExceptionHandlerSituationType2["ERROR_OBJECT"] = "SIMPLE_BOOT_CORE://ExceptionHandler/ERROR_OBJECT";
+    ExceptionHandlerSituationType2["PARAMETER"] = "SIMPLE_BOOT_CORE://ExceptionHandler/PARAMETER";
+    return ExceptionHandlerSituationType2;
+  })(ExceptionHandlerSituationType || {});
   var ExceptionHandlerMetadataKey = Symbol.for("simple-boot:exception-handler-metadata");
+  var getExceptionHandlers = (target) => {
+    if (target !== null && void 0 !== target && typeof target === "object") {
+      target = target.constructor;
+    }
+    return ReflectUtils.getMetadata(ExceptionHandlerMetadataKey, target);
+  };
+  var targetExceptionHandlers = (target, error) => {
+    const exceptionHandlers = getExceptionHandlers(target);
+    const emptyTargets = exceptionHandlers?.filter((it) => it.config.type === void 0);
+    const targets = exceptionHandlers?.filter((it) => ObjectUtils.isPrototypeOfTarget(it.config.type, error));
+    const targetSorts = targets?.sort((a, b) => {
+      const aPrototypeOfDepth = ObjectUtils.prototypeOfDepth(error, a.config.type);
+      const bPrototypeOfDepth = ObjectUtils.prototypeOfDepth(error, b.config.type);
+      return aPrototypeOfDepth.length - bPrototypeOfDepth.length;
+    });
+    return (targetSorts ?? []).concat(...emptyTargets ?? []);
+  };
+  var targetExceptionHandler = (target, error, excludeMethods = []) => {
+    let exceptionHandlers = targetExceptionHandlers(target, error);
+    exceptionHandlers = exceptionHandlers?.filter((it) => !excludeMethods.includes(it.method));
+    if (exceptionHandlers && exceptionHandlers.length > 0) {
+      return exceptionHandlers[0];
+    } else {
+      return void 0;
+    }
+  };
 
-  // ../simple-boot/dist/esm/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");
-
-  // ../simple-boot/dist/esm/decorators/route/Router.js
-  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;
-  ((RouterAction2) => {
-    RouterAction2.isCanActivate = (obj) => {
-      return typeof obj?.canActivate === "function";
-    };
-    RouterAction2.isOnRouting = (obj) => {
-      return typeof obj?.onRouting === "function";
-    };
-    RouterAction2.isHasActivate = (obj) => {
-      return typeof obj?.hasActivate === "function";
-    };
-  })(RouterAction || (RouterAction = {}));
-
-  // ../simple-boot/dist/esm/decorators/cache/CacheDecorator.js
-  var CacheMetadataKey = Symbol.for("simple-boot:cache-metadata");
-
-  // ../simple-boot/dist/esm/fetch/ApiService.js
-  var ApiServiceInterceptor;
-  ((ApiServiceInterceptor2) => {
-    ApiServiceInterceptor2.TOKEN = Symbol.for("simple-boot:api-service-interceptor-token");
-    ApiServiceInterceptor2.resolveAll = (simstanceManager) => {
+  // ../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 {
-        return (simstanceManager.findSims(ApiServiceInterceptor2.TOKEN) ?? []).map((it) => it.getValue()).filter(ValidUtils.isDefined);
+        this.aopBefore(thisArg, target);
+        try {
+          r = Reflect.apply(target, thisArg, argumentsList);
+        } catch (e) {
+          throw e;
+        } finally {
+          this.aopAfter(thisArg, target);
+        }
       } catch (e) {
-        return [];
+        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;
+        }
       }
-    };
-  })(ApiServiceInterceptor || (ApiServiceInterceptor = {}));
+      return r;
+    }
+    executeExceptionHandler(e, inHandler, argumentsList) {
+      const otherStorage = /* @__PURE__ */ new Map();
+      otherStorage.set(e.constructor, e);
+      const situationErrorTypeContainer = new SituationTypeContainer({
+        situationType: ExceptionHandlerSituationType.ERROR_OBJECT,
+        data: e
+      });
+      const situationParameterTypeContainer = new SituationTypeContainer({
+        situationType: ExceptionHandlerSituationType.PARAMETER,
+        data: argumentsList
+      });
+      otherStorage.set(SituationTypeContainers, new SituationTypeContainers([situationErrorTypeContainer, situationParameterTypeContainer]));
+      argumentsList?.forEach((it) => {
+        otherStorage.set(it.constructor, it);
+      });
+      try {
+        this.simstanceManager.executeBindParameterSim(
+          {
+            target: inHandler.thisArg,
+            targetKey: inHandler.config.propertyKey
+          },
+          otherStorage
+        );
+      } catch (es) {
+        e = es;
+      }
+      if (inHandler.config.config.throw) {
+        const exceptionHandler = this.getExceptionHandler(e, inHandler.thisArg, inHandler.config.method);
+        if ((exceptionHandler?.length ?? 0) > 0) {
+          this.executeExceptionHandler(e, exceptionHandler[0], argumentsList);
+        }
+      }
+    }
+    getExceptionHandler(e, thisArg, target) {
+      const globalConfigSets = this.simOption.advice.map((it) => this.simstanceManager?.getOrNewSim({ target: it })).filter((it) => it).map((it) => {
+        return { thisArg: it, config: targetExceptionHandler(it, e, [target]) };
+      }) ?? [];
+      const thisConfigSet = { thisArg, config: targetExceptionHandler(thisArg, e, [target]) };
+      const inHandlers = [thisConfigSet, ...globalConfigSets].filter((it) => it && it.config);
+      return inHandlers;
+    }
+    aopBefore(obj, protoType) {
+      const propertyName = ObjectUtils.prototypeName(obj, protoType);
+      if (propertyName && obj) {
+        getProtoBefores(obj, propertyName).forEach((it) => {
+          it.call(obj, protoType, propertyName);
+        });
+        for (let i = 0; i < this.simOption.advice.length; i++) {
+          const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
+          const protoBefores = getProtoBefores(sim, propertyName, Object.getPrototypeOf(obj));
+          protoBefores.forEach((it) => {
+            it.call(obj, protoType, propertyName);
+          });
+        }
+      }
+    }
+    aopAfter(obj, protoType) {
+      const propertyName = ObjectUtils.prototypeName(obj, protoType);
+      if (propertyName) {
+        getProtoAfters(obj, propertyName).forEach((it) => {
+          it.call(obj, protoType, propertyName);
+        });
+        for (let i = 0; i < this.simOption.advice.length; i++) {
+          const sim = this.simstanceManager?.getOrNewSim({ target: this.simOption.advice[i] });
+          const protoBefores = getProtoAfters(sim, propertyName, Object.getPrototypeOf(obj));
+          protoBefores.forEach((it) => {
+            it.call(obj, protoType, propertyName);
+          });
+        }
+      }
+    }
+    has(target, key) {
+      if (key === "_SimpleBoot_isProxy") {
+        return true;
+      }
+      return key in target;
+    }
+  };
+
+  // ../simple-boot/dist/esm/lifecycle/OnSimCreate.js
+  var isOnSimCreate = (obj) => {
+    return typeof obj?.onSimCreate === "function";
+  };
+
+  // ../simple-boot/dist/esm/lifecycle/OnSimCreateCompleted.js
+  var isOnSimCreateProxyCompleted = (obj) => {
+    return typeof obj?.onSimCreateProxyCompleted === "function";
+  };
+
+  // ../simple-boot/dist/esm/decorators/SimNoProxy.js
+  var SimNoProxyKey = Symbol.for("simple-boot:sim-no-proxy-metadata");
+  var getSimNoProxy = (target, propertyKey) => {
+    try {
+      if (propertyKey === void 0) {
+        return Reflect.getMetadata(SimNoProxyKey, target);
+      }
+      return Reflect.getMetadata(SimNoProxyKey, target, propertyKey);
+    } catch (e) {
+      return void 0;
+    }
+  };
+  var isSimNoProxy = (target, propertyKey) => {
+    if (target === null || target === void 0) {
+      return false;
+    }
+    return getSimNoProxy(target, propertyKey) === true;
+  };
+
+  // ../simple-boot/dist/esm/simstance/SimstanceManager.js
+  var SimstanceManager = class _SimstanceManager {
+    // private otherInstanceSim?: Map<ConstructorType<any> | Function, any>;
+    constructor(simpleApplication, option) {
+      this.simpleApplication = simpleApplication;
+      this.option = option;
+      this._storage = /* @__PURE__ */ new Map();
+      this.name = "simstanceManager-" + RandomUtils.uuid4();
+      this.setStoreSet(SimpleApplication, this.simpleApplication);
+      this.setStoreSet(_SimstanceManager, this);
+      this.setStoreSet(option.constructor, option);
+      this.setStoreSet(SimOption, option);
+      this.simProxyHandler = new SimProxyHandler(this.simpleApplication, this, option);
+    }
+    get storage() {
+      return this._storage;
+    }
+    getSimAtomics() {
+      const r = [];
+      Array.from(this.storage.entries()).forEach(([targetKeyType, targetMap]) => {
+        r.push(
+          ...Array.from(Array.from(targetMap.keys())).map(
+            (sit) => new SimAtomic(
+              {
+                targetKeyType,
+                originalType: sit
+              },
+              this
+            )
+          )
+        );
+      });
+      return r;
+    }
+    getSimConfig(schemeOrSymbol) {
+      const newVar = this.getSimAtomics().filter((it) => {
+        const config = it?.getConfig();
+        const symbols = ConvertUtils.flatArray(config?.symbol);
+        const schemes = ConvertUtils.flatArray(config?.scheme);
+        if (typeof schemeOrSymbol === "symbol") {
+          return schemeOrSymbol && it && symbols.includes(schemeOrSymbol);
+        } else if (typeof schemeOrSymbol === "string") {
+          return schemeOrSymbol && it && schemes.includes(schemeOrSymbol);
+        } else {
+          return false;
+        }
+      }) || [];
+      return newVar;
+    }
+    findSims(data) {
+      let r = [];
+      if (data) {
+        const simAtomics = this.getSimAtomics();
+        r = simAtomics.filter((it) => {
+          let b = false;
+          const config = it.getConfig();
+          const symbols = ConvertUtils.flatArray(config?.symbol).filter(ValidUtils.isDefined);
+          const schemes = ConvertUtils.flatArray(config?.scheme).filter(ValidUtils.isDefined);
+          if (typeof data === "symbol") {
+            b = symbols.includes(data);
+          } else {
+            const { scheme, type } = data;
+            b = (scheme ? schemes.includes(scheme) : true) && (type ? it.type.targetKeyType === type : true);
+          }
+          return b;
+        });
+      }
+      return r;
+    }
+    findFirstSim(data) {
+      if (typeof data === "symbol") {
+        return this.findSims(data)[0];
+      } else {
+        return this.findSims(data)[0];
+      }
+    }
+    findLastSim(data) {
+      if (typeof data === "symbol") {
+        return this.findSims(data).reverse()[0];
+      } else {
+        return this.findSims(data).reverse()[0];
+      }
+    }
+    flatStoreSets() {
+      return new Map(
+        Array.from(this.storage.values()).map((it) => Array.from(it.entries())).flat()
+      );
+    }
+    getStoreSets(targetKey) {
+      const map = this.storage.get(targetKey);
+      const datas = (Array.from(map?.entries?.() ?? []) ?? []).reverse();
+      return datas.map((it) => ({ type: it[0], instance: it[1] }));
+    }
+    getStoreSet(targetKey, target) {
+      const sets = this.getStoreSets(targetKey);
+      let find = sets.find((it) => it.type === target);
+      if (!find && (!target || target === targetKey)) {
+        find = sets.find((it) => it.instance);
+      }
+      if (!find?.instance) {
+        const type = target ?? targetKey;
+        if (typeof type === "object") {
+          const find2 = this.storage.get(type);
+          if (find2) {
+            return { type, instance: type };
+          }
+        }
+        const flatStoreSets = this.flatStoreSets();
+        const data = flatStoreSets.get(type);
+        if (data) {
+          this.setStoreSet(targetKey, data, type);
+        }
+        return { type, instance: data };
+      } else {
+        return find;
+      }
+    }
+    getStoreInstance(targetKey, target) {
+      return this.getStoreSet(targetKey, target)?.instance;
+    }
+    getOrNewSim({ target, originTypeTarget = target, newInstanceCarrier }) {
+      if (target) {
+        const registed = this.getStoreSet(target, originTypeTarget);
+        if (registed?.type && !registed?.instance) {
+          return this.resolve({
+            targetKey: target,
+            target: originTypeTarget,
+            newInstanceCarrier
+          });
+        }
+        return registed?.instance;
+      }
+    }
+    setStoreSet(targetKey, obj, target = targetKey) {
+      const itemMap = this.storage.get(targetKey) ?? /* @__PURE__ */ new Map();
+      itemMap.set(target, obj);
+      this.storage.set(targetKey, itemMap);
+    }
+    registerStore(targetKey, regTyps) {
+      const itemMap = this.storage.get(targetKey) ?? /* @__PURE__ */ new Map();
+      regTyps.forEach((it) => {
+        const { type, value } = typeof it === "object" ? { type: it.constructor, value: it } : { type: it, value: void 0 };
+        if (!itemMap.has(type) || value !== void 0 && itemMap.get(type) === void 0) {
+          itemMap.set(type, value);
+        }
+      });
+      this.storage.set(targetKey, itemMap);
+    }
+    // 진입점
+    resolve({ target, targetKey, newInstanceCarrier = { newInstances: [], depth: 0 } }) {
+      const registed = this.getStoreSet(targetKey, target);
+      if (registed?.instance) {
+        return registed.instance;
+      }
+      if (this.storage.has(targetKey) && void 0 === registed?.instance) {
+        newInstanceCarrier.depth++;
+        const newSim = this.newSim({
+          target: registed?.type ?? targetKey,
+          newInstanceCarrier,
+          simCreateAfter: (data) => {
+            if (getSim(registed?.type ?? target ?? targetKey)?.scope === Lifecycle.Singleton) {
+              this.setStoreSet(targetKey, data, target);
+            }
+          }
+        });
+        newInstanceCarrier.depth--;
+        if (newInstanceCarrier.depth === 0) {
+          newInstanceCarrier.newInstances.forEach((it) => {
+            this.callBindPostConstruct(it);
+          });
+        }
+        if (isOnSimCreate(newSim)) {
+          newSim.onSimCreate();
+        }
+        return newSim;
+      }
+      const simNoSuch = new SimNoSuch("SimNoSuch: no simple instance(resolve) name:" + targetKey?.prototype?.constructor?.name + "," + targetKey);
+      console.error(simNoSuch);
+      throw simNoSuch;
+    }
+    newSim({ target, simCreateAfter, otherStorage, newInstanceCarrier }) {
+      const parameters = this.getParameterSim({
+        target,
+        otherStorage,
+        newInstanceCarrier
+      });
+      const r = ValidUtils.isFunction(target) && !target.prototype ? target(...parameters) : new target(...parameters);
+      let p = this.proxy(r);
+      const config = getSim(target);
+      if (config?.proxy) {
+        const proxys = (Array.isArray(config.proxy) ? config.proxy : [config.proxy]).filter(ValidUtils.isDefined);
+        proxys.forEach((it) => {
+          if (typeof it === "object") {
+            p = new Proxy(p, it);
+          } else {
+            const simConfig = getSim(it);
+            p = new Proxy(p, simConfig ? this.getOrNewSim({ target: it }) : this.newSim({ target: it }));
+          }
+        });
+      }
+      newInstanceCarrier?.newInstances.push(p);
+      simCreateAfter?.(p);
+      if (isOnSimCreateProxyCompleted(p)) {
+        p.onSimCreateProxyCompleted(p);
+      }
+      return p;
+    }
+    callBindPostConstruct(obj) {
+      const postConstruct = getPostConstructs(obj);
+      postConstruct.forEach((it) => {
+        obj[it.property](...this.getParameterSim({ target: obj, targetKey: it.property }));
+      });
+    }
+    async executeBindParameterSimPromise({ target, targetKey, firstCheckMaker, parameterCount, inputParameters }, otherStorage) {
+      const binds = this.getParameterSim({ target, targetKey, firstCheckMaker, otherStorage, parameterCount, inputParameters });
+      const resolvedBinds = await Promise.all(binds);
+      if (typeof target === "object" && targetKey) {
+        const targetMethod = target[targetKey];
+        return targetMethod?.bind(target)?.(...resolvedBinds);
+      } else if (typeof target === "function" && !targetKey) {
+        return new target(...resolvedBinds);
+      }
+    }
+    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);
+      injections = [];
+      for (let idx = 0; idx < loopCount; idx++) {
+        const token = paramTypes[idx];
+        const saveInject = injects?.find((it) => it.index === idx);
+        let isFirstChecked = false;
+        for (const f of firstCheckMaker ?? []) {
+          const firstCheckObj = f({ target, targetKey }, token, idx, saveInject);
+          if (void 0 !== firstCheckObj) {
+            injections.push(firstCheckObj);
+            isFirstChecked = true;
+            break;
+          }
+        }
+        if (isFirstChecked) continue;
+        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 })));
+            }
+            injections.push(p);
+            continue;
+          }
+          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)) {
+              const combinedParameters = injections.length > 0 ? injections : inputParameters;
+              obj = inject.factory({
+                instance: currentInstance,
+                methodName: String(targetKey),
+                parameter: combinedParameters,
+                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") {
+                    const combinedParameters = injections.length > 0 ? injections : inputParameters;
+                    obj = inject.factory({
+                      instance: currentInstance,
+                      methodName: String(targetKey),
+                      parameter: combinedParameters,
+                      application: this.simpleApplication,
+                      injectInstance: obj
+                    });
+                  }
+                }
+              } catch (e) {
+                if (inject.optional) {
+                  injections.push(void 0);
+                  continue;
+                } 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);
+              }
+            }
+          }
+          injections.push(obj);
+        } else {
+          const obj = otherStorage?.get(token) ?? (token ? this.resolve({ targetKey: token, newInstanceCarrier }) : void 0);
+          injections.push(obj);
+        }
+      }
+      return injections;
+    }
+    proxy(target) {
+      try {
+        const noProxy = isSimNoProxy(target);
+        const isExcludeProxy = this.option.excludeProxys?.some((it) => target instanceof it);
+        if (!noProxy && !isExcludeProxy && target !== null && getSim(target) && typeof target === "object" && !("_SimpleBoot_isProxy" in target)) {
+          for (const key in target) {
+            if (!isSimNoProxy(target, key)) {
+              target[key] = this.proxy(target[key]);
+            }
+          }
+          const protoTypeName = ObjectUtils.ownPropertyNames(target);
+          protoTypeName.filter((it) => typeof target[it] === "function").filter((it) => !isSimNoProxy(target, it)).filter((it) => !("_SimpleBoot_isProxy" in target[it])).forEach((it) => {
+            target[it] = new Proxy(target[it], this.simProxyHandler);
+          });
+          if (this.simProxyHandler) {
+            target = new Proxy(target, this.simProxyHandler);
+          }
+        }
+        if (this.option.proxy) {
+          target = this.option.proxy.onAfterProxy(target);
+        }
+        return target;
+      } catch (e) {
+        console.log("sim proxy error");
+        throw e;
+      }
+    }
+    run(otherInstanceSim = /* @__PURE__ */ new Map()) {
+      for (const [k, v] of Array.from(otherInstanceSim.entries())) {
+        const storageKey = typeof k === "object" && k !== null && "type" in k ? k.type : k;
+        this.registerStore(storageKey, /* @__PURE__ */ new Set([v]));
+        if (typeof k === "object" && k !== null && "symbol" in k && k.symbol) {
+          this.registerStore(k.symbol, /* @__PURE__ */ new Set([v]));
+        }
+      }
+      const myContainers = ConvertUtils.flatArray(this.option.container).filter(ValidUtils.isDefined);
+      if (!myContainers.includes(this.simpleApplication)) {
+        myContainers.push(this.simpleApplication);
+      }
+      Array.from(sims.entries()).forEach(([type, implementations]) => {
+        const filteredSet = /* @__PURE__ */ new Set();
+        implementations.forEach((impl) => {
+          const config = getSim(impl);
+          const targetContainers = ConvertUtils.flatArray(config?.container).filter(ValidUtils.isDefined);
+          let isInclude = false;
+          if (targetContainers.length <= 0) {
+            if (myContainers.length === 1 && myContainers[0] === this.simpleApplication) {
+              isInclude = true;
+            }
+          } else {
+            isInclude = myContainers.some((it) => targetContainers.includes(it));
+          }
+          if (isInclude) {
+            filteredSet.add(impl);
+          }
+        });
+        if (filteredSet.size > 0) {
+          this.registerStore(type, filteredSet);
+        }
+      });
+      this.callBindPostConstruct(this);
+      this.getSimAtomics().forEach((it) => {
+        if (it.getConfig()?.autoCreate) {
+          it.getValue();
+        }
+      });
+    }
+  };
+
+  // ../simple-boot/dist/esm/intent/Intent.js
+  var Intent = class {
+    constructor(uri, data) {
+      this.uri = uri;
+      this.data = data;
+      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" && "symbol" in this.uri) {
+        return Array.isArray(this.uri.symbol) ? this.uri.symbol : [this.uri.symbol];
+      }
+      return void 0;
+    }
+    get types() {
+      if (typeof this.uri === "object" && "type" in this.uri) {
+        return this.uri.type;
+      }
+      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() {
+      if (typeof this.uri === "object" && "type" in this.uri && "target" in this.uri) {
+        return [String(this.uri.target)];
+      }
+      return this.pathname.split("/") ?? [];
+    }
+    get fullPath() {
+      if (typeof this.uri === "object" && "type" in this.uri && "target" in this.uri) {
+        return `/${String(this.uri.target)}`;
+      }
+      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 isTypePublishType = (it) => typeof it === "object" && it !== null && "type" in it && "target" 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 (isTypePublishType(it)) {
+        it = new Intent({ type: it.type, target: it.target }, 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.types) {
+          target.push(...this.simstanceManager.findSims({ type: intent.types }));
+        } else 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: String(lastProp),
+                parameterCount: intentData.length,
+                inputParameters: intentData,
+                firstCheckMaker: [
+                  (obj, token, idx) => {
+                    if (idx < intentData.length) {
+                      return intentData[idx];
+                    }
+                    if (token === Intent && idx === 0) {
+                      return intent;
+                    }
+                  }
+                ]
+              });
+              r.push(result);
+            } else if (orNewSim) {
+              callthis[lastProp] = intent.data;
+              r.push(callthis[lastProp]);
+            }
+          } else {
+            const intentData = Array.isArray(intent.data) ? intent.data : intent.data !== void 0 ? [intent.data] : [];
+            if (isIntentSubscribe(orNewSim)) {
+              r.push(orNewSim.intentSubscribe(...intentData));
+            }
+          }
+        }
+      }
+      return { return: r, target };
+    }
+    async publish(it, data) {
+      const rdata = await this.publishMeta(it, data);
+      return rdata.return;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/inject/Injection.js
+  var InjectionMetadataKey = Symbol("Injection");
+  var getInjection = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(InjectionMetadataKey, target, propertyKey);
+  };
+
+  // ../simple-boot/dist/esm/throwable/MethodNoSuch.js
+  var MethodNoSuch = class extends SimError {
+    constructor(message, name, propertyKeys, stack) {
+      super(message, name, stack);
+      this.propertyKeys = propertyKeys;
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/route/Router.js
+  var RouterMetadataKey = Symbol.for("simple-boot:router-metadata");
+  var getRouter = (target) => {
+    if (target != null && typeof target === "object") {
+      target = target.constructor;
+    }
+    try {
+      return ReflectUtils.getMetadata(RouterMetadataKey, target);
+    } catch (e) {
+    }
+  };
+  var RouteMetadataKey = Symbol.for("simple-boot:route-metadata");
+
+  // ../simple-boot/dist/esm/route/RouterModule.js
+  var RouterModule = class {
+    constructor(simstanceManager, router, module, routerChains = []) {
+      this.simstanceManager = simstanceManager;
+      this.router = router;
+      this.module = module;
+      this.routerChains = routerChains;
+    }
+    get path() {
+      return this._path;
+    }
+    set path(value) {
+      this._path = value;
+    }
+    get data() {
+      return this._data;
+    }
+    set data(value) {
+      this._data = value;
+    }
+    get intent() {
+      return this._intent;
+    }
+    set intent(value) {
+      this._intent = value;
+    }
+    get propertyKeys() {
+      return this._propertyKeys;
+    }
+    set propertyKeys(value) {
+      this._propertyKeys = value;
+    }
+    get pathData() {
+      return this._pathData;
+    }
+    getPathData() {
+      return this._pathData;
+    }
+    set pathData(value) {
+      this._pathData = value;
+    }
+    getRouterPath(join = "") {
+      return this.getRouterPaths().map((it) => it ?? "").join(join);
+    }
+    getRouterPaths() {
+      return this.routerChains.map((it) => getRouter(it instanceof SimAtomic ? it.type.targetKeyType : it)?.path);
+    }
+    getRouterPathData(pathName) {
+      return Expression.Path.pathNameData(pathName, this.getRouterPath());
+    }
+    getModuleInstance(propertyKey, instanceBind = true) {
+      const instance = this.simstanceManager.getOrNewSim({ target: this.module?.targetKeyType, originTypeTarget: this.module?.originalType });
+      if (propertyKey && this.propertyKeys && this.propertyKeys.includes(propertyKey)) {
+        let instanceElement = instance[propertyKey];
+        if (instanceBind && typeof instanceBind === "boolean") {
+          instanceElement = instanceElement.bind(instance);
+        } else if (instanceBind && typeof instanceBind === "object") {
+          instanceElement = instanceElement.bind(instanceBind);
+        }
+        return instanceElement;
+      } else {
+        return instance;
+      }
+    }
+    executeModuleProperty(propertyKey, ...param) {
+      const target = this.getModuleInstance();
+      if (propertyKey) {
+        const config = getInjection(target, propertyKey);
+        if (config) {
+          const other = /* @__PURE__ */ new Map();
+          param.forEach((it) => other.set(it.constructor, it));
+          return this.simstanceManager.executeBindParameterSim({ target, targetKey: propertyKey }, other);
+        } else {
+          if (target[propertyKey]) {
+            return target[propertyKey]?.(...param);
+          } else {
+            throw new MethodNoSuch(`${propertyKey.toString()} noSuch`, propertyKey.toString(), propertyKey);
+          }
+        }
+      }
+    }
+    get firstRouteChain() {
+      return this.routerChains[0];
+    }
+    get firstRouteChainValue() {
+      return this.firstRouteChain?.getValue();
+    }
+    get lastRouteChain() {
+      return this.routerChains[this.routerChains.length - 1];
+    }
+    get lastRouteChainValue() {
+      return this.lastRouteChain?.getValue();
+    }
+    hasActivateInLastRoute(obj) {
+      return this.lastRouteChainValue?.hasActivate(obj) === true;
+    }
+    getQueryParamDecodeURI(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamDecodeURI(key);
+      }
+    }
+    getQueryParamDecodeURIFirst(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamDecodeURIFirst(key);
+      }
+    }
+    getQueryParam(key) {
+      if (this.intent) {
+        return this.intent.getQueryParam(key);
+      }
+    }
+    getQueryParamFirst(key) {
+      if (this.intent) {
+        return this.intent.getQueryParamFirst(key);
+      }
+    }
+    get queryParams() {
+      if (this.intent) {
+        return this.intent.queryParams;
+      }
+    }
+    get queryParamsAfterDecodeURI() {
+      if (this.intent) {
+        return this.intent.queryParamsDecodeURI;
+      }
+    }
+  };
+
+  // ../simple-boot/dist/esm/route/RouterAction.js
+  var RouterAction;
+  ((RouterAction2) => {
+    RouterAction2.isCanActivate = (obj) => {
+      return typeof obj?.canActivate === "function";
+    };
+    RouterAction2.isOnRouting = (obj) => {
+      return typeof obj?.onRouting === "function";
+    };
+    RouterAction2.isHasActivate = (obj) => {
+      return typeof obj?.hasActivate === "function";
+    };
+  })(RouterAction || (RouterAction = {}));
+
+  // ../simple-boot/dist/esm/route/RouterManager.js
+  var RouterManager = class {
+    constructor(simpleApplication, simstanceManager, simOption) {
+      this.simpleApplication = simpleApplication;
+      this.simstanceManager = simstanceManager;
+      this.simOption = simOption;
+      this.subject = new Subject();
+    }
+    // @SimNoProxy
+    get observable() {
+      return this.subject.asObservable();
+    }
+    routingMap(option) {
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      if (!targetRouter) {
+        throw new Error("no router");
+      }
+      const map = {};
+      if (targetRouter) {
+        const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+        const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+        const routerAtomic = new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+        const routerData = routerAtomic.getConfig(RouterMetadataKey);
+        if (routerData) {
+          const currentPrefix = (option?.prefix ?? "") + routerData.path;
+          if (routerData.route && routerData.route[""]) {
+            map[currentPrefix] = routerData.route[""];
+          }
+          if (routerData.route) {
+            Object.entries(routerData.route).forEach(([key, value]) => {
+              map[currentPrefix + key] = value;
+            });
+          }
+          routerData.routers?.forEach((it) => {
+            Object.assign(map, this.routingMap({ ...option, router: it, prefix: currentPrefix }));
+          });
+        }
+      }
+      return map;
+    }
+    /** 일반적인 lifecycle 타지않는 그냥 find.. 의미가없을듯.
+     * @deprecated
+     */
+    async routings(intent, option) {
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      if (!targetRouter) {
+        throw new Error("no router");
+      }
+      const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+      const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+      const routerAtomic = new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+      const allMatches = this._collectAllMatchingModules(routerAtomic, intent, []);
+      const exactModuleMatches = allMatches.filter((rm) => rm.path === intent.pathname && rm.module);
+      if (exactModuleMatches.length > 0) {
+        exactModuleMatches.forEach((it) => this.subject.next({ intent, routerManager: this, routerModule: it }));
+        return exactModuleMatches;
+      }
+      const exactPathMatches = allMatches.filter((rm) => rm.path === intent.pathname);
+      if (exactPathMatches.length > 0) {
+        exactPathMatches.forEach((it) => this.subject.next({ intent, routerManager: this, routerModule: it }));
+        return exactPathMatches;
+      }
+      return [];
+    }
+    async routing(intent, option) {
+      if (typeof intent === "string") {
+        intent = new Intent(intent);
+      }
+      const targetRouter = option?.router ?? this.simOption.rootRouter;
+      const callCheckOnRouting = option?.noOnRouting !== true;
+      if (!targetRouter) {
+        debugger;
+        throw new Error("no router");
+      }
+      const targetType = typeof targetRouter === "object" ? targetRouter.constructor : targetRouter;
+      const targetValue = typeof targetRouter === "object" ? targetRouter : void 0;
+      const routerAtomic = typeof targetType === "symbol" ? this.simstanceManager.findFirstSim(targetType) : new SimAtomic({ targetKeyType: targetType, originalType: targetType, value: targetValue }, this.simstanceManager);
+      const rootRouter = routerAtomic.getValue();
+      const executeModuleResult = this.getExecuteModule(routerAtomic, intent, [], option);
+      if (executeModuleResult) {
+        const [executeModule, routerChains] = executeModuleResult;
+        executeModule.routerChains = routerChains;
+        this.activeRouterModule = executeModule;
+        const routingDataSet = { intent, routerModule: executeModule, routerManager: this };
+        if (routerChains.length > 0) {
+          for (let i = 0; i < routerChains.length; i++) {
+            const current = routerChains[i];
+            const next = routerChains[i + 1];
+            const value = current.getValue();
+            if (RouterAction.isCanActivate(value) && next) {
+              await value.canActivate(routingDataSet, next.getValue());
+            }
+            if (callCheckOnRouting && RouterAction.isOnRouting(value) && next) {
+              await value.onRouting(routingDataSet);
+            }
+          }
+        }
+        this.activeRouterModule = executeModule;
+        const moduleInstance = executeModule.getModuleInstance();
+        if (!executeModule?.module) {
+          const routerChain = executeModule.routerChains[executeModule.routerChains.length - 1];
+          const value = routerChain?.getValue();
+          if (RouterAction.isCanActivate(value)) {
+            await value.canActivate(routingDataSet, moduleInstance);
+          }
+          if (callCheckOnRouting && RouterAction.isOnRouting(value)) {
+            await value.onRouting(routingDataSet);
+          }
+        } else {
+          const value = executeModule.router?.getValue();
+          if (RouterAction.isCanActivate(value)) {
+            await value.canActivate(routingDataSet, moduleInstance);
+          }
+          if (callCheckOnRouting && RouterAction.isOnRouting(value)) {
+            await value.onRouting(routingDataSet);
+          }
+          if (moduleInstance && callCheckOnRouting && RouterAction.isOnRouting(moduleInstance)) {
+            await moduleInstance.onRouting(routingDataSet);
+          }
+        }
+        const find = this.activeRouterModule;
+        this.subject.next({ intent, routerModule: find, routerManager: this });
+        return find;
+      } else {
+        const empty = await this._handleNotFoundRouting(rootRouter, intent);
+        this.subject.next({ intent, routerModule: empty, routerManager: this });
+        return empty;
+      }
+    }
+    /**
+     * URL과 일치하는 라우트를 찾지 못했을 경우를 처리합니다.
+     * "Not Found" 상태를 나타내는 비어있는 RouterModule 객체를 생성하여 반환합니다.
+     * 이 과정에서 rootRouter의 라이프사이클을 호출하여 공통 레이아웃등을 처리할 수 있습니다.
+     * @param rootRouter 앱의 최상위 라우터 인스턴스
+     * @param intent 확인에 실패한 원본 Intent 객체
+     * @private
+     */
+    async _handleNotFoundRouting(rootRouter, intent) {
+      const routerModule = new RouterModule(this.simstanceManager, rootRouter, void 0, []);
+      const routingDataSet = { intent, routerModule, routerManager: this };
+      const value = rootRouter;
+      if (RouterAction.isCanActivate(value)) {
+        await value.canActivate(routingDataSet, null);
+      }
+      if (RouterAction.isOnRouting(value)) {
+        await value.onRouting(routingDataSet);
+      }
+      this.activeRouterModule = routerModule;
+      return this.activeRouterModule;
+    }
+    getExecuteModule(router, intent, parentRouters, option) {
+      const path = intent.pathname;
+      const routerConfig = router.getConfig(RouterMetadataKey);
+      if (routerConfig) {
+        const filters = [];
+        if (Array.isArray(routerConfig.filters)) {
+          filters.push(...routerConfig.filters);
+        } else if (routerConfig.filters) {
+          filters.push(routerConfig.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (noAccept) {
+          return;
+        }
+        const routerStrings = parentRouters.map((it) => it.getConfig(RouterMetadataKey)?.path || "");
+        const isRoot = this.isRootUrl(routerConfig.path, routerStrings, path);
+        if (isRoot) {
+          const currentParentRouters = [...parentRouters, router];
+          if (routerConfig.routers && routerConfig.routers.length > 0) {
+            let bestMatchModule = void 0;
+            let bestMatchLength = -1;
+            for (const child of routerConfig.routers) {
+              const routerAtomic = typeof child === "symbol" ? this.simstanceManager.findFirstSim(child) : new SimAtomic({ targetKeyType: child, originalType: child }, this.simstanceManager);
+              if (!routerAtomic) {
+                continue;
+              }
+              const executeModule = this.getExecuteModule(routerAtomic, intent, currentParentRouters, option);
+              if (executeModule) {
+                const [rm, chains] = executeModule;
+                const currentMatchLength = rm.path?.length || 0;
+                if (currentMatchLength > bestMatchLength) {
+                  bestMatchLength = currentMatchLength;
+                  bestMatchModule = executeModule;
+                } else if (currentMatchLength === bestMatchLength) {
+                  if (option?.find?.router === "last") {
+                    bestMatchModule = executeModule;
+                  }
+                }
+              }
+            }
+            if (bestMatchModule) {
+              return bestMatchModule;
+            }
+          }
+          const module = this.findRouterOrModule(router, routerConfig, routerStrings, intent);
+          if (module) {
+            return [module, currentParentRouters];
+          }
+        }
+      }
+    }
+    // path: 지금 내 라우터의 path,  parentRoots: 부모router path들,  url: 사용자가 원하는 full intent url
+    isRootUrl(path, parentRoots, url) {
+      const searchString = parentRoots.join("") + (path || "");
+      if (searchString === "/") {
+        return true;
+      }
+      const searchs = searchString.split("/");
+      const urls = url.split("/");
+      const trimmedUrls = urls.slice(0, searchs.length).join("/");
+      return !!Expression.Path.pathNameData(trimmedUrls, searchString);
+    }
+    _collectAllMatchingModules(router, intent, parentRouters) {
+      const matches = [];
+      const path = intent.pathname;
+      const routerConfig = router.getConfig(RouterMetadataKey);
+      if (routerConfig) {
+        const filters = [];
+        if (Array.isArray(routerConfig.filters)) {
+          filters.push(...routerConfig.filters);
+        } else if (routerConfig.filters) {
+          filters.push(routerConfig.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (noAccept) {
+          return matches;
+        }
+        const routerStrings = parentRouters.map((it) => it.getConfig(RouterMetadataKey)?.path || "");
+        const isRoot = this.isRootUrl(routerConfig.path, routerStrings, path);
+        if (isRoot) {
+          const currentParentRouters = [...parentRouters, router];
+          if (routerConfig.routers && routerConfig.routers.length > 0) {
+            for (const child of routerConfig.routers) {
+              const routerAtomic = typeof child === "symbol" ? this.simstanceManager.findFirstSim(child) : new SimAtomic({ targetKeyType: child, originalType: child }, this.simstanceManager);
+              if (!routerAtomic) {
+                continue;
+              }
+              matches.push(...this._collectAllMatchingModules(routerAtomic, intent, currentParentRouters));
+            }
+          }
+          const module = this.findRouterOrModule(router, routerConfig, routerStrings, intent);
+          if (module) {
+            module.routerChains = currentParentRouters;
+            matches.push(module);
+          }
+        }
+      }
+      return matches;
+    }
+    findRouterOrModule(router, routerData, parentRoots, intent) {
+      const module = this.findRouting(router, routerData, parentRoots, intent);
+      if (module?.module) {
+        module.intent = intent;
+        return module;
+      }
+      const urlRoot = parentRoots.join("") + (routerData.path || "");
+      if (this.isRootUrl(routerData.path, parentRoots, intent.pathname)) {
+        const rm = new RouterModule(this.simstanceManager, router);
+        rm.intent = intent;
+        rm.path = urlRoot;
+        rm.pathData = intent.getPathnameData(urlRoot);
+        return rm;
+      }
+      return void 0;
+    }
+    findRouting(router, routerData, parentRoots, intent) {
+      const urlRoot = parentRoots.join("") + routerData.path;
+      if (routerData.route) {
+        for (const it of Object.keys(routerData.route).filter((it2) => !it2.startsWith("_"))) {
+          const path = urlRoot + it;
+          const pathnameData = intent.getPathnameData(path);
+          if (pathnameData) {
+            try {
+              const dataSet = this.findRouteProperty(routerData.route, it, intent);
+              const rm = new RouterModule(this.simstanceManager, router, dataSet.child);
+              rm.data = dataSet.data;
+              rm.path = path;
+              rm.pathData = pathnameData;
+              rm.propertyKeys = dataSet.propertyKeys;
+              return rm;
+            } catch (e) {
+            }
+          }
+        }
+      }
+    }
+    findRouteProperty(route, propertyName, intent) {
+      let child;
+      let data;
+      let propertyKeys;
+      const routeElement = route[propertyName];
+      if (typeof routeElement === "function") {
+        child = { targetKeyType: routeElement, originalType: routeElement };
+      } else if (typeof routeElement === "symbol") {
+        const findSimType = this.simstanceManager.findLastSim(routeElement)?.type;
+        if (findSimType?.originalType) {
+          child = { targetKeyType: findSimType.originalType, originalType: findSimType.originalType };
+        }
+      } else if (typeof routeElement === "string") {
+        return this.findRouteProperty(route, routeElement, intent);
+      } else if (Array.isArray(routeElement)) {
+        const r = routeElement?.[0];
+        if (typeof r === "object" && "filters" in r && "target" in r) {
+          const filters = [];
+          if (Array.isArray(r.filters)) {
+            filters.push(...r.filters);
+          } else if (r.filters) {
+            filters.push(r.filters);
+          }
+          const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+          if (!noAccept) {
+            child = { targetKeyType: r.target, originalType: r.target };
+          }
+        } else {
+          child = { targetKeyType: r, originalType: r };
+        }
+        data = routeElement?.[1];
+      } else if (typeof routeElement === "object" && "target" in routeElement && "propertyKeys" in routeElement) {
+        const noAccept = routeElement.filters?.filter((it) => it).some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (!noAccept) {
+          child = { targetKeyType: routeElement.target, originalType: routeElement.target };
+          propertyKeys = routeElement.propertyKeys;
+        }
+      } else if (typeof routeElement === "object" && "filters" in routeElement && "target" in routeElement) {
+        const filters = [];
+        if (Array.isArray(routeElement.filters)) {
+          filters.push(...routeElement.filters);
+        } else if (routeElement.filters) {
+          filters.push(routeElement.filters);
+        }
+        const noAccept = filters.some((it) => (typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it)?.isAccept(intent) === false);
+        if (!noAccept) {
+          child = { targetKeyType: routeElement.target, originalType: routeElement.target };
+        }
+      }
+      return {
+        child,
+        data,
+        propertyKeys
+      };
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/cache/CacheDecorator.js
+  var simpleApplicationCache = /* @__PURE__ */ new WeakMap();
+  var getCacheSet = (simpleApplication) => {
+    return simpleApplicationCache.get(simpleApplication);
+  };
+  var findCacheByKey = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      return Array.from(storage.config.entries()).find(([k, v]) => k === key);
+    }
+  };
+  var findCacheByKeyStartWith = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      return Array.from(storage.config.entries()).filter(([k, v]) => k.startsWith(key));
+    } else {
+      return [];
+    }
+  };
+  var deleteCacheByKey = (simpleApplication, key) => {
+    const storage = simpleApplicationCache.get(simpleApplication);
+    if (storage) {
+      storage.storage.delete(key);
+      findCacheByKeyStartWith(simpleApplication, key).forEach(([k, v]) => {
+        const data = storage.config.get(k);
+        if (data?.expireTimeout) {
+          clearTimeout(data.expireTimeout);
+        }
+        storage.config.delete(k);
+        storage.storage.delete(k);
+      });
+    }
+  };
+  var deleteCacheByKeyStartWith = (simpleApplication, key) => {
+    findCacheByKeyStartWith(simpleApplication, key).forEach(([key2, data]) => deleteCacheByKey(simpleApplication, key2));
+  };
+  var CacheMetadataKey = Symbol.for("simple-boot:cache-metadata");
+
+  // ../simple-boot/dist/esm/cache/CacheManager.js
+  var CacheManager = class {
+    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);
+    }
+  };
+
+  // ../simple-boot/dist/esm/fetch/ApiService.js
+  var ApiServiceInterceptor;
+  ((ApiServiceInterceptor2) => {
+    ApiServiceInterceptor2.TOKEN = Symbol.for("simple-boot:api-service-interceptor-token");
+    ApiServiceInterceptor2.resolveAll = (simstanceManager) => {
+      try {
+        return (simstanceManager.findSims(ApiServiceInterceptor2.TOKEN) ?? []).map((it) => it.getValue()).filter(ValidUtils.isDefined);
+      } catch (e) {
+        return [];
+      }
+    };
+  })(ApiServiceInterceptor || (ApiServiceInterceptor = {}));
+  var ApiService = class 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);
+    }
+  };
+
+  // ../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 AlertFactory = class {
+  };
+  var DefaultAlertFactory = class extends AlertFactory {
+    create(data) {
+      return void 0;
+    }
+  };
+
+  // ../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 AlertService = class {
+    constructor(alertFactory) {
+      this.name = (/* @__PURE__ */ new Date()).toUTCString();
+      this.subject = new ReplaySubject();
+      this.alertFactory = alertFactory;
+    }
+    // @PostConstruct
+    // postConstruct(
+    // ) {
+    //   this.alertFactory = alertFactory;
+    // }
+    // @PostConstruct
+    // postConstruct(apiService: ApiService) {
+    //   this.apiService = 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);
+    }
+  };
+
+  // ../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
+    // private alertService: AlertService<any>;
+    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.cacheManager = new CacheManager(this);
+      if (!this.simstanceManager.getStoreSet(AlertFactory)) {
+        this.simstanceManager.setStoreSet(AlertFactory, new DefaultAlertFactory());
+      }
+      Sim({ container: this.option.container })(AlertService);
+      Sim({ container: this.option.container })(ApiService);
+      this.simstanceManager.setStoreSet(IntentManager, this.intentManager);
+      this.simstanceManager.setStoreSet(RouterManager, this.routerManager);
+      this.simstanceManager.setStoreSet(CacheManager, this.cacheManager);
+      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);
+      }
+    }
+  };
+
+  // ../simple-boot/dist/esm/decorators/event/EventListener.js
+  var EventListenerMetadataKey = Symbol.for("simple-boot:event-listener-metadata");
+
+  // ../simple-boot/dist/esm/decorators/validate/Validation.js
+  var ValidMetadataKey = Symbol.for("simple-boot:valid-metadata");
+  var ValidationMetadataKey = Symbol.for("simple-boot:validation-metadata");
+
+  // src/router/ElementRouter.ts
+  var ElementRouter = class extends Router {
+    constructor(config) {
+      super(config);
+      __publicField(this, "_history", []);
+      __publicField(this, "_currentIndex", -1);
+    }
+    // Override pushState to manage internal history
+    pushState(data, title, path, config) {
+      const behaviorSubject = this.behaviorSubject;
+      if (!config?.noEventAndPublish && behaviorSubject) {
+        behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      }
+      if (!this._history) this._history = [];
+      this._history = this._history.slice(0, this._currentIndex + 1);
+      this._history.push({ url: path, data, title });
+      this._currentIndex++;
+      if (!config?.noEventAndPublish && behaviorSubject) {
+        behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
+      }
+      return { data };
+    }
+    // Override replaceState to manage internal history
+    replaceState(data, title, path, config) {
+      const behaviorSubject = this.behaviorSubject;
+      if (!config?.noEventAndPublish && behaviorSubject) {
+        behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "start" });
+      }
+      if (!this._history) this._history = [];
+      if (this._currentIndex === -1) {
+        this._history.push({ url: path, data, title });
+        this._currentIndex = 0;
+      } else {
+        this._history[this._currentIndex] = { url: path, data, title };
+      }
+      if (!config?.noEventAndPublish && behaviorSubject) {
+        behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: path }), triggerPoint: "end" });
+      }
+      return { data };
+    }
+    push(path, state) {
+      this.pushState(state?.data, state?.title, this.toUrl(path), state?.config);
+    }
+    replace(path, state) {
+      this.replaceState(state?.data, state?.title, this.toUrl(path), state?.config);
+    }
+    back(config) {
+      if (this._currentIndex > 0) {
+        this.go(-1, config);
+      }
+    }
+    forward(config) {
+      if (this._currentIndex < this._history.length - 1) {
+        this.go(1, config);
+      }
+    }
+    go(config, changeStateConfig) {
+      if (typeof config === "number") {
+        const targetIndex = this._currentIndex + config;
+        if (this._history && targetIndex >= 0 && targetIndex < this._history.length) {
+          const behaviorSubject = this.behaviorSubject;
+          if (!changeStateConfig?.noEventAndPublish && behaviorSubject) {
+            behaviorSubject.next({ ...this.getRouteData(), triggerPoint: "start" });
+          }
+          this._currentIndex = targetIndex;
+          const entry = this._history[this._currentIndex];
+          if (!changeStateConfig?.noEventAndPublish && behaviorSubject) {
+            behaviorSubject.next({ ...this.getRouteData({ pathOrUrl: entry.url }), triggerPoint: "end" });
+          }
+        }
+        return;
+      }
+      return super.go(config, changeStateConfig);
+    }
+    getData() {
+      return this._history?.[this._currentIndex]?.data;
+    }
+    getUrl() {
+      return this._history?.[this._currentIndex]?.url ?? this.config?.firstUrl ?? "/";
+    }
+    getHref() {
+      return this.getUrl();
+    }
+    getPathName() {
+      return this.getUrl().split("?")[0];
+    }
+    getSearch() {
+      const parts = this.getUrl().split("?");
+      return parts[1] ? `?${parts[1]}` : "";
+    }
+    getSearchParams(data) {
+      const search = this.getSearch();
+      const searchParams = new URLSearchParams(search);
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+    getHashSearchParams(data) {
+      const url = this.getUrl();
+      const hashIdx = url.indexOf("#");
+      const hash = hashIdx !== -1 ? url.slice(hashIdx + 1) : "";
+      const searchParams = new URLSearchParams(hash);
+      return UrlUtils.manipulateSearchParams(searchParams, data);
+    }
+    pushAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.push({ searchParams: s }, state);
+    }
+    pushDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const url = this.getUrl().split("#")[0];
+      const size = Array.from(s.entries()).length;
+      this.push(url + (size > 0 ? "#" + s.toString() : ""), state);
+    }
+    pushDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.push({ searchParams: s }, state);
+    }
+    pushUpsertSearchParam(params, state) {
+      const s = this.getSearchParams();
+      UrlUtils.upsertSearchParam(s, params);
+      this.push({ searchParams: s }, state);
+    }
+    replaceAddSearchParam(params, state) {
+      const s = this.getSearchParams({ append: params });
+      this.replace({ searchParams: s }, state);
+    }
+    replaceDeleteHashSearchParam(name, state) {
+      const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      const url = this.getUrl().split("#")[0];
+      const size = Array.from(s.entries()).length;
+      this.replace(url + (size > 0 ? "#" + s.toString() : ""), state);
+    }
+    replaceDeleteSearchParam(name, state) {
+      const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+      this.replace({ searchParams: s }, state);
+    }
+    replaceUpsertSearchParam(params, state) {
+      const s = this.getSearchParamObject();
+      UrlUtils.upsertSearchParam(s, params);
+      this.replace({ searchParams: s }, state);
+    }
+  };
+
+  // src/SwcAppEngine.ts
+  var SwcAppEngine = class {
+    constructor(host) {
+      this.host = host;
+      __publicField(this, "simpleApplication");
+      __publicField(this, "router");
+      __publicField(this, "routerSubscription");
+      __publicField(this, "_config");
+    }
+    get config() {
+      return this._config;
+    }
+    async connect(config) {
+      try {
+        this._config = config;
+        if (this._config.routeType === "path") {
+          this.router = new PathRouter({ window: this._config.window, firstUrl: this._config.path });
+        } else if (this._config.routeType === "hash") {
+          this.router = new HashRouter({ window: this._config.window, firstUrl: this._config.path });
+        } else if (this._config.routeType === "element") {
+          this.router = new ElementRouter({ window: this._config.window, firstUrl: this._config.path });
+        }
+        this.simpleApplication = new SimpleApplication(
+          new SimOption({
+            excludeProxys: [this._config.window.Node],
+            container: this._config.container
+          })
+        );
+        const otherInstanceSim = /* @__PURE__ */ new Map();
+        this.config?.otherInstanceSim?.forEach((v, k) => {
+          otherInstanceSim.set(k, v);
+        });
+        if (this.router) otherInstanceSim.set(Router, this.router);
+        this.simpleApplication.run(otherInstanceSim);
+        if (this._config.onEngineStarted) {
+          await this._config.onEngineStarted(this.simpleApplication, this.host);
+        }
+      } catch (e) {
+        console.error("[SWC-APP-ENGINE] Init failed:", e, this._config);
+      }
+    }
+    disconnect() {
+      this.routerSubscription?.unsubscribe();
+    }
+  };
+
+  // src/elements/SwcApp.ts
+  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 isSSR = (i) => {
+    return i.hasAttribute("swc-use-ssr");
+  };
+  var setSSRAttribute = (i) => {
+    i.setAttribute("swc-use-ssr", i._swcId ?? "");
+  };
+  var removeSSRAttribute = (i) => {
+    i.removeAttribute("swc-use-ssr");
+  };
+  var tagName = "swc-app";
+  var SwcApp_default = async (w) => {
+    const existing = w.customElements.get(tagName);
+    if (existing)
+      return existing;
+    let SwcApp = class SwcApp extends w.HTMLElement {
+      constructor() {
+        super(...arguments);
+        this.__swc_engine = new SwcAppEngine(this);
+        this._swc_connected_instance = /* @__PURE__ */ new Set();
+        this._routeChangeInvocations = 0;
+        this._connectedInvocations = 0;
+        this._connected_safari_and_standby = [];
+      }
+      get simpleApplication() {
+        return this.__swc_engine.simpleApplication;
+      }
+      get config() {
+        return this.__swc_engine?.config;
+      }
+      get router() {
+        return this.__swc_engine?.router;
+      }
+      async _invokeRouteChangeSubscribers(instance, re) {
+        if (instance.isConnected === false)
+          return;
+        this._routeChangeInvocations++;
+        if (this._childrenRouteChangedInterval) {
+          this.config.window.clearInterval(this._childrenRouteChangedInterval);
+        }
+        const intervalConfig = { setInterval: this.config.window.setInterval.bind(this.config.window), clearInterval: this.config.window.clearInterval.bind(this.config.window) };
+        this._childrenRouteChangedInterval = debounceTimeIntervalLock(
+          () => this._routeChangeInvocations === 0,
+          () => {
+            this._childrenRouteChangedInterval = null;
+            this.config.onChildrenRouteChanged?.(re, this);
+          },
+          this.config?.childrenConnectedDoneCheckIntervalTime ?? 30,
+          intervalConfig
+          // {setInterval: window.setInterval, clearInterval: window.clearInterval}
+        );
+        try {
+          const routeChangeSubscribers = getSubscribeSwcAppRouteChangeWhileConnectedMetadata(instance);
+          if (routeChangeSubscribers && Array.isArray(routeChangeSubscribers)) {
+            const ps = routeChangeSubscribers.map(async (metadata) => {
+              const methodName = metadata.propertyKey;
+              let pathPattern = metadata.options?.path;
+              const filter = metadata.options?.filter;
+              if (typeof pathPattern === "function") {
+                pathPattern = pathPattern(instance);
+              }
+              let pathMatched = false;
+              let pathData = null;
+              if (!pathPattern) {
+                pathMatched = true;
+                pathData = {};
+              } else if (Array.isArray(pathPattern)) {
+                for (const pattern of pathPattern) {
+                  const data = SwcUtils.parsePathPattern(pattern, re.path || "/");
+                  if (data !== null) {
+                    pathMatched = true;
+                    pathData = data;
+                    break;
+                  }
+                }
+              } else {
+                pathData = SwcUtils.parsePathPattern(pathPattern, re.path || "/");
+                pathMatched = pathData !== null;
+              }
+              const filterPassed = !filter || filter(this.router, instance);
+              if (pathMatched && filterPassed && instance[methodName]) {
+                await instance[methodName]({ ...re, pathData });
+              }
+            });
+            await Promise.allSettled(ps);
+          }
+        } finally {
+          if (this.config?.ssr) {
+            setSSRAttribute(instance);
+          } else {
+            removeSSRAttribute(instance);
+          }
+          this._routeChangeInvocations = Math.max(0, this._routeChangeInvocations - 1);
+        }
+      }
+      async _connected(instance, option) {
+        if (instance) {
+          if (!this.simpleApplication && !this.config) {
+            this._connected_safari_and_standby.push(instance);
+            return;
+          }
+          this.config.onConnectedChildBefore?.(instance);
+          if (!option?.noIncrements) {
+            this._connectedInvocations++;
+          }
+          this._swc_connected_instance.add(instance);
+          const connectedSwcAppCallBacks = findAllLifecycleMetadata(instance, ON_CONNECTED_SWC_APP_METADATA_KEY) ?? [];
+          for (let connectedSwcAppCallBack of connectedSwcAppCallBacks) {
+            await instance?._invokeLifecycleMethod?.(connectedSwcAppCallBack);
+          }
+          if (this._childrenConnectedDoneInterval) {
+            this.config.window.clearInterval(this._childrenConnectedDoneInterval);
+          }
+          const intervalConfig = { setInterval: this.config.window.setInterval.bind(this.config.window), clearInterval: this.config.window.clearInterval.bind(this.config.window) };
+          this._childrenConnectedDoneInterval = debounceTimeIntervalLock(() => this._connectedInvocations === 0, () => {
+            this._childrenConnectedDoneInterval = null;
+            this.config.onChildrenConnectedDone?.(this);
+          }, this.config?.childrenConnectedDoneCheckIntervalTime ?? 30, intervalConfig);
+          if (this.simpleApplication) {
+            try {
+              if (this.router && this._lastRouterEvent) {
+                await this._invokeRouteChangeSubscribers(instance, this._lastRouterEvent);
+              }
+            } catch (e) {
+              throw e;
+            }
+          }
+          if (this.config?.ssr) {
+            setSSRAttribute(instance);
+          } else {
+            removeSSRAttribute(instance);
+          }
+        }
+        this.config.onConnectedChildAfter?.(instance);
+        return this;
+      }
+      async _connectedDone(instance) {
+        try {
+        } finally {
+          this._connectedInvocations = Math.max(0, this._connectedInvocations - 1);
+        }
+      }
+      _disconnected(instance) {
+        if (instance) {
+          this._swc_connected_instance.delete(instance);
+          this.config?.onDisconnectedChildAfter?.(instance);
+        }
+      }
+      async _handleRouteChange(route) {
+        this._lastRouterEvent = route;
+        const swcConnectedInstance = Array.from(this._swc_connected_instance);
+        const ps = swcConnectedInstance.map((instance) => this._invokeRouteChangeSubscribers(instance, route));
+        await Promise.allSettled(ps);
+      }
+      async connect(config) {
+        console.log("[SWC] connect");
+        const swcConfig = {
+          routeType: "element",
+          window: config?.window,
+          ...config
+        };
+        const mode = config?.connectMode || "direct";
+        if (mode === "direct" || mode === "hydrate") {
+          this.setAttribute("swc-connect-mode", mode);
+          await this.__swc_engine.connect(swcConfig);
+        } else if (mode === "swap" || mode === "clear-swap") {
+          if (!this.parentNode) {
+            await this.__swc_engine.connect(swcConfig);
+            this.setAttribute("swc-connect-mode", "direct");
+          } else {
+            const clonedApp = this.cloneNode(mode === "swap");
+            clonedApp.style.display = "none";
+            this.parentNode.insertBefore(clonedApp, this.nextSibling);
+            try {
+              await clonedApp.connect({ ...config || {}, connectMode: "direct" });
+              if (this.parentNode) {
+                this.parentNode.removeChild(this);
+              }
+              clonedApp.style.display = "";
+              clonedApp.setAttribute("swc-connect-mode", mode);
+              return;
+            } catch (e) {
+              if (clonedApp.parentNode) {
+                clonedApp.parentNode.removeChild(clonedApp);
+              }
+              await this.__swc_engine.connect(swcConfig);
+              this.setAttribute("swc-connect-mode", "direct");
+            }
+          }
+        }
+        this._connected_safari_and_standby.forEach((instance) => {
+          this._connected(instance, { noIncrements: true });
+        });
+        if (!this._routerSubscription && this.router) {
+          const config2 = this.__swc_engine.config;
+          this._routerSubscription = this.router.observable.subscribe(async (route) => {
+            console.log("[SWC] Router event received:", route.triggerPoint);
+            if (route.triggerPoint === "end") {
+              await this._handleRouteChange(route);
+            }
+          });
+          if (config2?.path) {
+            console.log("[DEBUG] Navigating to initial path:", config2.path);
+          }
+        }
+      }
+      // async _invokeOnConnectedSwcAppStarted(instance: any) {
+      //   this._swcAppStartedInvocations++;
+      //   try {
+      //     // 이미 시작된 인스턴스라면 스킵 (비동기 병렬 중복 호출 방지)
+      //     if (this._swc_started_instances.has(instance)) return;
+      //     this._swc_started_instances.add(instance);
+      //
+      //     const startedMethods = findAllLifecycleMetadata(instance, ON_CONNECTED_SWC_APP_METADATA_KEY);
+      //     if (startedMethods) {
+      //       const ps = startedMethods.map(m => instance._invokeLifecycleMethod(m));
+      //       await Promise.allSettled(ps);
+      //     }
+      //   } finally {
+      //     this._swcAppStartedInvocations--;
+      //   }
+      // }
+      connectedCallback() {
+        if (super.connectedCallback)
+          super.connectedCallback();
+        const configStr = this.getAttribute("swc-get-application-config");
+        const win = this.ownerDocument?.defaultView || window;
+        if (configStr && win) {
+          try {
+            const userConfig = FunctionUtils.executeReturn({
+              script: configStr,
+              context: this,
+              args: SwcUtils.getHelperAndHostSet(win, this)
+            });
+            this.connect(userConfig);
+          } catch (e) {
+            console.error("[SWC-APP-ENGINE] Script execution failed:", e);
+          }
+        }
+        this._connected(this);
+        this.__swc_engine?.config?.onConnected?.(this);
+        this._connectedDone(this);
+      }
+      disconnectedCallback() {
+        if (super.disconnectedCallback)
+          super.disconnectedCallback();
+        this._routerSubscription?.unsubscribe();
+        this._routerSubscription = void 0;
+        this._lastRouterEvent = void 0;
+        this.__swc_engine.disconnect();
+        this.__swc_engine?.config?.onDisconnected?.(this);
+        this._disconnected(this);
+      }
+      async routing(path) {
+        await this.router?.go(path);
+      }
+      back() {
+        this.router?.back();
+      }
+      forward() {
+        this.router?.forward();
+      }
+      reload() {
+        this.router?.reload();
+      }
+      // async completedSwcApp() {
+      //   const ss = Array.from(this._swc_connected_instance).flatMap((it) => {
+      //     const ms = findAllLifecycleMetadata(it, ON_CONNECTED_COMPLETED_SWC_APP_METADATA_KEY) ?? [];
+      //     return ms.map((sit) => it[sit](this));
+      //   });
+      //   await Promise.allSettled(ss);
+      // }
+      publishMessage(message) {
+        this._swc_connected_instance.forEach((instance) => {
+          this._invokeMessageSubscribers(instance, message);
+        });
+      }
+      _invokeMessageSubscribers(instance, message) {
+        const messageSubscribers = getSubscribeSwcAppMessageWhileConnectedMetadata(instance);
+        if (messageSubscribers && Array.isArray(messageSubscribers)) {
+          messageSubscribers.forEach((metadata) => {
+            const methodName = metadata.propertyKey;
+            const messageType = metadata.messageType;
+            const filter = metadata.filter;
+            let typeMatched = false;
+            if (!messageType) {
+              typeMatched = true;
+            } else if (message.type === messageType) {
+              typeMatched = true;
+            }
+            let filterMatched = true;
+            if (filter && typeMatched) {
+              filterMatched = filter(message, instance);
+            }
+            if (typeMatched && filterMatched && typeof instance[methodName] === "function") {
+              instance[methodName](message);
+            }
+          });
+        }
+      }
+    };
+    SwcApp = __decorate([
+      elementDefine(tagName, { window: w })
+    ], SwcApp);
+    ;
+    return w.customElements.whenDefined(tagName);
+  };
+
+  // src/elements/index.ts
+  var registerSwcApp = SwcApp_default;
+  var register = [SwcApp_default];
   return __toCommonJS(bundle_entry_exports);
 })();
 /*! Bundled license information: