@dooboostore/simple-web-component 1.0.36 → 1.0.37

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

@@ -4,6 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 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;
 };
@@ -23,6 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   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({
@@ -1110,10 +1112,10 @@ var require_Reflect = __commonJS({
 });
 
 // src/bundle-entry.ts
-var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata3 = __toESM(require_Reflect(), 1);
 
 // src/index.ts
-var import_reflect_metadata = __toESM(require_Reflect(), 1);
+var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
 // ../core/dist/esm/valid/ValidUtils.js
 var ValidUtils;
@@ -4789,6 +4791,137 @@ var Observable = class {
   }
 };
 
+// ../core/dist/esm/message/Subject.js
+var Subject = class extends Observable {
+  constructor() {
+    super((subscriber) => {
+      return this._subscribeToSubject(subscriber);
+    });
+    this._observers = /* @__PURE__ */ new Set();
+    this._isStopped = false;
+    this._hasError = false;
+  }
+  _subscribeToSubject(subscriber) {
+    const partialObserver = {
+      next: subscriber.next.bind(subscriber),
+      error: subscriber.error.bind(subscriber),
+      complete: subscriber.complete.bind(subscriber)
+    };
+    if (this._isStopped) {
+      if (this._hasError) {
+        partialObserver.error?.(this._error);
+      } else {
+        partialObserver.complete?.();
+      }
+      return Subscription.EMPTY;
+    }
+    this._observers.add(partialObserver);
+    return new Subscription(() => {
+      this._observers.delete(partialObserver);
+    });
+  }
+  next(data) {
+    if (this._isStopped) {
+      return;
+    }
+    this._observers.forEach((observer) => {
+      observer.next?.(data);
+    });
+  }
+  error(err) {
+    if (this._isStopped) {
+      return;
+    }
+    this._hasError = true;
+    this._error = err;
+    this._isStopped = true;
+    this._observers.forEach((observer) => observer.error?.(err));
+    this._observers.clear();
+  }
+  complete() {
+    if (this._isStopped) {
+      return;
+    }
+    this._isStopped = true;
+    this._observers.forEach((observer) => observer.complete?.());
+    this._observers.clear();
+  }
+  asObservable() {
+    return new Observable((subscriber) => {
+      return this._subscribeToSubject(subscriber);
+    });
+  }
+};
+
+// ../core/dist/esm/message/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) {
@@ -4796,6 +4929,19 @@ var AutoCloseSubscription = class extends Subscription {
   }
 };
 
+// ../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) {
@@ -5123,6 +5269,284 @@ var Promises;
   })(Result = Promises2.Result || (Promises2.Result = {}));
 })(Promises || (Promises = {}));
 
+// ../core/dist/esm/fetch/Fetcher.js
+var Fetcher = class {
+  createPipe(config) {
+    return {};
+  }
+  fetch(config) {
+    return new Promise((resolve, reject) => {
+      const pipe = this.createPipe(config);
+      Promise.resolve().then(() => {
+        this.before(config, pipe);
+        config?.before?.();
+      }).then(() => {
+        return this.execute(config);
+      }).then((data) => {
+        const hasError = config.config?.hasErrorChecker?.(data);
+        if (hasError) {
+          throw hasError;
+        }
+        pipe.responseData = data;
+        this.afterSuccess(config, pipe);
+        config?.afterSuccess?.();
+        const gdata = config?.transform ? config.transform(data) : data;
+        this.afterSuccessTransform(config, pipe);
+        resolve(gdata);
+      }).catch(async (e) => {
+        this.error(config, pipe, e);
+        config?.error?.();
+        if (config?.errorTransform) {
+          e = await config.errorTransform(e);
+        }
+        e = await this.errorTransform(e);
+        reject(e);
+      }).finally(() => {
+        this.finally(config, pipe);
+        config?.finally?.();
+      });
+    });
+  }
+};
+
+// ../core/dist/esm/fetch/HttpFetcher.js
+var HttpResponseError = class extends Error {
+};
+var HttpFetcher = class extends Fetcher {
+  get(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "GET";
+    return this.fetch(config);
+  }
+  post(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "POST";
+    return this.fetch(config);
+  }
+  patch(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "PATCH";
+    return this.fetch(config);
+  }
+  put(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "PUT";
+    return this.fetch(config);
+  }
+  head(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "HEAD";
+    return this.fetch(config);
+  }
+  delete(config) {
+    config.config ?? (config.config = {});
+    config.config.fetch = config.config?.fetch ?? {};
+    config.config.fetch.method = "DELETE";
+    return this.fetch(config);
+  }
+  async beforeProxyFetch(config) {
+    return config;
+  }
+  async afterProxyFetch(config) {
+    return config.response;
+  }
+  afterSuccess(config, pipe) {
+  }
+  afterSuccessTransform(config, pipe) {
+  }
+  before(config, pipe) {
+  }
+  error(config, pipe, e) {
+  }
+  finally(config, pipe) {
+  }
+  beforeFetch(fetch2) {
+  }
+  afterFetch(fetch2, response) {
+  }
+  // protected async errorTransform(e: any): Promise<HttpResponseError<any>> {
+  async errorTransform(e) {
+    const httpResponseError = new HttpResponseError();
+    httpResponseError.error = e;
+    if (e instanceof Response) {
+      httpResponseError.response = e;
+      try {
+        httpResponseError.body = await e.clone().text();
+        httpResponseError.message = e.statusText;
+      } catch (e2) {
+        httpResponseError.body = e2;
+        httpResponseError.message = e2.message;
+      }
+    } else {
+      httpResponseError.body = e;
+      httpResponseError.message = e.message;
+    }
+    return httpResponseError;
+  }
+  async execute(fetcherRequest) {
+    let target = fetcherRequest.target;
+    let config = fetcherRequest.config;
+    if (!(target instanceof URL) && typeof target !== "string") {
+      const searchParams = ConvertUtils.toURLSearchParams(target.searchParams ?? {});
+      try {
+        const url = typeof target.url === "string" ? new URL(target.url) : target.url;
+        searchParams.forEach((value, key) => {
+          url.searchParams.append(key, value);
+        });
+        target = url;
+      } catch (e) {
+        if (typeof target.url === "string") {
+          const searchParamString = searchParams.toString();
+          target = target.url + (searchParamString ? "?" + searchParamString : "");
+        } else {
+          target = "";
+        }
+      }
+    }
+    const beforeProxyData = { requestInfo: target, init: config?.fetch };
+    let beforeData = config?.beforeProxyFetch ? await config?.beforeProxyFetch(config) : beforeProxyData.requestInfo;
+    beforeData = config?.skipGlobalBeforeProxyFetch ? beforeProxyData : await this.beforeProxyFetch(beforeProxyData);
+    target = beforeData.requestInfo;
+    if (beforeData.init) {
+      config ?? (config = {});
+      config.fetch = beforeData.init;
+    }
+    let abortedTimeout;
+    if (config?.fetch && "timeout" in config.fetch) {
+      const abortController = new AbortController();
+      abortedTimeout = setTimeout(() => {
+        if (config?.fetch?.signal) {
+          const inputSignal = config.fetch.signal;
+          const listener = () => {
+            if (!abortController.signal.aborted) {
+              abortController.abort();
+            }
+            inputSignal.removeEventListener("abort", listener);
+          };
+          inputSignal.addEventListener("abort", listener);
+        }
+        if (!abortController.signal.aborted) {
+          abortController.abort();
+        }
+      }, config.fetch.timeout);
+      config.fetch.signal = abortController.signal;
+    }
+    this.beforeFetch({ target, requestInit: config?.fetch });
+    return (config.fetcher ?? fetch)(target, config?.fetch).then(async (it) => {
+      this.afterFetch({ target, requestInit: config?.fetch }, it);
+      const afterProxyData = {
+        fetch: { target, requestInit: config.fetch },
+        config: beforeData,
+        response: it
+      };
+      it = config?.afterProxyFetch ? await config.afterProxyFetch(afterProxyData) : it;
+      it = config?.skipGlobalAfterProxyFetch ? it : await this.afterProxyFetch(afterProxyData);
+      config?.fetchResponseAfterCallBack?.(it, config);
+      if (!config?.allowedResponseNotOk && !it.ok) {
+        throw it;
+      }
+      const data = config?.hasResponseErrorChecker?.(it, config);
+      if (data) {
+        throw data;
+      }
+      return it;
+    }).finally(() => {
+      if (abortedTimeout) {
+        clearTimeout(abortedTimeout);
+      }
+    });
+  }
+};
+
+// ../core/dist/esm/fetch/HttpJsonFetcher.js
+var HttpJsonFetcher = class extends HttpFetcher {
+  updateJsonFetchConfigAndData(config) {
+    var _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) {
@@ -5895,9 +6319,44 @@ var ON_AFTER_DISCONNECTED_METADATA_KEY = Symbol.for("simple-web-component:on-aft
 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;
@@ -5910,8 +6369,6 @@ function createLifecycleDecorator(metadataKey) {
   };
 }
 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);
@@ -5920,13 +6377,15 @@ var onAdoptedBefore = createLifecycleDecorator(ON_BEFORE_ADOPTED_METADATA_KEY);
 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 });
   };
@@ -5939,11 +6398,19 @@ function onConnectedInnerHtml(arg1, arg2, arg3) {
 }
 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
@@ -5965,14 +6432,17 @@ var commentNode = (comment, doc) => {
   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) => {
@@ -6226,7 +6696,7 @@ var SwcUtils;
       $hosts,
       $firstHost,
       $lastHost: $host,
-      $templateHost: el.__swc_template_host,
+      // $templateHost: (el as any).__swc_template_host,
       $appHost,
       $appHosts,
       $firstAppHost,
@@ -6905,7 +7375,22 @@ var SituationTypeContainers = class {
     return this.containers.find(predicate);
   }
 };
+var isTargetSymbol = (config) => {
+  return "symbol" in config && config.symbol !== void 0;
+};
+var isTargetType = (config) => {
+  return "type" in config && config.type !== void 0;
+};
+var isTargetScheme = (config) => {
+  return "scheme" in config && config.scheme !== void 0;
+};
+var isTargetFactory = (config) => {
+  return "factory" in config && typeof config.factory === "function" && !("symbol" in config) && !("type" in config) && !("scheme" in config);
+};
 var InjectMetadataKey = Symbol.for("simple-boot:inject-metadata");
+var getInject = (target, propertyKey) => {
+  return ReflectUtils.findMetadata(InjectMetadataKey, target, propertyKey) ?? [];
+};
 
 // src/types.ts
 var InjectSituationType = /* @__PURE__ */ ((InjectSituationType2) => {
@@ -7177,6 +7662,379 @@ var NodeUtils;
   };
 })(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) => {
@@ -7571,8 +8429,360 @@ var LocationUtils;
   };
 })(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);
@@ -7689,6 +8899,91 @@ var ValidUtils2;
   };
 })(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) => {
@@ -7697,7 +8992,7 @@ var getElementConfig = (target) => {
 };
 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;
@@ -7718,6 +9013,12 @@ var ensureInit = (inst) => {
         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);
@@ -7760,7 +9061,7 @@ var getHandlers = (inst) => {
   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 = {}) {
@@ -7791,7 +9092,7 @@ var setupPrototype = (proto) => {
   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();
@@ -7896,61 +9197,57 @@ var elementDefine = (name, config = {}) => (constructor) => {
   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) {
@@ -8098,9 +9395,11 @@ var elementDefine = (name, config = {}) => (constructor) => {
         });
       });
       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);
@@ -8116,6 +9415,9 @@ var elementDefine = (name, config = {}) => (constructor) => {
         }
       }
     } 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);
       }
@@ -8123,7 +9425,6 @@ var elementDefine = (name, config = {}) => (constructor) => {
   };
   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);
@@ -8385,8 +9686,9 @@ var normalizeNodes = (res, doc) => {
     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;
@@ -8397,7 +9699,7 @@ var applyToDom = (targetEl, res, pos, doc) => {
     }
     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);
@@ -8450,7 +9752,7 @@ function applyNode(selector, options = { position: "beforeEnd" }) {
       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) {
@@ -8484,23 +9786,23 @@ function applyNodeThis(targetOrOptions, propertyKey, descriptor) {
   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" });
 }
 
@@ -8972,60 +10274,2509 @@ var getPublishSwcAppMessageMetadata = (target) => {
   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];
 export {
   ADD_EVENT_LISTENER_METADATA_KEY,
   APPLY_NODE_METADATA_KEY,
+  APPLY_SLOT_METADATA_KEY,
   ATTRIBUTE_APPLY_METADATA_KEY,
   ATTRIBUTE_CHANGED_WILDCARD,
   ATTRIBUTE_FIELD_METADATA_KEY,
@@ -9035,7 +12786,6 @@ export {
   ELEMENT_CONFIG_KEY,
   EMIT_CUSTOM_EVENT_METADATA_KEY,
   HTML_TAG_ENTRIES,
-  INNER_HTML_METADATA_KEY,
   InjectSituationType,
   ON_ADD_EVENT_LISTENER_METADATA_KEY,
   ON_AFTER_ADOPTED_METADATA_KEY,
@@ -9045,6 +12795,8 @@ export {
   ON_BEFORE_ADOPTED_METADATA_KEY,
   ON_BEFORE_CONNECTED_METADATA_KEY,
   ON_BEFORE_DISCONNECTED_METADATA_KEY,
+  ON_CONNECTED_COMPLETED_METADATA_KEY,
+  ON_CONNECTED_INNER_HTML_METADATA_KEY,
   ON_CONNECTED_SWC_APP_METADATA_KEY,
   ON_INITIALIZE_METADATA_KEY,
   PROPERTY_SET_METADATA_KEY,
@@ -9069,15 +12821,26 @@ export {
   applyAttributeThis,
   applyClass,
   applyClassThis,
-  applyInnerHtmlNode,
-  applyInnerHtmlNodeThis,
-  applyInnerTextNode,
   applyNode,
+  applyNodeInnerHtml,
+  applyNodeInnerText,
+  applyNodeReplaceChildren,
   applyNodeThis,
-  applyReplaceChildrenNode,
-  applyReplaceChildrenNodeThis,
+  applyNodeThisReplaceChildren,
+  applySlot,
+  applySlotAppend,
+  applySlotAppendHtml,
+  applySlotAppendText,
+  applySlotClear,
+  applySlotPrepend,
+  applySlotPrependHtml,
+  applySlotPrependText,
+  applySlotReplaceChildren,
+  applySlotReplaceChildrenHtml,
+  applySlotReplaceChildrenText,
   applyStyle,
   applyStyleThis,
+  applyThisInnerHtmlNode,
   attribute,
   attributeThis,
   changedAttributeThis,
@@ -9090,6 +12853,7 @@ export {
   emitCustomEventThis,
   ensureInit,
   findAllApplyNodeMetadata,
+  findAllApplySlotMetadata,
   findAllAttributeApplyMetadata,
   findAllAttributeChangedMetadata,
   findAllAttributeMetadata,
@@ -9101,6 +12865,8 @@ export {
   getChangedAttributeMetadata,
   getElementConfig,
   getEmitCustomEventMetadataList,
+  getOnConnectedAfterMetadata,
+  getOnConnectedBeforeMetadata,
   getOnConnectedInnerHtmlMetadata,
   getPublishSwcAppMessageMetadata,
   getQueryAllMetadata,
@@ -9125,7 +12891,9 @@ export {
   onConnected,
   onConnectedAfter,
   onConnectedBefore,
+  onConnectedCompleted,
   onConnectedInnerHtml,
+  onConnectedSwcApp,
   onDisconnected,
   onDisconnectedAfter,
   onDisconnectedBefore,
@@ -9139,6 +12907,8 @@ export {
   queryHost,
   queryThis,
   queryWindow,
+  register,
+  registerSwcApp,
   removeAttribute,
   removeAttributeThis,
   removeClass,