reroute-js 0.43.5 → 0.43.6

package/elysia/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.43.5
+ * reroute-js v0.43.6
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
@@ -491,6 +491,73 @@ class LRUCache {
     this.cache.clear();
   }
 }
+
+class TTLCache {
+  cache = new Map;
+  maxSize;
+  defaultTtlMs;
+  cleanupInterval = null;
+  constructor(maxSize = 100, defaultTtlMs = 300000, cleanupIntervalMs = 60000) {
+    this.maxSize = maxSize;
+    this.defaultTtlMs = defaultTtlMs;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, cleanupIntervalMs);
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return;
+    if (entry.exp <= Date.now()) {
+      this.cache.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.cache.delete(key);
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, {
+      value,
+      exp: Date.now() + (ttlMs ?? this.defaultTtlMs)
+    });
+  }
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.exp <= now) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.clear();
+  }
+}
 var getGlobalCache = () => {
   const g = globalThis;
   if (!g.__REROUTE_SSR_CACHE__) {
@@ -5338,6 +5405,7 @@ __export(exports_core, {
   allowAICrawlers: () => allowAICrawlers,
   acceptsGzip: () => acceptsGzip,
   acceptsBrotli: () => acceptsBrotli,
+  TTLCache: () => TTLCache,
   SSRDataCache: () => SSRDataCache,
   SEARCH_CRAWLERS: () => SEARCH_CRAWLERS,
   LRUCache: () => LRUCache,
@@ -6081,43 +6149,23 @@ function registerInternalRoutes(app, opts) {
       }
     });
   });
-  const cacheTtlMs = maxAge * 1000;
-  function getCacheEntry(key) {
-    if (maxAge <= 0)
-      return;
-    const entry = dataCache?.get(key);
-    if (!entry)
-      return;
-    if (entry.exp <= Date.now()) {
-      return;
-    }
-    return entry.data;
-  }
-  function setCacheEntry(key, data) {
-    if (maxAge <= 0)
-      return;
-    dataCache?.set(key, {
-      data,
-      exp: Date.now() + cacheTtlMs
-    });
-  }
   async function handleKeyRequest(pathname, dataKey, headers2) {
     const { computeSSRData: computeSSRData2 } = await Promise.resolve().then(() => (init_core(), exports_core));
     const cacheKey = `${pathname}:promises`;
-    let promiseData = getCacheEntry(cacheKey);
+    let promiseData = dataCache?.get(cacheKey);
     const promiseDataCached = promiseData !== undefined;
     if (!promiseData) {
       const sp = extractSearchParams(pathname);
       const { data } = await computeSSRData2(pathname, clientDir, cwd, isWatchMode, { streaming: true, maxAge }, sp);
       promiseData = data;
-      setCacheEntry(cacheKey, promiseData);
+      dataCache?.set(cacheKey, promiseData);
     }
     if (promiseData && typeof promiseData === "object") {
       const value = promiseData[dataKey];
       if (value instanceof Promise) {
         const resolved = await value;
         const resolvedCacheKey = `${pathname}:${dataKey}:resolved`;
-        setCacheEntry(resolvedCacheKey, resolved);
+        dataCache?.set(resolvedCacheKey, resolved);
         return jsonWithCache({ data: resolved }, dataCacheControl || "no-cache", headers2, promiseDataCached ? "HIT" : "MISS");
       }
       if (value !== undefined) {
@@ -6129,7 +6177,7 @@ function registerInternalRoutes(app, opts) {
   async function handleFullDataRequest(pathname) {
     const { computeSSRData: computeSSRData2 } = await Promise.resolve().then(() => (init_core(), exports_core));
     const cacheKey = `${pathname}:streaming`;
-    let data = getCacheEntry(cacheKey);
+    let data = dataCache?.get(cacheKey);
     const cacheHit = data !== undefined;
     if (data === undefined) {
       const sp = extractSearchParams(pathname);
@@ -6140,7 +6188,7 @@ function registerInternalRoutes(app, opts) {
         console.error("[__reroute_data] Error computing data:", error);
         data = null;
       }
-      setCacheEntry(cacheKey, data);
+      dataCache?.set(cacheKey, data);
     }
     return { data, cacheHit };
   }
@@ -6414,18 +6462,6 @@ function registerLiveReloadRoutes(app, state) {
 init_core();
 import { NotFoundError as NotFoundError5 } from "elysia";
 
-// packages/elysia/src/libs/caching.ts
-function toTTL(seconds) {
-  return seconds * 1000;
-}
-function isValid(entry) {
-  return entry !== undefined && entry.exp > Date.now();
-}
-function getIfValid(cache2, key) {
-  const entry = cache2.get(key);
-  return isValid(entry) ? entry : undefined;
-}
-
 // packages/elysia/src/libs/llms.ts
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
@@ -6559,9 +6595,9 @@ function registerLLMsRoutes(app, options) {
     llmsConfig,
     collections: collections2
   } = options;
-  const llmsCache = new Map;
   const defaults = calculateLlmsDefaults(llmsConfig, maxAge);
   const { ttlMs, ttlMsFull, baseUrl } = defaults;
+  const llmsCache = new TTLCache(100, ttlMs);
   const availableLlms = [];
   const responseOpts = {
     maxAge: defaults.maxAge,
@@ -6576,9 +6612,9 @@ function registerLLMsRoutes(app, options) {
     app.get("/llms.txt", async () => {
       const cacheKey = buildLlmsIndexCacheKey();
       try {
-        const cached = getIfValid(llmsCache, cacheKey);
+        const cached = llmsCache.get(cacheKey);
         if (cached) {
-          return textResponse(cached.content, {
+          return textResponse(cached, {
             ...responseOpts,
             cacheStatus: "HIT"
           });
@@ -6590,7 +6626,7 @@ function registerLLMsRoutes(app, options) {
           isWatchMode,
           llmsConfig
         });
-        llmsCache.set(cacheKey, { content: content2, exp: Date.now() + ttlMs });
+        llmsCache.set(cacheKey, content2);
         return textResponse(content2, { ...responseOpts, cacheStatus: "MISS" });
       } catch (error) {
         console.error("[reroute/llms] Failed to generate index:", error);
@@ -6602,9 +6638,9 @@ function registerLLMsRoutes(app, options) {
     app.get("/llms-full.txt", async () => {
       const cacheKey = buildLlmsFullCacheKey();
       try {
-        const cached = getIfValid(llmsCache, cacheKey);
+        const cached = llmsCache.get(cacheKey);
         if (cached) {
-          return textResponse(cached.content, {
+          return textResponse(cached, {
             ...responseOptsFull,
             cacheStatus: "HIT"
           });
@@ -6622,7 +6658,7 @@ function registerLLMsRoutes(app, options) {
           llmsConfig
         });
         console.log(`[reroute/llms] Generated llms-full.txt: ${stats.itemCount} items, ${formatByteSize(stats.byteSize)}MB`);
-        llmsCache.set(cacheKey, { content: content2, exp: Date.now() + ttlMsFull });
+        llmsCache.set(cacheKey, content2, ttlMsFull);
         return textResponse(content2, {
           ...responseOptsFull,
           cacheStatus: "MISS"
@@ -6642,9 +6678,9 @@ function registerLLMsRoutes(app, options) {
       app.get(`/${collection}/llms.txt`, async () => {
         const cacheKey = buildLlmsIndexCacheKey(collection);
         try {
-          const cached = getIfValid(llmsCache, cacheKey);
+          const cached = llmsCache.get(cacheKey);
           if (cached) {
-            return textResponse(cached.content, {
+            return textResponse(cached, {
               ...responseOpts,
               cacheStatus: "HIT"
             });
@@ -6660,7 +6696,7 @@ function registerLLMsRoutes(app, options) {
               siteDescription: meta.description
             }
           });
-          llmsCache.set(cacheKey, { content: content2, exp: Date.now() + ttlMs });
+          llmsCache.set(cacheKey, content2);
           return textResponse(content2, {
             ...responseOpts,
             cacheStatus: "MISS"
@@ -6675,9 +6711,9 @@ function registerLLMsRoutes(app, options) {
       app.get(`/${collection}/llms-full.txt`, async () => {
         const cacheKey = buildLlmsFullCacheKey(collection);
         try {
-          const cached = getIfValid(llmsCache, cacheKey);
+          const cached = llmsCache.get(cacheKey);
           if (cached) {
-            return textResponse(cached.content, {
+            return textResponse(cached, {
               ...responseOptsFull,
               cacheStatus: "HIT"
             });
@@ -6699,7 +6735,7 @@ function registerLLMsRoutes(app, options) {
             }
           });
           console.log(`[reroute/llms] Generated ${collection}/llms-full.txt: ${stats.itemCount} items, ${formatByteSize(stats.byteSize)}MB`);
-          llmsCache.set(cacheKey, { content: content2, exp: Date.now() + ttlMsFull });
+          llmsCache.set(cacheKey, content2, ttlMsFull);
           return textResponse(content2, {
             ...responseOptsFull,
             cacheStatus: "MISS"
@@ -6714,12 +6750,12 @@ function registerLLMsRoutes(app, options) {
   if (shouldEnableContentNegotiation(llmsConfig)) {
     async function handleLLMRequest(pathname, format, acceptEncoding) {
       const cacheKey = buildLlmsCacheKey(pathname, format, acceptEncoding);
-      const cached = getIfValid(llmsCache, cacheKey);
+      const cached = llmsCache.get(cacheKey);
       if (cached) {
-        return format === "md" ? markdownResponse(cached.content, {
+        return format === "md" ? markdownResponse(cached, {
           ...responseOpts,
           cacheStatus: "HIT"
-        }) : textResponse(cached.content, {
+        }) : textResponse(cached, {
           ...responseOpts,
           extraHeaders: { Vary: "Accept" },
           cacheStatus: "HIT"
@@ -6736,7 +6772,7 @@ function registerLLMsRoutes(app, options) {
         format,
         llmsConfig
       });
-      llmsCache.set(cacheKey, { content: content2, exp: Date.now() + ttlMs });
+      llmsCache.set(cacheKey, content2);
       return format === "md" ? markdownResponse(content2, { ...responseOpts, cacheStatus: "MISS" }) : textResponse(content2, {
         ...responseOpts,
         extraHeaders: { Vary: "Accept" },
@@ -6980,14 +7016,12 @@ function registerOGRoutes(app, options) {
     return pathname;
   }
   function checkOgCache(pathname, set) {
-    if (maxAge > 0) {
-      const cached = getIfValid(ogCache, pathname);
-      if (cached) {
-        set.headers["content-type"] = "image/png";
-        set.headers["cache-control"] = `public, max-age=${maxAge}`;
-        set.headers["Reroute-Cache"] = "HIT";
-        return new Response(cached.buffer);
-      }
+    const cached = ogCache.get(pathname);
+    if (cached) {
+      set.headers["content-type"] = "image/png";
+      set.headers["cache-control"] = `public, max-age=${maxAge}`;
+      set.headers["Reroute-Cache"] = "HIT";
+      return new Response(cached);
     }
     return;
   }
@@ -7058,9 +7092,7 @@ function registerOGRoutes(app, options) {
       siteName: routeOgImage?.siteName ?? ogConfig2.siteName,
       baseUrl: ogConfig2.baseUrl
     }, { width: width2, height: height2, fonts });
-    if (maxAge > 0) {
-      ogCache.set(pathname, { buffer, exp: Date.now() + maxAge * 1000 });
-    }
+    ogCache.set(pathname, buffer);
   }
   app.get("/__reroute_og/*", async ({ request, set }) => {
     try {
@@ -7222,16 +7254,15 @@ function registerRobotsRoute(app, options) {
     sitemapEnabled,
     redirects
   } = options;
-  const ttlMs = toTTL(maxAge);
   app.get("/robots.txt", async () => {
     try {
-      const cached = getIfValid(robotsCache, "robots:main");
+      const cached = robotsCache.get("robots:main");
       if (cached) {
-        return textResponse(cached.txt, { maxAge, cacheStatus: "HIT" });
+        return textResponse(cached, { maxAge, cacheStatus: "HIT" });
       }
       const discovery5 = await discoverRobotsData(cwd, isWatchMode, robotsConfig, sitemapConfig, redirects);
       const txt = generateRobots(discovery5, robotsConfig, sitemapEnabled);
-      robotsCache.set("robots:main", { txt, exp: Date.now() + ttlMs });
+      robotsCache.set("robots:main", txt);
       return textResponse(txt, { maxAge, cacheStatus: "MISS" });
     } catch (error) {
       console.error("[reroute] Failed to generate robots.txt:", error);
@@ -7244,21 +7275,24 @@ function registerRobotsRoute(app, options) {
 // packages/elysia/src/routes/rss.ts
 init_core();
 import { NotFoundError as NotFoundError8 } from "elysia";
-var rssDiscoveryCache = new LRUCache(1);
+
+// packages/elysia/src/libs/caching.ts
+function toTTL(seconds) {
+  return seconds * 1000;
+}
+
+// packages/elysia/src/routes/rss.ts
+var rssDiscoveryCache = new TTLCache(1, 5 * 60 * 1000);
 async function getOrDiscoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig) {
   if (isWatchMode) {
     return discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
   }
   const cacheKey = "rss:discovery";
   const cached = rssDiscoveryCache.get(cacheKey);
-  if (cached && cached.exp > Date.now()) {
-    return cached.discovery;
-  }
+  if (cached)
+    return cached;
   const discovery5 = await discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
-  rssDiscoveryCache.set(cacheKey, {
-    discovery: discovery5,
-    exp: Date.now() + 5 * 60 * 1000
-  });
+  rssDiscoveryCache.set(cacheKey, discovery5);
   return discovery5;
 }
 function createFeedTitle(configTitle, name) {
@@ -7284,12 +7318,12 @@ async function discoverSSRRoutes(cwd, isWatchMode) {
     return [];
   }
 }
-async function registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMode, rssCache, format, limit, maxAge, ttlMs, feedTitle, feedDescription, rssConfig) {
+async function registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMode, rssCache, format, limit, maxAge, _ttlMs, feedTitle, feedDescription, rssConfig) {
   app.get("/feed.xml", async () => {
     try {
-      const cached = getIfValid(rssCache, "rss:main");
+      const cached = rssCache.get("rss:main");
       if (cached) {
-        return feedResponse(cached.xml, format, { maxAge, cacheStatus: "HIT" });
+        return feedResponse(cached, format, { maxAge, cacheStatus: "HIT" });
       }
       const discovery5 = await getOrDiscoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
       const allItems = [
@@ -7309,7 +7343,7 @@ async function registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMod
         items: allItems
       };
       const xml = generateFeed(feed, { format, limit });
-      rssCache.set("rss:main", { xml, exp: Date.now() + ttlMs });
+      rssCache.set("rss:main", xml);
       return feedResponse(xml, format, { maxAge, cacheStatus: "MISS" });
     } catch (error) {
       console.error("[reroute] Failed to generate main feed:", error);
@@ -7323,9 +7357,9 @@ function registerCollectionFeedRoutes(app, collections2, options) {
     app.get(`/${collection}/feed.xml`, async () => {
       const cacheKey = `rss:${collection}`;
       try {
-        const cached = getIfValid(options.rssCache, cacheKey);
+        const cached = options.rssCache.get(cacheKey);
         if (cached) {
-          return feedResponse(cached.xml, options.format, {
+          return feedResponse(cached, options.format, {
             maxAge: options.maxAge,
             cacheStatus: "HIT"
           });
@@ -7344,10 +7378,7 @@ function registerCollectionFeedRoutes(app, collections2, options) {
           format: options.format,
           limit: options.limit
         });
-        options.rssCache.set(cacheKey, {
-          xml,
-          exp: Date.now() + options.ttlMs
-        });
+        options.rssCache.set(cacheKey, xml);
         return feedResponse(xml, options.format, {
           maxAge: options.maxAge,
           cacheStatus: "MISS"
@@ -7382,9 +7413,9 @@ async function discoverRoutesWithFeeds(ssrDataRoutes, collections2, options) {
 async function generateSSRDataFeed(route, options) {
   const routeName = route.pattern.replace(/^\//, "") || "index";
   const cacheKey = `rss:${routeName}`;
-  const cached = getIfValid(options.rssCache, cacheKey);
+  const cached = options.rssCache.get(cacheKey);
   if (cached) {
-    return feedResponse(cached.xml, options.format, {
+    return feedResponse(cached, options.format, {
       maxAge: options.maxAge,
       cacheStatus: "HIT"
     });
@@ -7406,10 +7437,7 @@ async function generateSSRDataFeed(route, options) {
     format: options.format,
     limit: options.limit
   });
-  options.rssCache.set(cacheKey, {
-    xml,
-    exp: Date.now() + options.ttlMs
-  });
+  options.rssCache.set(cacheKey, xml);
   return feedResponse(xml, options.format, {
     maxAge: options.maxAge,
     cacheStatus: "MISS"
@@ -7616,21 +7644,17 @@ function registerSearchRoute(app, cwd, directive, maxAge, searchConfig) {
 // packages/elysia/src/routes/sitemap.ts
 init_core();
 import { NotFoundError as NotFoundError9 } from "elysia";
-var sitemapDiscoveryCache = new LRUCache(1);
+var sitemapDiscoveryCache = new TTLCache(1, 5 * 60 * 1000);
 async function getOrDiscoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig) {
   if (isWatchMode) {
     return discoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
   }
   const cacheKey = "sitemap:discovery";
   const cached = sitemapDiscoveryCache.get(cacheKey);
-  if (cached && cached.exp > Date.now()) {
-    return cached.discovery;
-  }
+  if (cached)
+    return cached;
   const discovery5 = await discoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
-  sitemapDiscoveryCache.set(cacheKey, {
-    discovery: discovery5,
-    exp: Date.now() + 5 * 60 * 1000
-  });
+  sitemapDiscoveryCache.set(cacheKey, discovery5);
   return discovery5;
 }
 async function generateAndCacheSitemap(options, _ttlMs) {
@@ -7653,23 +7677,17 @@ function registerSitemapRoutes(app, options) {
   const ttlMs = toTTL(maxAge);
   app.get("/sitemap.xml", async () => {
     try {
-      const cached = getIfValid(sitemapCache, "sitemap:main");
+      const cached = sitemapCache.get("sitemap:main");
       if (cached) {
-        return xmlResponse(cached.xml, { maxAge, cacheStatus: "HIT" });
+        return xmlResponse(cached, { maxAge, cacheStatus: "HIT" });
       }
       const result = await generateAndCacheSitemap(options, ttlMs);
       if (result.needsIndex) {
         for (const page of result.pages) {
-          sitemapCache.set(`sitemap:${page.filename}`, {
-            xml: page.xml,
-            exp: Date.now() + ttlMs
-          });
+          sitemapCache.set(`sitemap:${page.filename}`, page.xml);
         }
       }
-      sitemapCache.set("sitemap:main", {
-        xml: result.xml,
-        exp: Date.now() + ttlMs
-      });
+      sitemapCache.set("sitemap:main", result.xml);
       return xmlResponse(result.xml, { maxAge, cacheStatus: "MISS" });
     } catch (error) {
       console.error("[reroute] Failed to generate sitemap:", error);
@@ -7685,19 +7703,16 @@ function registerSitemapRoutes(app, options) {
     const filename = `sitemap-${pageMatch[1]}.xml`;
     const cacheKey = `sitemap:${filename}`;
     try {
-      const cached = getIfValid(sitemapCache, cacheKey);
+      const cached = sitemapCache.get(cacheKey);
       if (cached) {
-        return xmlResponse(cached.xml, { maxAge, cacheStatus: "HIT" });
+        return xmlResponse(cached, { maxAge, cacheStatus: "HIT" });
       }
       const result = await generateAndCacheSitemap(options, ttlMs);
       const pageData = result.pages.find((p) => p.filename === filename);
       if (!pageData) {
         throw new NotFoundError9;
       }
-      sitemapCache.set(cacheKey, {
-        xml: pageData.xml,
-        exp: Date.now() + ttlMs
-      });
+      sitemapCache.set(cacheKey, pageData.xml);
       return xmlResponse(pageData.xml, { maxAge, cacheStatus: "MISS" });
     } catch (error) {
       if (error instanceof NotFoundError9)
@@ -8339,13 +8354,14 @@ var reroute = () => async (app) => {
   const llmsEnabled = llmsConfig?.enabled === true;
   const robotsConfig = globalConfig.robots;
   const robotsEnabled = robotsConfig?.enabled === true;
-  const fileCache = new LRUCache(100);
-  const dataCache = new LRUCache(100);
-  const collectionCache = new LRUCache(50);
-  const sitemapCache = new LRUCache(20);
-  const rssCache = new LRUCache(20);
-  const ogCache = new LRUCache(100);
-  const robotsCache = new LRUCache(10);
+  const serverTtlMs = serverMaxAge * 1000;
+  const fileCache = new TTLCache(100, serverTtlMs);
+  const dataCache = new TTLCache(100, serverTtlMs);
+  const collectionCache = new TTLCache(50, serverTtlMs);
+  const sitemapCache = new TTLCache(20, serverTtlMs);
+  const rssCache = new TTLCache(20, serverTtlMs);
+  const ogCache = new TTLCache(100, serverTtlMs);
+  const robotsCache = new TTLCache(10, serverTtlMs);
   const liveReloadState = {
     clients: new Set,
     pendingReload: false
@@ -8429,7 +8445,22 @@ var reroute = () => async (app) => {
   const startupCollections = await loadCollections2(cwd, isWatchMode);
   const startupTailwindCSS = await inlineTailwindCSS2(clientDir, false, isWatchMode);
   const startupIndexHtml = await loadIndexHtml2(clientDir);
-  const getCollections = isWatchMode ? () => loadCollections2(cwd, isWatchMode) : async () => startupCollections;
+  const collectionsTtlMs = serverMaxAge * 1000;
+  let collectionsCache = serverCacheEnabled ? { data: startupCollections, exp: Date.now() + collectionsTtlMs } : null;
+  const getCollections = isWatchMode ? () => loadCollections2(cwd, isWatchMode) : async () => {
+    if (!serverCacheEnabled) {
+      return loadCollections2(cwd, isWatchMode);
+    }
+    if (collectionsCache && collectionsCache.exp > Date.now()) {
+      return collectionsCache.data;
+    }
+    const fresh = await loadCollections2(cwd, isWatchMode);
+    collectionsCache = {
+      data: fresh,
+      exp: Date.now() + collectionsTtlMs
+    };
+    return fresh;
+  };
   const getTailwindCSS = isWatchMode ? () => inlineTailwindCSS2(clientDir, false, isWatchMode) : async () => startupTailwindCSS;
   const getIndexHtml = isWatchMode ? () => loadIndexHtml2(clientDir) : async () => startupIndexHtml;
   if (globalConfig.redirects && globalConfig.redirects.length > 0) {
@@ -8619,4 +8650,4 @@ export {
   reroute
 };
 
-//# debugId=5A7719554EA87CE164756E2164756E21
+//# debugId=F52BE988669929F264756E2164756E21