sibujs 1.0.0-beta.1

package/dist/plugins.js

@@ -0,0 +1,1504 @@
+import {
+  renderToString
+} from "./chunk-VCZLXRMR.js";
+import {
+  span
+} from "./chunk-6JGMNCD6.js";
+import "./chunk-MFHVGKET.js";
+import "./chunk-ETMEC6FH.js";
+import "./chunk-MJNB47HB.js";
+import {
+  signal,
+  track
+} from "./chunk-M5GNLDEO.js";
+import "./chunk-MLKGABMK.js";
+
+// src/plugins/i18n.ts
+var [currentLocale, setLocaleInternal] = signal("en");
+var locales = {};
+function setLocale(locale) {
+  setLocaleInternal(locale);
+}
+function getLocale() {
+  return currentLocale();
+}
+function registerTranslations(locale, messages) {
+  locales[locale] = { ...locales[locale], ...messages };
+}
+function t(key, params) {
+  const locale = currentLocale();
+  const message = locales[locale]?.[key] || key;
+  return params ? message.replace(/\{(\w+)\}/g, (_, p) => String(params[p] ?? "")) : message;
+}
+function Trans(key, params) {
+  return span({
+    nodes: () => t(key, params)
+  });
+}
+function hasTranslation(key) {
+  const locale = currentLocale();
+  return key in (locales[locale] || {});
+}
+function getAvailableLocales() {
+  return Object.keys(locales);
+}
+
+// src/plugins/router.ts
+var LRUCache = class {
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = Math.max(1, maxSize);
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var NavigationController = class {
+  constructor() {
+    this.currentController = null;
+  }
+  async navigate(navigationFn) {
+    if (this.currentController) {
+      this.currentController.abort();
+    }
+    this.currentController = new AbortController();
+    const signal2 = this.currentController.signal;
+    try {
+      await navigationFn(signal2);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      throw error;
+    } finally {
+      if (this.currentController?.signal === signal2) {
+        this.currentController = null;
+      }
+    }
+  }
+  abort() {
+    if (this.currentController) {
+      this.currentController.abort();
+      this.currentController = null;
+    }
+  }
+  get isNavigating() {
+    return this.currentController !== null;
+  }
+};
+var RouteMatcher = class {
+  constructor(routes) {
+    this.routeTrie = /* @__PURE__ */ new Map();
+    this.namedRoutes = /* @__PURE__ */ new Map();
+    this.compiledPatterns = new LRUCache(50);
+    this.buildIndex(routes);
+  }
+  buildIndex(routes, parentPath = "") {
+    for (const route2 of routes) {
+      const fullPath = parentPath + route2.path;
+      this.routeTrie.set(fullPath, route2);
+      if (route2.name) {
+        this.namedRoutes.set(route2.name, route2);
+      }
+      if (route2.alias) {
+        const aliases = Array.isArray(route2.alias) ? route2.alias : [route2.alias];
+        for (const alias of aliases) {
+          this.routeTrie.set(parentPath + alias, route2);
+        }
+      }
+      if (route2.children?.length) {
+        this.buildIndex(route2.children, fullPath);
+      }
+    }
+  }
+  match(path) {
+    const exactMatch = this.routeTrie.get(path);
+    if (exactMatch) {
+      return { route: exactMatch, params: {}, matched: [exactMatch] };
+    }
+    for (const [routePath, route2] of this.routeTrie) {
+      const match = this.matchPattern(path, routePath);
+      if (match) {
+        return { route: route2, params: match.params, matched: [route2] };
+      }
+    }
+    return null;
+  }
+  findByName(name) {
+    return this.namedRoutes.get(name) || null;
+  }
+  matchPattern(path, routePath) {
+    if (routePath === "*" || routePath.endsWith("/*")) {
+      const basePath = routePath.slice(0, -2);
+      if (path.startsWith(basePath)) {
+        return { params: { pathMatch: path.slice(basePath.length) } };
+      }
+      return null;
+    }
+    let compiled = this.compiledPatterns.get(routePath);
+    if (!compiled) {
+      compiled = this.compileRoute(routePath);
+      this.compiledPatterns.set(routePath, compiled);
+    }
+    const match = path.match(compiled.regex);
+    if (match) {
+      const params = {};
+      compiled.keys.forEach((key, i) => {
+        if (match[i + 1] !== void 0) {
+          params[key] = decodeURIComponent(match[i + 1]);
+        }
+      });
+      return { params };
+    }
+    return null;
+  }
+  compileRoute(routePath) {
+    const keys = [];
+    const escapeRegex = (s) => s.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+    const parts = routePath.split(/(\/:[^/]+\??)/);
+    let pattern = "";
+    for (const part of parts) {
+      if (part.startsWith("/:")) {
+        if (part.endsWith("?")) {
+          keys.push(part.slice(2, -1));
+          pattern += "(?:/([^/]+))?";
+        } else {
+          keys.push(part.slice(2));
+          pattern += "/([^/]+)";
+        }
+      } else {
+        pattern += escapeRegex(part);
+      }
+    }
+    return {
+      regex: new RegExp(`^${pattern}$`),
+      keys
+    };
+  }
+  rebuild(routes) {
+    this.routeTrie.clear();
+    this.namedRoutes.clear();
+    this.compiledPatterns.clear();
+    this.buildIndex(routes);
+  }
+  addRoute(route2, parentPath = "") {
+    const fullPath = parentPath + route2.path;
+    this.routeTrie.set(fullPath, route2);
+    if (route2.name) {
+      this.namedRoutes.set(route2.name, route2);
+    }
+    if (route2.children?.length) {
+      this.buildIndex(route2.children, fullPath);
+    }
+  }
+  removeRoute(path) {
+    this.routeTrie.delete(path);
+    this.compiledPatterns.clear();
+    for (const [name, route2] of this.namedRoutes) {
+      if (route2.path === path) {
+        this.namedRoutes.delete(name);
+        break;
+      }
+    }
+  }
+};
+var GuardManager = class {
+  constructor(timeout = 5e3) {
+    this.beforeEachGuards = [];
+    this.beforeResolveGuards = [];
+    this.afterEachHooks = [];
+    this.timeout = timeout;
+  }
+  async runBeforeEach(to, from, signal2) {
+    for (const guard of this.beforeEachGuards) {
+      if (signal2.aborted) throw new Error("Navigation aborted");
+      const result = await this.runGuard(guard, to, from, signal2);
+      if (result !== true) return result;
+    }
+    return true;
+  }
+  async runBeforeResolve(to, from, signal2) {
+    for (const guard of this.beforeResolveGuards) {
+      if (signal2.aborted) throw new Error("Navigation aborted");
+      const result = await this.runGuard(guard, to, from, signal2);
+      if (result !== true) return result;
+    }
+    return true;
+  }
+  runAfterEach(to, from) {
+    for (const hook of this.afterEachHooks) {
+      try {
+        hook(to, from);
+      } catch (error) {
+        console.error("[Router] AfterEach hook error:", error);
+      }
+    }
+  }
+  runGuard(guard, to, from, signal2) {
+    return new Promise((resolve, reject) => {
+      if (signal2.aborted) {
+        reject(new Error("Navigation aborted"));
+        return;
+      }
+      let resolved = false;
+      const next = (result) => {
+        if (resolved || signal2.aborted) return;
+        resolved = true;
+        if (result instanceof Error) {
+          reject(result);
+        } else if (result === false) {
+          resolve(false);
+        } else if (typeof result === "string") {
+          resolve(result);
+        } else {
+          resolve(true);
+        }
+      };
+      const abortHandler = () => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error("Navigation aborted"));
+        }
+      };
+      signal2.addEventListener("abort", abortHandler);
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          signal2.removeEventListener("abort", abortHandler);
+          reject(new Error("Guard timeout"));
+        }
+      }, this.timeout);
+      try {
+        guard(to, from, next);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        signal2.removeEventListener("abort", abortHandler);
+        if (!resolved) {
+          resolved = true;
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      Promise.resolve().then(() => {
+        if (resolved) {
+          clearTimeout(timeoutId);
+          signal2.removeEventListener("abort", abortHandler);
+        }
+      });
+    });
+  }
+  addBeforeEach(guard) {
+    this.beforeEachGuards.push(guard);
+    return () => {
+      const index = this.beforeEachGuards.indexOf(guard);
+      if (index > -1) this.beforeEachGuards.splice(index, 1);
+    };
+  }
+  addBeforeResolve(guard) {
+    this.beforeResolveGuards.push(guard);
+    return () => {
+      const index = this.beforeResolveGuards.indexOf(guard);
+      if (index > -1) this.beforeResolveGuards.splice(index, 1);
+    };
+  }
+  addAfterEach(hook) {
+    this.afterEachHooks.push(hook);
+    return () => {
+      const index = this.afterEachHooks.indexOf(hook);
+      if (index > -1) this.afterEachHooks.splice(index, 1);
+    };
+  }
+  clear() {
+    this.beforeEachGuards = [];
+    this.beforeResolveGuards = [];
+    this.afterEachHooks = [];
+  }
+};
+var ComponentLoader = class {
+  constructor(cacheSize = 50, retryDelay = 1e3) {
+    this.errorCache = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.componentCache = new LRUCache(cacheSize);
+    this.retryDelay = retryDelay;
+  }
+  async loadComponent(route2, routePath) {
+    if (!("component" in route2)) {
+      throw new Error(`Route ${routePath} does not have a component`);
+    }
+    const comp = route2.component;
+    const cached = this.componentCache.get(routePath);
+    if (cached) return cached;
+    const existingPromise = this.loadingPromises.get(routePath);
+    if (existingPromise) return existingPromise;
+    const errorInfo = this.errorCache.get(routePath);
+    if (errorInfo && Date.now() - errorInfo.timestamp < this.retryDelay) {
+      throw new Error(`Component loading failed recently, retry in ${this.retryDelay}ms`);
+    }
+    const loadingPromise = this.doLoadComponent(comp, routePath);
+    this.loadingPromises.set(routePath, loadingPromise);
+    try {
+      const component = await loadingPromise;
+      this.componentCache.set(routePath, component);
+      this.errorCache.delete(routePath);
+      return component;
+    } catch (error) {
+      const currentError = this.errorCache.get(routePath) || { timestamp: 0, count: 0 };
+      this.errorCache.set(routePath, {
+        timestamp: Date.now(),
+        count: currentError.count + 1
+      });
+      throw error;
+    } finally {
+      this.loadingPromises.delete(routePath);
+    }
+  }
+  async doLoadComponent(comp, routePath) {
+    if (!this.isAsyncComponent(comp)) {
+      const result = comp();
+      if (!this.isElement(result)) {
+        throw new Error(`Component for route "${routePath}" must return Element, got ${typeof result}`);
+      }
+      return comp;
+    }
+    try {
+      const result = await comp();
+      const component = this.extractComponent(result, routePath);
+      const testElement = component();
+      if (!this.isElement(testElement)) {
+        throw new Error(`Component for route "${routePath}" must return Element, got ${typeof testElement}`);
+      }
+      return component;
+    } catch (error) {
+      throw new Error(
+        `Failed to load component for route "${routePath}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  isAsyncComponent(comp) {
+    return comp.constructor.name === "AsyncFunction" || typeof comp === "function" && comp.toString().includes("import(");
+  }
+  isElement(value) {
+    return value instanceof Element;
+  }
+  extractComponent(result, routePath) {
+    if ("default" in result && typeof result.default === "function") {
+      return result.default;
+    }
+    if (typeof result === "function") {
+      return result;
+    }
+    if (this.isElement(result)) {
+      return () => result;
+    }
+    throw new Error(`Invalid component module for route "${routePath}"`);
+  }
+  clearErrors() {
+    this.errorCache.clear();
+  }
+  clearCache() {
+    this.componentCache.clear();
+    this.errorCache.clear();
+    this.loadingPromises.clear();
+  }
+};
+var SibuRouter = class {
+  constructor(routes, options = {}) {
+    // Event listeners cleanup
+    this.cleanup = [];
+    this.options = {
+      mode: "history",
+      base: "",
+      linkActiveClass: "router-link-active",
+      linkExactActiveClass: "router-link-exact-active",
+      fallback: true,
+      guardTimeout: 5e3,
+      cacheSize: 50,
+      errorRetryDelay: 1e3,
+      preloadStrategy: "none",
+      ...options
+    };
+    const [currentRouteState, setCurrentRouteState] = signal(this.createInitialRoute());
+    const [isReadyState, setIsReadyState] = signal(false);
+    this.currentRouteGetter = currentRouteState;
+    this.currentRouteSetter = setCurrentRouteState;
+    this.isReadyGetter = isReadyState;
+    this.isReadySetter = setIsReadyState;
+    this.matcher = new RouteMatcher(routes);
+    this.guards = new GuardManager(this.options.guardTimeout);
+    this.loader = new ComponentLoader(this.options.cacheSize, this.options.errorRetryDelay);
+    this.navigator = new NavigationController();
+    this.initialize();
+  }
+  initialize() {
+    if (this.options.mode === "history") {
+      const popstateHandler = () => this.handleLocationChange();
+      window.addEventListener("popstate", popstateHandler);
+      this.cleanup.push(() => window.removeEventListener("popstate", popstateHandler));
+    } else {
+      const hashHandler = () => this.handleLocationChange();
+      window.addEventListener("hashchange", hashHandler);
+      this.cleanup.push(() => window.removeEventListener("hashchange", hashHandler));
+    }
+    queueMicrotask(() => {
+      this.handleLocationChange();
+      this.isReadySetter(true);
+    });
+  }
+  createInitialRoute() {
+    return {
+      path: "/",
+      params: {},
+      query: {},
+      hash: "",
+      meta: {},
+      matched: []
+    };
+  }
+  handleLocationChange() {
+    const path = this.getCurrentPath();
+    const context = this.createRouteContext(path);
+    this.currentRouteSetter(context);
+  }
+  getCurrentPath() {
+    const { mode, base } = this.options;
+    if (mode === "hash") {
+      return window.location.hash.slice(1) || "/";
+    }
+    let path = window.location.pathname;
+    if (base && path.startsWith(base)) {
+      path = path.slice(base.length);
+    }
+    return (path || "/") + window.location.search + window.location.hash;
+  }
+  createRouteContext(fullPath) {
+    const [pathWithQuery, hash = ""] = fullPath.split("#");
+    const [path, queryString = ""] = pathWithQuery.split("?");
+    const query = Object.fromEntries(new URLSearchParams(queryString));
+    const match = this.matcher.match(path || "/");
+    const params = match?.params || {};
+    const meta = match?.route.meta || {};
+    const matched = match ? [match.route] : [];
+    return {
+      path: path || "/",
+      params,
+      query,
+      hash,
+      meta,
+      matched
+    };
+  }
+  // Public API
+  async navigate(to, options = {}) {
+    try {
+      await this.navigator.navigate(async (signal2) => {
+        const targetPath = this.resolvePath(to);
+        const from = this.currentRouteGetter();
+        const toContext = this.createRouteContext(targetPath);
+        if (this.isSameRoute(from, toContext)) {
+          throw new NavigationFailureError("duplicated", from, toContext);
+        }
+        await this.performNavigation(toContext, from, options, signal2);
+      });
+      return { success: true, route: this.currentRouteGetter() };
+    } catch (error) {
+      if (error instanceof NavigationFailureError) {
+        const failure2 = error.toFailure();
+        return { success: false, type: failure2.type, failure: failure2 };
+      }
+      const failure = {
+        type: "aborted",
+        from: this.currentRouteGetter(),
+        to: this.createRouteContext(this.resolvePath(to)),
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+      return { success: false, type: failure.type, failure };
+    }
+  }
+  async performNavigation(to, from, options, signal2) {
+    const beforeEachResult = await this.guards.runBeforeEach(to, from, signal2);
+    if (beforeEachResult !== true) {
+      if (typeof beforeEachResult === "string") {
+        return this.performNavigation(this.createRouteContext(beforeEachResult), from, options, signal2);
+      }
+      throw new NavigationFailureError("aborted", from, to);
+    }
+    const match = this.matcher.match(to.path);
+    if (match) {
+      const { route: route2 } = match;
+      if ("beforeEnter" in route2 && route2.beforeEnter) {
+        const guards = Array.isArray(route2.beforeEnter) ? route2.beforeEnter : [route2.beforeEnter];
+        for (const guard of guards) {
+          if (signal2.aborted) throw new Error("Navigation aborted");
+          const result = await guard(to, from);
+          if (result !== true) {
+            if (typeof result === "string") {
+              return this.performNavigation(this.createRouteContext(result), from, options, signal2);
+            }
+            throw new NavigationFailureError("aborted", from, to);
+          }
+        }
+      }
+      if ("redirect" in route2) {
+        const redirectPath = typeof route2.redirect === "function" ? route2.redirect(to) : route2.redirect;
+        if (typeof redirectPath === "string" && /^https?:\/\/|^\/\//i.test(redirectPath)) {
+          console.warn(
+            `[SibuJS Router] Redirect to absolute URL "${redirectPath}" detected. Use relative paths for safer redirects.`
+          );
+        }
+        return this.performNavigation(this.createRouteContext(redirectPath), from, options, signal2);
+      }
+    }
+    const beforeResolveResult = await this.guards.runBeforeResolve(to, from, signal2);
+    if (beforeResolveResult !== true) {
+      if (typeof beforeResolveResult === "string") {
+        return this.performNavigation(this.createRouteContext(beforeResolveResult), from, options, signal2);
+      }
+      throw new NavigationFailureError("aborted", from, to);
+    }
+    this.updateHistory(to, options);
+    this.currentRouteSetter(to);
+    this.guards.runAfterEach(to, from);
+    this.handleScrollBehavior(to, from);
+  }
+  resolvePath(to) {
+    if (typeof to === "string") return to;
+    let path = to.path || "";
+    if (to.name && !path) {
+      const namedRoute = this.matcher.findByName(to.name);
+      if (namedRoute) {
+        path = namedRoute.path;
+      }
+    }
+    if (to.params) {
+      for (const [key, value] of Object.entries(to.params)) {
+        path = path.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    if (to.query && Object.keys(to.query).length > 0) {
+      path += `?${new URLSearchParams(to.query).toString()}`;
+    }
+    if (to.hash) {
+      path += `#${to.hash}`;
+    }
+    return path;
+  }
+  isSameRoute(from, to) {
+    return from.path === to.path && JSON.stringify(from.params) === JSON.stringify(to.params) && JSON.stringify(from.query) === JSON.stringify(to.query) && from.hash === to.hash;
+  }
+  updateHistory(to, options) {
+    const fullPath = this.options.base + to.path + (Object.keys(to.query).length ? `?${new URLSearchParams(to.query).toString()}` : "") + (to.hash ? `#${to.hash}` : "");
+    if (options.replace) {
+      history.replaceState(options.state || {}, "", fullPath);
+    } else {
+      history.pushState(options.state || {}, "", fullPath);
+    }
+  }
+  handleScrollBehavior(to, from) {
+    if (this.options.scrollBehavior) {
+      const scrollTo = this.options.scrollBehavior(to, from, null);
+      if (scrollTo) {
+        requestAnimationFrame(() => {
+          window.scrollTo(scrollTo.x, scrollTo.y);
+        });
+      }
+    }
+  }
+  // Component loading
+  async loadComponent(route2, routePath) {
+    return this.loader.loadComponent(route2, routePath);
+  }
+  // Guards API
+  beforeEach(guard) {
+    return this.guards.addBeforeEach(guard);
+  }
+  beforeResolve(guard) {
+    return this.guards.addBeforeResolve(guard);
+  }
+  afterEach(hook) {
+    return this.guards.addAfterEach(hook);
+  }
+  // Utility methods
+  push(to) {
+    return this.navigate(to);
+  }
+  replace(to) {
+    return this.navigate(to, { replace: true });
+  }
+  go(delta) {
+    history.go(delta);
+  }
+  back() {
+    history.back();
+  }
+  forward() {
+    history.forward();
+  }
+  // State getters
+  get currentRoute() {
+    return this.currentRouteGetter();
+  }
+  get isReady() {
+    return this.isReadyGetter();
+  }
+  get isNavigating() {
+    return this.navigator.isNavigating;
+  }
+  // Cleanup
+  destroy() {
+    this.navigator.abort();
+    for (const fn of this.cleanup) fn();
+    this.cleanup = [];
+    this.guards.clear();
+    this.loader.clearCache();
+    this.isReadySetter(false);
+  }
+  // Cache management
+  clearCache() {
+    this.loader.clearCache();
+  }
+  clearErrorCache() {
+    this.loader.clearErrors();
+  }
+  // Route management
+  updateRoutes(routes) {
+    this.matcher.rebuild(routes);
+    this.clearCache();
+  }
+  /**
+   * Add a route dynamically at runtime.
+   */
+  addRoute(route2, parentPath) {
+    this.matcher.addRoute(route2, parentPath);
+    this.clearCache();
+  }
+  /**
+   * Remove a route by path.
+   */
+  removeRoute(path) {
+    this.matcher.removeRoute(path);
+    this.clearCache();
+  }
+  /**
+   * Get the reactive route getter for tracking.
+   */
+  get routeGetter() {
+    return this.currentRouteGetter;
+  }
+};
+var NavigationFailureError = class extends Error {
+  constructor(type, from, to, error) {
+    super(`Navigation ${type}: from ${from.path} to ${to.path}`);
+    this.name = "NavigationFailureError";
+    this.type = type;
+    this.from = from;
+    this.to = to;
+    if (error) {
+      this.cause = error;
+    }
+  }
+  toFailure() {
+    return {
+      type: this.type,
+      from: this.from,
+      to: this.to,
+      error: this.cause instanceof Error ? this.cause : void 0
+    };
+  }
+};
+var globalRouter = null;
+function createRouter(routesOrOptions, options = {}) {
+  if (globalRouter) {
+    globalRouter.destroy();
+  }
+  let routes;
+  if (Array.isArray(routesOrOptions)) {
+    routes = routesOrOptions;
+  } else {
+    options = routesOrOptions;
+    routes = [];
+  }
+  globalRouter = new SibuRouter(routes, options);
+  return globalRouter;
+}
+function setRoutes(routes) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.updateRoutes(routes);
+}
+function route() {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.currentRoute;
+}
+function router() {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return {
+    currentRoute: globalRouter.currentRoute,
+    isReady: globalRouter.isReady,
+    isNavigating: globalRouter.isNavigating,
+    push: (to) => globalRouter?.push(to),
+    replace: (to) => globalRouter?.replace(to),
+    go: (delta) => globalRouter?.go(delta),
+    back: () => globalRouter?.back(),
+    forward: () => globalRouter?.forward(),
+    beforeEach: (guard) => globalRouter?.beforeEach(guard),
+    beforeResolve: (guard) => globalRouter?.beforeResolve(guard),
+    afterEach: (hook) => globalRouter?.afterEach(hook)
+  };
+}
+function navigate(to, options) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.navigate(to, options);
+}
+function push(to) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.push(to);
+}
+function replace(to) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.replace(to);
+}
+function go(delta) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.go(delta);
+}
+function back() {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.back();
+}
+function forward() {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.forward();
+}
+function beforeEach(guard) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.beforeEach(guard);
+}
+function beforeResolve(guard) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.beforeResolve(guard);
+}
+function afterEach(hook) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter.afterEach(hook);
+}
+var routeCleanups = [];
+function Route() {
+  const anchor = document.createComment("route-outlet");
+  let currentNode = null;
+  let loadingNode = null;
+  let errorNode = null;
+  let isUpdating = false;
+  let currentPath = "";
+  const cleanupNodes = () => {
+    [currentNode, loadingNode, errorNode].forEach((node) => {
+      if (node?.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    });
+    currentNode = null;
+    loadingNode = null;
+    errorNode = null;
+  };
+  const showLoading = () => {
+    if (!loadingNode && anchor.parentNode) {
+      loadingNode = document.createElement("div");
+      loadingNode.className = "route-loading";
+      loadingNode.setAttribute("role", "status");
+      loadingNode.setAttribute("aria-label", "Loading route");
+      const spinner = document.createElement("div");
+      spinner.className = "route-loading-spinner";
+      spinner.setAttribute("aria-hidden", "true");
+      const text = document.createElement("span");
+      text.textContent = "Loading...";
+      text.className = "route-loading-text";
+      loadingNode.appendChild(spinner);
+      loadingNode.appendChild(text);
+      anchor.parentNode.insertBefore(loadingNode, anchor.nextSibling);
+    }
+  };
+  const hideLoading = () => {
+    if (loadingNode?.parentNode) {
+      loadingNode.parentNode.removeChild(loadingNode);
+      loadingNode = null;
+    }
+  };
+  const showError = (error) => {
+    if (!anchor.parentNode) return;
+    cleanupNodes();
+    errorNode = document.createElement("div");
+    errorNode.className = "route-error";
+    errorNode.setAttribute("role", "alert");
+    errorNode.setAttribute("aria-live", "assertive");
+    const title = document.createElement("h3");
+    title.textContent = "Route Error";
+    title.className = "route-error-title";
+    const message = document.createElement("p");
+    message.textContent = error.message || "Failed to load route component";
+    message.className = "route-error-message";
+    const retryButton = document.createElement("button");
+    retryButton.textContent = "Retry";
+    retryButton.className = "route-error-retry";
+    retryButton.type = "button";
+    retryButton.addEventListener("click", () => {
+      if (globalRouter) {
+        globalRouter.clearErrorCache();
+        update();
+      }
+    });
+    errorNode.appendChild(title);
+    errorNode.appendChild(message);
+    errorNode.appendChild(retryButton);
+    anchor.parentNode.insertBefore(errorNode, anchor.nextSibling);
+  };
+  let pendingUpdate = false;
+  const update = async () => {
+    if (!globalRouter) return;
+    if (isUpdating) {
+      pendingUpdate = true;
+      return;
+    }
+    const route2 = globalRouter.currentRoute;
+    if (route2.path === currentPath && currentNode) return;
+    isUpdating = true;
+    currentPath = route2.path;
+    try {
+      const match = globalRouter["matcher"].match(route2.path);
+      if (!match) {
+        cleanupNodes();
+        return;
+      }
+      const { route: routeDef } = match;
+      if ("redirect" in routeDef) {
+        const redirectPath = typeof routeDef.redirect === "function" ? routeDef.redirect(route2) : routeDef.redirect;
+        queueMicrotask(() => globalRouter?.navigate(redirectPath));
+        return;
+      }
+      if ("component" in routeDef) {
+        try {
+          const isAsync = routeDef.component.constructor.name === "AsyncFunction" || routeDef.component.toString().includes("import(");
+          if (isAsync) {
+            showLoading();
+          }
+          const component = await globalRouter.loadComponent(routeDef, route2.path);
+          const node = component();
+          if (node && anchor.parentNode && route2.path === currentPath) {
+            cleanupNodes();
+            anchor.parentNode.insertBefore(node, anchor.nextSibling);
+            currentNode = node;
+          }
+        } catch (error) {
+          hideLoading();
+          console.error("[Route] Component error:", error);
+          showError(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    } catch (error) {
+      console.error("[Route] Update failed:", error);
+      showError(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      isUpdating = false;
+      if (pendingUpdate) {
+        pendingUpdate = false;
+        update();
+      }
+    }
+  };
+  let routeInitialized = false;
+  const originalUpdate = update;
+  const wrappedUpdate = async () => {
+    await originalUpdate();
+    routeInitialized = true;
+  };
+  track(wrappedUpdate);
+  if (!routeInitialized) {
+    queueMicrotask(() => {
+      if (!routeInitialized && anchor.parentNode) wrappedUpdate();
+    });
+  }
+  routeCleanups.push(cleanupNodes);
+  return anchor;
+}
+function RouterLink(props) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  const { to, replace: replace2 = false, activeClass, exactActiveClass, nodes, target, rel, ...attrs } = props;
+  const route2 = globalRouter.currentRoute;
+  const href = globalRouter["resolvePath"](to);
+  const isActive = route2.path.startsWith(href.split("?")[0].split("#")[0]);
+  const isExactActive = route2.path === href.split("?")[0].split("#")[0];
+  const link = document.createElement("a");
+  link.href = href;
+  if (target) {
+    link.target = target;
+    if (target === "_blank") {
+      link.rel = rel ? `${rel} noopener noreferrer` : "noopener noreferrer";
+    } else if (rel) {
+      link.rel = rel;
+    }
+  } else if (rel) {
+    link.rel = rel;
+  }
+  const classes = [];
+  const options = globalRouter["options"];
+  if (isActive) {
+    if (activeClass) classes.push(activeClass);
+    else if (options.linkActiveClass) classes.push(options.linkActiveClass);
+  }
+  if (isExactActive) {
+    if (exactActiveClass) classes.push(exactActiveClass);
+    else if (options.linkExactActiveClass) classes.push(options.linkExactActiveClass);
+  }
+  if (classes.length > 0) {
+    link.className = classes.join(" ");
+  }
+  Object.entries(attrs).forEach(([key, value]) => {
+    if (key.startsWith("on") || key === "href") return;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      link.setAttribute(key, String(value));
+    }
+  });
+  if (typeof nodes === "string") {
+    link.textContent = nodes;
+  } else if (nodes instanceof Node) {
+    link.appendChild(nodes);
+  } else if (Array.isArray(nodes)) {
+    nodes.forEach((child) => {
+      if (typeof child === "string") {
+        link.appendChild(document.createTextNode(child));
+      } else if (child instanceof Node) {
+        link.appendChild(child);
+      }
+    });
+  }
+  link.addEventListener("click", (e) => {
+    if (target || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) {
+      return;
+    }
+    e.preventDefault();
+    globalRouter?.navigate(to, { replace: replace2 });
+  });
+  return link;
+}
+function Suspense(props) {
+  const anchor = document.createComment("suspense-boundary");
+  let currentNode = null;
+  let fallbackNode = null;
+  let isLoading = false;
+  const cleanupNodes = () => {
+    [currentNode, fallbackNode].forEach((node) => {
+      if (node?.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    });
+    currentNode = null;
+    fallbackNode = null;
+  };
+  const showFallback = () => {
+    if (fallbackNode || !props.fallback || !anchor.parentNode) return;
+    try {
+      const fallback = typeof props.fallback === "function" ? props.fallback() : props.fallback;
+      if (fallback instanceof HTMLElement) {
+        fallbackNode = fallback;
+        anchor.parentNode.insertBefore(fallbackNode, anchor.nextSibling);
+      }
+    } catch (error) {
+      console.error("[Suspense] Fallback error:", error);
+    }
+  };
+  const hideFallback = () => {
+    if (fallbackNode?.parentNode) {
+      fallbackNode.parentNode.removeChild(fallbackNode);
+      fallbackNode = null;
+    }
+  };
+  const render = async () => {
+    if (isLoading) return;
+    isLoading = true;
+    try {
+      const result = props.nodes();
+      if (result instanceof Promise) {
+        showFallback();
+        const element = await result;
+        if (anchor.parentNode) {
+          cleanupNodes();
+          anchor.parentNode.insertBefore(element, anchor.nextSibling);
+          currentNode = element;
+        }
+      } else {
+        if (anchor.parentNode) {
+          cleanupNodes();
+          anchor.parentNode.insertBefore(result, anchor.nextSibling);
+          currentNode = result;
+        }
+      }
+    } catch (error) {
+      hideFallback();
+      console.error("[Suspense] Nodes error:", error);
+      if (anchor.parentNode) {
+        const errorElement = document.createElement("div");
+        errorElement.className = "suspense-error";
+        errorElement.textContent = error instanceof Error ? error.message : "Failed to load";
+        cleanupNodes();
+        anchor.parentNode.insertBefore(errorElement, anchor.nextSibling);
+        currentNode = errorElement;
+      }
+    } finally {
+      isLoading = false;
+    }
+  };
+  queueMicrotask(render);
+  return anchor;
+}
+function lazy(importFn) {
+  return importFn;
+}
+async function preloadRoute(to) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  const path = globalRouter["resolvePath"](to);
+  const match = globalRouter["matcher"].match(path.split("?")[0].split("#")[0]);
+  if (match && "component" in match.route) {
+    try {
+      await globalRouter.loadComponent(match.route, path);
+    } catch (error) {
+      console.warn("[Router] Preload failed:", error);
+    }
+  }
+}
+function hasRoute(name) {
+  if (!globalRouter) return false;
+  return globalRouter["matcher"].findByName(name) !== null;
+}
+function getRouteInfo(name) {
+  if (!globalRouter) return null;
+  return globalRouter["matcher"].findByName(name);
+}
+function buildURL(to) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  return globalRouter["resolvePath"](to);
+}
+function destroyRouter() {
+  for (const fn of routeCleanups) fn();
+  routeCleanups.length = 0;
+  if (globalRouter) {
+    globalRouter.destroy();
+    globalRouter = null;
+  }
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("beforeunload", () => {
+    destroyRouter();
+  });
+}
+function Outlet() {
+  const anchor = document.createComment("route-outlet-nested");
+  let currentNode = null;
+  const update = async () => {
+    if (!globalRouter) return;
+    const route2 = globalRouter.currentRoute;
+    if (route2.matched.length < 2) return;
+    const childRoute = route2.matched[route2.matched.length - 1];
+    if (!childRoute || !("component" in childRoute)) return;
+    try {
+      const component = await globalRouter.loadComponent(childRoute, route2.path);
+      const node = component();
+      if (node && anchor.parentNode) {
+        if (currentNode?.parentNode) {
+          currentNode.parentNode.removeChild(currentNode);
+        }
+        anchor.parentNode.insertBefore(node, anchor.nextSibling);
+        currentNode = node;
+      }
+    } catch (error) {
+      console.error("[Outlet] Failed to render child route:", error);
+    }
+  };
+  track(update);
+  if (!anchor.parentNode) {
+    queueMicrotask(() => {
+      if (anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+function addRoute(route2, parentPath) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.addRoute(route2, parentPath);
+}
+function removeRoute(path) {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  globalRouter.removeRoute(path);
+}
+function routerState() {
+  if (!globalRouter) throw new Error("Router not initialized. Call createRouter() first.");
+  const router2 = globalRouter;
+  return {
+    currentPath: () => router2.currentRoute.path,
+    params: () => router2.currentRoute.params,
+    query: () => router2.currentRoute.query,
+    hash: () => router2.currentRoute.hash,
+    meta: () => router2.currentRoute.meta,
+    isNavigating: router2.isNavigating,
+    isReady: router2.isReady
+  };
+}
+var routerPlugins = [];
+function routerPlugin(plugin) {
+  routerPlugins.push(plugin);
+  if (globalRouter?.isReady && plugin.onReady) {
+    plugin.onReady();
+  }
+  let removeGuard = null;
+  if (globalRouter && plugin.onNavigate) {
+    removeGuard = globalRouter.afterEach((to, from) => {
+      plugin.onNavigate?.(to, from);
+    });
+  }
+  return () => {
+    const idx = routerPlugins.indexOf(plugin);
+    if (idx !== -1) routerPlugins.splice(idx, 1);
+    removeGuard?.();
+  };
+}
+var _routeTransitionOptions = null;
+function setRouteTransition(options) {
+  _routeTransitionOptions = options;
+}
+function getRouteTransition() {
+  return _routeTransitionOptions;
+}
+function createMemoryRouter(routes, _initialPath = "/") {
+  const router2 = createRouter(routes, { mode: "hash" });
+  return {
+    router: router2,
+    currentPath: () => router2.currentRoute.path,
+    push: (path) => router2.push(path)
+  };
+}
+
+// src/plugins/routerSSR.ts
+function parseURL(url) {
+  let remaining = url;
+  let hash = "";
+  let queryString = "";
+  const hashIndex = remaining.indexOf("#");
+  if (hashIndex !== -1) {
+    hash = remaining.slice(hashIndex + 1);
+    remaining = remaining.slice(0, hashIndex);
+  }
+  const queryIndex = remaining.indexOf("?");
+  if (queryIndex !== -1) {
+    queryString = remaining.slice(queryIndex + 1);
+    remaining = remaining.slice(0, queryIndex);
+  }
+  const path = remaining || "/";
+  const query = {};
+  if (queryString) {
+    const pairs = queryString.split("&");
+    for (const pair of pairs) {
+      if (!pair) continue;
+      const eqIndex = pair.indexOf("=");
+      if (eqIndex === -1) {
+        query[decodeURIComponent(pair)] = "";
+      } else {
+        const key = decodeURIComponent(pair.slice(0, eqIndex));
+        const value = decodeURIComponent(pair.slice(eqIndex + 1));
+        query[key] = value;
+      }
+    }
+  }
+  return { path, query, hash };
+}
+function compilePattern(routePath) {
+  const keys = [];
+  let pattern = "";
+  const segments = routePath.split("/");
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (i > 0) pattern += "\\/";
+    if (!segment) {
+      continue;
+    }
+    if (segment === "*") {
+      keys.push("pathMatch");
+      pattern += "(.*)";
+      continue;
+    }
+    const namedWildcardMatch = segment.match(/^:([^*]+)\*$/);
+    if (namedWildcardMatch) {
+      keys.push(namedWildcardMatch[1]);
+      pattern += "(.*)";
+      continue;
+    }
+    const optionalMatch = segment.match(/^:([^?]+)\?$/);
+    if (optionalMatch) {
+      keys.push(optionalMatch[1]);
+      pattern = pattern.replace(/\\\/$/g, "");
+      pattern += "(?:\\/([^\\/]+))?";
+      continue;
+    }
+    const paramMatch = segment.match(/^:(.+)$/);
+    if (paramMatch) {
+      keys.push(paramMatch[1]);
+      pattern += "([^\\/]+)";
+      continue;
+    }
+    pattern += segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return {
+    regex: new RegExp(`^${pattern}$`),
+    keys
+  };
+}
+function matchRoute(path, routes, parentPath = "", parentChain = []) {
+  for (const route2 of routes) {
+    const fullPath = normalizePath(`${parentPath}/${route2.path}`);
+    if (route2.children && route2.children.length > 0) {
+      const childResult = matchRoute(path, route2.children, fullPath, [...parentChain, route2]);
+      if (childResult) {
+        return childResult;
+      }
+    }
+    const compiled = compilePattern(fullPath);
+    const match = path.match(compiled.regex);
+    if (match) {
+      const params = {};
+      for (let i = 0; i < compiled.keys.length; i++) {
+        if (match[i + 1] !== void 0) {
+          params[compiled.keys[i]] = decodeURIComponent(match[i + 1]);
+        }
+      }
+      return {
+        route: route2,
+        params,
+        matched: [...parentChain, route2]
+      };
+    }
+  }
+  return null;
+}
+function normalizePath(path) {
+  let normalized = path.replace(/\/+/g, "/");
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+var SSR_ROUTE_STATE_KEY = "__SIBU_ROUTE_STATE__";
+var MAX_REDIRECT_DEPTH = 10;
+function resolveServerRoute(url, routes) {
+  return resolveServerRouteInternal(url, routes, 0);
+}
+function resolveServerRouteInternal(url, routes, depth) {
+  const { path, query, hash } = parseURL(url);
+  const normalizedPath = normalizePath(path);
+  const match = matchRoute(normalizedPath, routes);
+  if (!match) {
+    return {
+      route: {
+        path: normalizedPath,
+        params: {},
+        query,
+        hash,
+        meta: {}
+      },
+      component: null
+    };
+  }
+  const { route: matchedDef, params } = match;
+  if (matchedDef.redirect) {
+    if (depth >= MAX_REDIRECT_DEPTH) {
+      return {
+        route: {
+          path: normalizedPath,
+          params,
+          query,
+          hash,
+          meta: matchedDef.meta || {},
+          name: matchedDef.name
+        },
+        component: null,
+        redirect: matchedDef.redirect
+      };
+    }
+    if (typeof matchedDef.redirect === "string" && /^https?:\/\/|^\/\//i.test(matchedDef.redirect)) {
+      console.warn(
+        `[SibuJS Router SSR] Redirect to absolute URL "${matchedDef.redirect}" detected. Use relative paths for safer redirects.`
+      );
+    }
+    return resolveServerRouteInternal(matchedDef.redirect, routes, depth + 1);
+  }
+  const routeState = {
+    path: normalizedPath,
+    params,
+    query,
+    hash,
+    meta: matchedDef.meta || {},
+    name: matchedDef.name
+  };
+  return {
+    route: routeState,
+    component: matchedDef.component || null,
+    redirect: void 0
+  };
+}
+function renderRouteToString(url, routes, _options) {
+  const resolved = resolveServerRoute(url, routes);
+  let html = "";
+  if (resolved.component) {
+    const element = resolved.component();
+    html = renderToString(element);
+  }
+  return {
+    html,
+    state: resolved.route
+  };
+}
+function renderRouteToDocument(url, routes, options) {
+  const { html, state } = renderRouteToString(url, routes, options);
+  const opts = options || {};
+  const metaTags = (opts.meta || []).map(
+    (attrs) => `<meta ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const linkTags = (opts.links || []).map(
+    (attrs) => `<link ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const scriptTags = (opts.scripts || []).map((src) => `<script src="${escapeAttr(src)}"></script>`).join("\n    ");
+  const stateScript = serializeRouteState(state);
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    ${opts.title ? `<title>${escapeHtml(opts.title)}</title>` : ""}
+    ${metaTags}
+    ${linkTags}
+    ${opts.headExtra || ""}
+  </head>
+  <body>
+    <div id="app">${html}</div>
+    ${stateScript}
+    ${scriptTags}
+  </body>
+</html>`;
+}
+function serializeRouteState(state) {
+  const json = JSON.stringify(state).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return `<script>window.${SSR_ROUTE_STATE_KEY}=${json}</script>`;
+}
+function deserializeRouteState() {
+  if (typeof window === "undefined") return void 0;
+  return window[SSR_ROUTE_STATE_KEY];
+}
+function hydrateRouter(routes, options) {
+  const serverState = deserializeRouteState();
+  if (!serverState) {
+    createRouter(routes);
+    return;
+  }
+  createRouter(routes);
+  const container = options?.container || document.getElementById("app");
+  if (container && serverState.path) {
+    const resolved = resolveServerRoute(serverState.path, routes);
+    if (resolved.component) {
+      import("./ssr-YQJ4AYBD.js").then(({ hydrate }) => {
+        if (resolved.component) {
+          hydrate(resolved.component, container);
+        }
+      });
+    }
+  }
+}
+function createSSRRouter(routes) {
+  return {
+    resolve(url) {
+      return resolveServerRoute(url, routes);
+    },
+    renderToString(url) {
+      return renderRouteToString(url, routes);
+    },
+    renderToDocument(url, options) {
+      return renderRouteToDocument(url, routes, options);
+    }
+  };
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export {
+  Outlet,
+  Route,
+  RouterLink,
+  SibuRouter,
+  Suspense,
+  Trans,
+  addRoute,
+  afterEach,
+  back,
+  beforeEach,
+  beforeResolve,
+  buildURL,
+  createMemoryRouter,
+  createRouter,
+  createSSRRouter,
+  deserializeRouteState,
+  destroyRouter,
+  forward,
+  getAvailableLocales,
+  getLocale,
+  getRouteInfo,
+  getRouteTransition,
+  go,
+  hasRoute,
+  hasTranslation,
+  hydrateRouter,
+  lazy,
+  navigate,
+  preloadRoute,
+  push,
+  registerTranslations,
+  removeRoute,
+  renderRouteToDocument,
+  renderRouteToString,
+  replace,
+  resolveServerRoute,
+  route,
+  router,
+  routerPlugin,
+  routerState,
+  serializeRouteState,
+  setLocale,
+  setRouteTransition,
+  setRoutes,
+  t
+};