stx-router 0.2.8

package/dist/index.js

@@ -0,0 +1,887 @@
+// @bun
+// src/file-router.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// src/codegen.ts
+import fs from "fs";
+import path from "path";
+function generateRouteTypes(routes, outputDir) {
+  const lines = [
+    "// Auto-generated by STX - do not edit",
+    'declare module "stx/routes" {',
+    "  interface RouteMap {"
+  ];
+  for (const route of routes) {
+    const paramEntries = [];
+    for (const p of route.params) {
+      const type = route.pattern.includes(`:${p}*`) ? "string[]" : "string";
+      paramEntries.push(`${p}: ${type}`);
+    }
+    const paramsStr = paramEntries.join("; ");
+    lines.push(`    '${route.pattern}': { ${paramsStr} }`);
+  }
+  lines.push("  }", "}", "");
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(path.join(outputDir, "route-types.d.ts"), lines.join(`
+`));
+}
+
+// src/matcher.ts
+import path2 from "path";
+function filePathToPattern(filePath, pagesDir) {
+  const relativePath = path2.relative(pagesDir, filePath);
+  let route = relativePath.replace(/\.(stx|md)$/, "");
+  route = route.split(path2.sep).join("/");
+  if (route === "index") {
+    return "/";
+  }
+  if (route.endsWith("/index")) {
+    route = route.slice(0, -6);
+  }
+  route = route.replace(/\[\[([^\]]+)\]\]/g, ":$1?");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/:\.\.\.([^/]+)/g, ":$1*");
+  return `/${route}`;
+}
+function patternToRegex(pattern) {
+  const params = [];
+  let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  regexStr = regexStr.replace(/\/:([^/]+)\?/g, (_, name) => {
+    params.push(name);
+    return "(?:/([^/]+))?";
+  });
+  regexStr = regexStr.replace(/:([^/]+)\*/g, (_, name) => {
+    params.push(name);
+    return "(.+)";
+  });
+  regexStr = regexStr.replace(/:([^/]+)/g, (_, name) => {
+    params.push(name);
+    return "([^/]+)";
+  });
+  regexStr = `^${regexStr}$`;
+  return { regex: new RegExp(regexStr), params };
+}
+function matchRoute(pathname, routes) {
+  const normalizedPath = pathname === "" ? "/" : pathname;
+  for (const route of routes) {
+    const match = normalizedPath.match(route.regex);
+    if (match) {
+      const params = {};
+      route.params.forEach((name, index) => {
+        params[name] = match[index + 1];
+      });
+      return { route, params };
+    }
+  }
+  return null;
+}
+
+// src/nested-layouts.ts
+import fs2 from "fs";
+import path3 from "path";
+function resolveLayoutChain(routeFilePath, pagesDir) {
+  const layouts = [];
+  let dir = path3.dirname(routeFilePath);
+  while (dir.startsWith(pagesDir) || dir === pagesDir) {
+    const layoutFile = path3.join(dir, "_layout.stx");
+    if (fs2.existsSync(layoutFile)) {
+      layouts.unshift(layoutFile);
+    }
+    if (dir === pagesDir)
+      break;
+    dir = path3.dirname(dir);
+  }
+  return layouts;
+}
+
+// src/file-router.ts
+function scanDirectory(dir, extensions) {
+  const files = [];
+  if (!fs3.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      files.push(...scanDirectory(fullPath, extensions));
+    } else if (entry.isFile()) {
+      const ext = path4.extname(entry.name);
+      if (extensions.includes(ext)) {
+        if (entry.name.startsWith("_") && entry.name !== "_layout.stx") {
+          continue;
+        }
+        if (entry.name === "_layout.stx") {
+          continue;
+        }
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+class Router {
+  routes;
+  pagesDir;
+  config;
+  constructor(baseDir, config = {}) {
+    this.config = config;
+    this.pagesDir = path4.resolve(baseDir, config.pagesDir || "pages");
+    const extensions = config.extensions || [".stx"];
+    const files = scanDirectory(this.pagesDir, extensions);
+    this.routes = files.map((filePath) => {
+      const pattern = filePathToPattern(filePath, this.pagesDir);
+      const { regex, params } = patternToRegex(pattern);
+      const layouts = config.layouts !== false ? resolveLayoutChain(filePath, this.pagesDir) : [];
+      return {
+        pattern,
+        regex,
+        params,
+        filePath,
+        isDynamic: params.length > 0,
+        layout: layouts.length > 0 ? layouts[layouts.length - 1] : undefined
+      };
+    });
+    this.routes.sort((a, b) => {
+      if (!a.isDynamic && b.isDynamic)
+        return -1;
+      if (a.isDynamic && !b.isDynamic)
+        return 1;
+      const aSegments = a.pattern.split("/").length;
+      const bSegments = b.pattern.split("/").length;
+      if (aSegments !== bSegments)
+        return bSegments - aSegments;
+      return a.pattern.localeCompare(b.pattern);
+    });
+    const stxDir = path4.join(baseDir, ".stx");
+    generateRouteTypes(this.routes, stxDir);
+  }
+  match(pathname) {
+    const normalizedPath = pathname === "" ? "/" : pathname;
+    for (const route of this.routes) {
+      const m = normalizedPath.match(route.regex);
+      if (m) {
+        const params = {};
+        route.params.forEach((name, index) => {
+          params[name] = m[index + 1];
+        });
+        return { route, params };
+      }
+    }
+    return null;
+  }
+  resolve(name, params) {
+    const route = this.routes.find((r) => r.pattern === name || r.filePath.includes(name));
+    if (!route)
+      return "#not-found";
+    let resolved = route.pattern;
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        resolved = resolved.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    return resolved;
+  }
+  addRoute(route) {
+    this.routes.push(route);
+    this.routes.sort((a, b) => {
+      if (!a.isDynamic && b.isDynamic)
+        return -1;
+      if (a.isDynamic && !b.isDynamic)
+        return 1;
+      return a.pattern.localeCompare(b.pattern);
+    });
+  }
+  getLayout(route) {
+    return route.layout ?? null;
+  }
+}
+function createRouter(baseDir, config) {
+  return new Router(baseDir, config);
+}
+function findErrorPage(pagesDir, statusCode) {
+  const candidates = [`${statusCode}.stx`, "error.stx"];
+  for (const candidate of candidates) {
+    const filePath = path4.join(pagesDir, candidate);
+    if (fs3.existsSync(filePath))
+      return filePath;
+  }
+  return null;
+}
+function formatRoutes(routes, baseDir) {
+  return routes.map((route) => {
+    const relativePath = path4.relative(baseDir, route.filePath);
+    const dynamicLabel = route.isDynamic ? " (dynamic)" : "";
+    return `${route.pattern} \u2192 ${relativePath}${dynamicLabel}`;
+  });
+}
+// src/named-routes.ts
+var routes = {};
+var appUrl = "";
+function setAppUrl(url) {
+  appUrl = url.replace(/\/$/, "");
+}
+function defineRoute(name, routePath, params = {}) {
+  routes[name] = { path: routePath, name, params };
+}
+function defineRoutes(routeDefinitions) {
+  for (const [name, definition] of Object.entries(routeDefinitions)) {
+    if (typeof definition === "string") {
+      routes[name] = { path: definition, name };
+    } else {
+      routes[name] = { ...definition, name };
+    }
+  }
+}
+function route(name, params = {}, absolute = false) {
+  const r = routes[name];
+  if (!r) {
+    console.warn(`Route [${name}] not defined.`);
+    return "#undefined-route";
+  }
+  const mergedParams = { ...r.params, ...params };
+  let routePath = r.path;
+  routePath = routePath.replace(/:(\w+)/g, (_, paramName) => {
+    const value = mergedParams[paramName];
+    if (value === undefined) {
+      console.warn(`Missing parameter [${paramName}] for route [${name}].`);
+      return `:${paramName}`;
+    }
+    delete mergedParams[paramName];
+    return encodeURIComponent(String(value));
+  });
+  const remainingParams = Object.entries(mergedParams);
+  if (remainingParams.length > 0) {
+    const queryString = remainingParams.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+    routePath += (routePath.includes("?") ? "&" : "?") + queryString;
+  }
+  return absolute && appUrl ? `${appUrl}${routePath}` : routePath;
+}
+function resetRoutes() {
+  for (const key of Object.keys(routes)) {
+    delete routes[key];
+  }
+  appUrl = "";
+}
+// src/middleware.ts
+import fs4 from "fs";
+import path5 from "path";
+function navigateTo(navPath, options = {}) {
+  return {
+    type: "redirect",
+    path: navPath,
+    options: {
+      replace: options.replace ?? false,
+      external: options.external ?? false,
+      redirectCode: options.redirectCode ?? 302
+    }
+  };
+}
+function abortNavigation(error) {
+  const normalizedError = typeof error === "string" ? { statusCode: 500, message: error } : error;
+  return {
+    type: "abort",
+    error: normalizedError
+  };
+}
+function defineMiddleware(handler, options = {}) {
+  return {
+    handler,
+    mode: options.mode ?? "universal"
+  };
+}
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  if (!cookieHeader)
+    return cookies;
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const [name, ...rest] = pair.split("=");
+    if (name) {
+      const key = name.trim();
+      const value = rest.join("=").trim();
+      if (key) {
+        cookies[key] = decodeURIComponent(value);
+      }
+    }
+  }
+  return cookies;
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.expires) {
+    const expires = typeof options.expires === "number" ? new Date(Date.now() + options.expires * 1000) : options.expires;
+    cookie += `; Expires=${expires.toUTCString()}`;
+  }
+  if (options.path)
+    cookie += `; Path=${options.path}`;
+  if (options.domain)
+    cookie += `; Domain=${options.domain}`;
+  if (options.secure)
+    cookie += "; Secure";
+  if (options.httpOnly)
+    cookie += "; HttpOnly";
+  if (options.sameSite)
+    cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
+}
+function createServerCookieManager(request, responseHeaders) {
+  const cookieHeader = request.headers.get("cookie") || "";
+  const cookies = parseCookies(cookieHeader);
+  return {
+    get(name) {
+      return cookies[name];
+    },
+    set(name, value, options = {}) {
+      cookies[name] = value;
+      responseHeaders.append("Set-Cookie", serializeCookie(name, value, options));
+    },
+    delete(name) {
+      delete cookies[name];
+      responseHeaders.append("Set-Cookie", serializeCookie(name, "", { expires: new Date(0), path: "/" }));
+    },
+    getAll() {
+      return { ...cookies };
+    }
+  };
+}
+function createClientCookieManager() {
+  return {
+    get(name) {
+      if (typeof document === "undefined")
+        return;
+      const cookies = parseCookies(document.cookie);
+      return cookies[name];
+    },
+    set(name, value, options = {}) {
+      if (typeof document === "undefined")
+        return;
+      document.cookie = serializeCookie(name, value, options);
+    },
+    delete(name) {
+      if (typeof document === "undefined")
+        return;
+      document.cookie = serializeCookie(name, "", { expires: new Date(0), path: "/" });
+    },
+    getAll() {
+      if (typeof document === "undefined")
+        return {};
+      return parseCookies(document.cookie);
+    }
+  };
+}
+function createStorageManager() {
+  const available = typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+  return {
+    get(key) {
+      if (!available)
+        return null;
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    set(key, value) {
+      if (!available)
+        return;
+      try {
+        window.localStorage.setItem(key, value);
+      } catch {}
+    },
+    remove(key) {
+      if (!available)
+        return;
+      try {
+        window.localStorage.removeItem(key);
+      } catch {}
+    },
+    isAvailable() {
+      return available;
+    }
+  };
+}
+var middlewareRegistry = new Map;
+function registerMiddleware(name, middleware) {
+  middlewareRegistry.set(name, middleware);
+}
+function getMiddleware(name) {
+  return middlewareRegistry.get(name);
+}
+function hasMiddleware(name) {
+  return middlewareRegistry.has(name);
+}
+function clearMiddleware() {
+  middlewareRegistry.clear();
+}
+function getMiddlewareNames() {
+  return Array.from(middlewareRegistry.keys());
+}
+async function loadMiddlewareFromDirectory(baseDir, middlewareDir = "middleware") {
+  const fullPath = path5.resolve(baseDir, middlewareDir);
+  if (!fs4.existsSync(fullPath)) {
+    return;
+  }
+  const files = fs4.readdirSync(fullPath);
+  for (const file of files) {
+    if (!file.endsWith(".ts") && !file.endsWith(".js"))
+      continue;
+    if (file.includes(".test.") || file.includes(".spec."))
+      continue;
+    const name = file.replace(/\.(ts|js)$/, "");
+    const filePath = path5.join(fullPath, file);
+    try {
+      const mod = await import(filePath);
+      const mw = mod.default;
+      if (mw && typeof mw.handler === "function") {
+        registerMiddleware(name, mw);
+      } else if (typeof mw === "function") {
+        registerMiddleware(name, { handler: mw, mode: "universal" });
+      }
+    } catch (error) {
+      console.warn(`Failed to load middleware '${name}' from ${filePath}:`, error);
+    }
+  }
+}
+function parseQuery(search) {
+  const query = {};
+  if (!search)
+    return query;
+  const params = new URLSearchParams(search);
+  for (const [key, value] of params) {
+    query[key] = value;
+  }
+  return query;
+}
+function createRouteLocation(pathname, params, meta, search = "") {
+  return {
+    path: pathname,
+    params,
+    query: parseQuery(search),
+    fullPath: search ? `${pathname}?${search}` : pathname,
+    meta
+  };
+}
+function createMiddlewareContext(to, from, request) {
+  const isServer = typeof window === "undefined";
+  const isClient = !isServer;
+  const responseHeaders = new Headers;
+  return {
+    to,
+    from,
+    isClient,
+    isServer,
+    cookies: isServer && request ? createServerCookieManager(request, responseHeaders) : createClientCookieManager(),
+    storage: createStorageManager(),
+    state: {},
+    request,
+    responseHeaders
+  };
+}
+async function runMiddleware(middlewareNames, context) {
+  const names = Array.isArray(middlewareNames) ? middlewareNames : [middlewareNames];
+  const isServer = context.isServer;
+  for (const name of names) {
+    const middleware = getMiddleware(name);
+    if (!middleware) {
+      console.warn(`Middleware '${name}' not found`);
+      continue;
+    }
+    if (middleware.mode === "server" && !isServer)
+      continue;
+    if (middleware.mode === "client" && isServer)
+      continue;
+    try {
+      const result = await middleware.handler(context);
+      if (result) {
+        if (result.type === "redirect") {
+          return {
+            passed: false,
+            redirect: result,
+            state: context.state,
+            responseHeaders: context.responseHeaders
+          };
+        }
+        if (result.type === "abort") {
+          return {
+            passed: false,
+            abort: result,
+            state: context.state,
+            responseHeaders: context.responseHeaders
+          };
+        }
+      }
+    } catch (error) {
+      console.error(`Error in middleware '${name}':`, error);
+      return {
+        passed: false,
+        abort: {
+          type: "abort",
+          error: {
+            statusCode: 500,
+            message: error instanceof Error ? error.message : "Middleware error"
+          }
+        },
+        state: context.state,
+        responseHeaders: context.responseHeaders
+      };
+    }
+  }
+  return {
+    passed: true,
+    state: context.state,
+    responseHeaders: context.responseHeaders
+  };
+}
+// src/client.ts
+function getRouterScript() {
+  return `
+;(function(){
+  'use strict';
+  if(window.__stxRouter)return;
+
+  // \u2500\u2500 Configuration \u2500\u2500
+  var defaults={container:'main',loadingClass:'stx-navigating',viewTransitions:true,cache:true,scrollToTop:true,prefetch:true};
+  var o=Object.assign({},defaults,window.__stxRouterConfig||{},window.STX_ROUTER_OPTIONS||{});
+  var containerSel=o.container;
+
+  var cache={};
+  var prefetching={};
+  var isNavigating=false;
+
+  function getContainer(){
+    return document.querySelector(containerSel)||document.querySelector('[data-stx-content]')||document.querySelector('main');
+  }
+
+  // \u2500\u2500 Navigation \u2500\u2500
+  function navigate(url,pushState){
+    if(isNavigating)return;
+    var t=new URL(url,location.origin);
+
+    // Different origin \u2192 full navigation
+    if(t.origin!==location.origin){location.href=url;return}
+
+    // Hash-only navigation on same page
+    if(t.pathname===location.pathname&&t.hash){
+      if(pushState!==false)history.pushState({},'',t.href);
+      var el=document.querySelector(t.hash);
+      if(el)el.scrollIntoView({behavior:'smooth'});
+      return;
+    }
+
+    // Same page, no hash \u2192 skip
+    if(t.href===location.href&&!t.hash)return;
+
+    isNavigating=true;
+    document.body.classList.add(o.loadingClass);
+
+    var targetHref=t.href;
+    var targetPath=t.pathname;
+    var targetHash=t.hash;
+
+    function done(){isNavigating=false;document.body.classList.remove(o.loadingClass)}
+
+    if(o.cache&&cache[targetPath]){
+      swap(cache[targetPath],targetPath,pushState,targetHash);
+      done();
+    }else{
+      fetch(url,{headers:{'X-STX-Router':'true','Accept':'text/html'}}).then(function(r){
+        if(!r.ok)throw new Error(r.status);
+        return r.text();
+      }).then(function(html){
+        if(o.cache)cache[targetPath]=html;
+        swap(html,targetPath,pushState,targetHash);
+      }).catch(function(){
+        location.href=url;
+      }).finally(done);
+    }
+  }
+
+  function swap(html,url,pushState,hash){
+    var parser=new DOMParser();
+    var doc=parser.parseFromString(html,'text/html');
+    var newContent=doc.querySelector(containerSel)||doc.querySelector('[data-stx-content]')||doc.querySelector('main');
+    var currentContent=getContainer();
+    if(!newContent||!currentContent){location.href=url;return}
+
+    // Clean up existing signals/effects
+    if(window.stx&&window.stx._cleanupContainer){
+      window.stx._cleanupContainer(currentContent);
+    }
+
+    function doSwap(){
+      // \u2500\u2500 Swap <head> styles \u2500\u2500
+      // Inject new styles FIRST, then remove old to prevent unstyled flash
+      var keepIds={'stx-view-transitions':1,'stx-r-css':1};
+      var curStyles=document.querySelectorAll('head style');
+      var newStyles=doc.querySelectorAll('head style');
+
+      var incoming=[];
+      newStyles.forEach(function(s){
+        if(!keepIds[s.id]){
+          var ns=document.createElement('style');
+          ns.textContent=s.textContent;
+          ns.setAttribute('data-stx-incoming','');
+          if(s.getAttribute('data-crosswind'))ns.setAttribute('data-crosswind',s.getAttribute('data-crosswind'));
+          document.head.appendChild(ns);
+          incoming.push(ns);
+        }
+      });
+
+      // Remove old styles (except persistent ones and incoming)
+      curStyles.forEach(function(s){
+        if(!keepIds[s.id]&&!s.hasAttribute('data-stx-incoming'))s.remove();
+      });
+
+      incoming.forEach(function(s){s.removeAttribute('data-stx-incoming')});
+
+      // \u2500\u2500 Swap main content \u2500\u2500
+      currentContent.innerHTML=newContent.innerHTML;
+
+      // \u2500\u2500 Load new external <head> scripts \u2500\u2500
+      var loadedSrcs={};
+      document.querySelectorAll('head script[src]').forEach(function(s){loadedSrcs[s.src]=1});
+      var extPromises=[];
+      doc.querySelectorAll('head script[src]').forEach(function(s){
+        var src=new URL(s.getAttribute('src'),location.origin).href;
+        if(loadedSrcs[src])return;
+        loadedSrcs[src]=1;
+        extPromises.push(new Promise(function(resolve,reject){
+          var ns=document.createElement('script');
+          ns.src=src;
+          ns.onload=resolve;
+          ns.onerror=reject;
+          document.head.appendChild(ns);
+        }));
+      });
+
+      // \u2500\u2500 Script re-execution \u2500\u2500
+      // Remove previously injected page scripts
+      document.querySelectorAll('script[data-stx-page]').forEach(function(s){s.remove()});
+
+      var scripts=[];
+      doc.querySelectorAll('script').forEach(function(s){
+        var text=s.textContent||'';
+        // Skip the signals runtime
+        if(text.indexOf('let activeEffect')!==-1)return;
+        // Skip the router
+        if(text.indexOf('__stxRouter')!==-1)return;
+        // Skip layout shell scripts
+        if(text.indexOf('__stxDashboardInit')!==-1||text.indexOf('__stxLayoutInit')!==-1)return;
+        // Skip external scripts
+        if(s.hasAttribute('src'))return;
+        // Skip empty
+        if(!text.trim())return;
+        scripts.push(text);
+      });
+
+      function execScripts(){
+        scripts.forEach(function(text){
+          var ns=document.createElement('script');
+          ns.textContent=text;
+          ns.setAttribute('data-stx-page','');
+          document.body.appendChild(ns);
+        });
+      }
+
+      if(extPromises.length>0){
+        Promise.all(extPromises).then(execScripts).catch(execScripts);
+      }else{
+        execScripts();
+      }
+
+      // Update active nav links
+      updateNav(url);
+      updateActiveLinks();
+
+      // Scroll
+      if(o.scrollToTop&&!hash)window.scrollTo({top:0,behavior:'instant'});
+      else if(hash){var el=document.querySelector(hash);if(el)el.scrollIntoView({behavior:'smooth'})}
+
+      // Update title
+      var newTitle=doc.querySelector('title');
+      if(newTitle)document.title=newTitle.textContent;
+
+      // Push history state
+      if(pushState!==false)history.pushState({},'',url+(hash||''));
+
+      // Dispatch navigation events
+      window.dispatchEvent(new CustomEvent('stx:navigate',{detail:{url:url}}));
+      window.dispatchEvent(new Event('stx:load'));
+    }
+
+    if(o.viewTransitions&&document.startViewTransition){
+      document.startViewTransition(doSwap);
+    }else{
+      // Fallback fade for browsers without View Transitions API
+      currentContent.style.transition='opacity 0.12s ease-out';
+      currentContent.style.opacity='0';
+      setTimeout(function(){
+        doSwap();
+        currentContent.style.opacity='1';
+        setTimeout(function(){currentContent.style.transition=''},150);
+      },120);
+    }
+  }
+
+  // \u2500\u2500 Link interception \u2500\u2500
+  function shouldIntercept(link){
+    if(!link)return false;
+    var href=link.getAttribute('href');
+    if(!href)return false;
+    if(href.startsWith('http')||href.startsWith('#')||href.startsWith('mailto:')||href.startsWith('tel:')||href.startsWith('javascript:'))return false;
+    if(link.target==='_blank')return false;
+    if(link.hasAttribute('data-stx-no-router')||link.hasAttribute('data-no-router')||link.hasAttribute('download'))return false;
+    if(href===location.pathname)return false;
+    if(!getContainer())return false;
+    return true;
+  }
+
+  document.addEventListener('click',function(e){
+    if(e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.button!==0)return;
+    if(!e.target||!e.target.closest)return;
+    var link=e.target.closest('a[href]');
+    if(!shouldIntercept(link))return;
+    e.preventDefault();
+    e.stopPropagation();
+    navigate(link.getAttribute('href'));
+  },true);
+
+  // \u2500\u2500 Back/forward \u2500\u2500
+  window.addEventListener('popstate',function(){
+    navigate(location.pathname+location.search+location.hash,false);
+  });
+
+  // \u2500\u2500 Prefetch on hover \u2500\u2500
+  if(o.prefetch){
+    document.addEventListener('mouseover',function(e){
+      if(!e.target||!e.target.closest)return;
+      var link=e.target.closest('a[href]');
+      if(!shouldIntercept(link))return;
+      // Only prefetch links with data-stx-prefetch or all internal links
+      var href=link.getAttribute('href');
+      if(cache[href]||prefetching[href])return;
+      prefetching[href]=true;
+      fetch(href,{headers:{'X-STX-Router':'true','Accept':'text/html'}}).then(function(r){return r.text()}).then(function(html){
+        if(o.cache)cache[href]=html;
+      }).catch(function(){}).finally(function(){delete prefetching[href]});
+    },true);
+  }
+
+  // \u2500\u2500 Active link management \u2500\u2500
+  function updateNav(url){
+    document.querySelectorAll('nav a[href], #mobileNav a[href], [data-stx-nav] a[href]').forEach(function(a){
+      var href=a.getAttribute('href');
+      if(!href||href.startsWith('#')||href.startsWith('http'))return;
+      var isActive=(href===url)||(href==='/'&&url==='/');
+      a.style.background=isActive?'var(--nav-active-bg, rgba(0,0,0,0.06))':'';
+      a.style.color=isActive?'var(--text-primary, inherit)':'var(--text-nav, inherit)';
+      a.style.fontWeight=isActive?'500':'';
+      if(a.hasAttribute('data-stx-link')){
+        var ac=a.getAttribute('data-stx-active-class')||'active';
+        if(isActive)a.classList.add(ac);else a.classList.remove(ac);
+      }
+    });
+  }
+
+  function updateActiveLinks(){
+    var links=document.querySelectorAll('[data-stx-link]');
+    var cur=location.pathname;
+    links.forEach(function(link){
+      var href=link.getAttribute('href')||'';
+      var ac=link.getAttribute('data-stx-active-class')||'active';
+      var eac=link.getAttribute('data-stx-exact-active-class')||'exact-active';
+      ac.split(' ').forEach(function(cls){if(cls)link.classList.remove(cls)});
+      eac.split(' ').forEach(function(cls){if(cls)link.classList.remove(cls)});
+      var isExact=cur===href;
+      var isActive=href!=='/'?cur.startsWith(href):cur==='/';
+      if(isExact)eac.split(' ').forEach(function(cls){if(cls)link.classList.add(cls)});
+      if(isActive)ac.split(' ').forEach(function(cls){if(cls)link.classList.add(cls)});
+    });
+  }
+
+  // \u2500\u2500 Loading bar + View Transitions CSS \u2500\u2500
+  function injectStyles(){
+    if(document.getElementById('stx-r-css'))return;
+    var s=document.createElement('style');s.id='stx-r-css';
+    s.textContent='.stx-navigating{cursor:wait}.stx-navigating *{pointer-events:none}@keyframes stx-l{0%{transform:translateX(-100%)}100%{transform:translateX(100%)}}.stx-navigating::before{content:\\'\\';position:fixed;top:0;left:0;right:0;height:3px;background:linear-gradient(90deg,transparent,#78dce8,transparent);animation:stx-l 1s ease-in-out infinite;z-index:99999}';
+    document.head.appendChild(s);
+  }
+
+  function injectViewTransitionCSS(){
+    if(document.getElementById('stx-view-transitions'))return;
+    var s=document.createElement('style');s.id='stx-view-transitions';
+    s.textContent='::view-transition-group(root){animation:none}::view-transition-old(root){animation:none}::view-transition-new(root){animation:none}#app-content,[data-stx-content]{view-transition-name:stx-content}::view-transition-old(stx-content){animation:stx-fade-out .15s ease-out both}::view-transition-new(stx-content){animation:stx-fade-in .15s ease-in .1s both}@keyframes stx-fade-out{from{opacity:1}to{opacity:0}}@keyframes stx-fade-in{from{opacity:0}to{opacity:1}}::view-transition{background:transparent}::view-transition-group(stx-content){background:inherit;overflow:hidden}';
+    (document.head||document.documentElement).appendChild(s);
+  }
+
+  // \u2500\u2500 Public API \u2500\u2500
+  var router={
+    navigate:navigate,
+    navigateTo:navigate,
+    prefetch:function(url){
+      if(!cache[url]){
+        fetch(url,{headers:{'X-STX-Router':'true'}}).then(function(r){return r.text()}).then(function(html){cache[url]=html}).catch(function(){});
+      }
+    },
+    clearCache:function(){for(var k in cache)delete cache[k]},
+    cache:cache,
+    swap:swap,
+    updateNav:updateNav
+  };
+
+  window.__stxRouter=router;
+  window.stxRouter=router;
+  if(window.stx)window.stx.router=router;
+
+  // \u2500\u2500 Initialize \u2500\u2500
+  function init(){
+    injectStyles();
+    injectViewTransitionCSS();
+    updateActiveLinks();
+    updateNav(location.pathname);
+  }
+
+  if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',init);else init();
+})();
+`;
+}
+export {
+  setAppUrl,
+  runMiddleware,
+  route,
+  resolveLayoutChain,
+  resetRoutes,
+  registerMiddleware,
+  patternToRegex,
+  navigateTo,
+  matchRoute,
+  loadMiddlewareFromDirectory,
+  hasMiddleware,
+  getRouterScript,
+  getMiddlewareNames,
+  getMiddleware,
+  generateRouteTypes,
+  formatRoutes,
+  findErrorPage,
+  filePathToPattern,
+  defineRoutes,
+  defineRoute,
+  defineMiddleware,
+  createStorageManager,
+  createServerCookieManager,
+  createRouter,
+  createRouteLocation,
+  createMiddlewareContext,
+  createClientCookieManager,
+  clearMiddleware,
+  abortNavigation,
+  Router
+};
+
+//# debugId=3C52557F9211FAA564756E2164756E21