@patternfly/patternfly-doc-core 1.10.0 → 1.11.0

package/dist/{server/chunks/_@astrojs-ssr-adapter_CbICuCdt.mjs → _worker.js/chunks/index_DlGha6WC.mjs}

@@ -1,24 +1,34 @@
-import { t as decryptString, v as createSlotValueFromString, w as isAstroComponentFactory, r as renderComponent, b as renderTemplate, x as ROUTE_TYPE_HEADER, y as REROUTE_DIRECTIVE_HEADER, A as AstroError, z as i18nNoLocaleFoundInPath, B as ResponseSentError, M as MiddlewareNoDataOrNextCalled, C as MiddlewareNotAResponse, D as originPathnameSymbol, E as RewriteWithBodyUsed, G as GetStaticPathsRequired, I as InvalidGetStaticPathsReturn, F as InvalidGetStaticPathsEntry, H as GetStaticPathsExpectedParams, J as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, K as DEFAULT_404_COMPONENT, N as NoMatchingStaticPathFound, L as PrerenderDynamicEndpointPathCollide, O as ReservedSlotName, Q as renderSlotToString, o as renderJSX, S as chunkToString, T as isRenderInstruction, V as ForbiddenRewrite, W as SessionStorageSaveError, X as SessionStorageInitError, Y as ASTRO_VERSION, Z as LocalsReassigned, _ as PrerenderClientAddressNotAvailable, $ as clientAddressSymbol, a0 as ClientAddressNotAvailable, a1 as StaticClientAddressNotAvailable, a2 as AstroResponseHeadersReassigned, a3 as responseSentSymbol$1, a4 as renderPage, a5 as REWRITE_DIRECTIVE_HEADER_KEY, a6 as REWRITE_DIRECTIVE_HEADER_VALUE, a7 as renderEndpoint, a8 as LocalsNotAnObject, a9 as REROUTABLE_STATUS_CODES } from './astro/server_Cl9jPh4p.mjs';
-import { bold, red, yellow, dim, blue } from 'kleur/colors';
-import 'clsx';
-import { serialize, parse } from 'cookie';
-import { g as getActionQueryString, d as deserializeActionResult, D as DEFAULT_404_ROUTE, a as default404Instance, N as NOOP_MIDDLEWARE_FN, e as ensure404Route } from './astro-designed-error-pages_BFveJFnQ.mjs';
-import 'es-module-lexer';
-import buffer from 'node:buffer';
-import crypto$1 from 'node:crypto';
-import { Http2ServerResponse } from 'node:http2';
-import { a as appendForwardSlash$1, j as joinPaths, b as removeTrailingForwardSlash, p as prependForwardSlash$1, t as trimSlashes, f as fileExtension, s as slash, c as collapseDuplicateTrailingSlashes, h as hasFileExtension$1 } from './path_Cvt6sEOY.mjs';
-import { unflatten as unflatten$1, stringify as stringify$1 } from 'devalue';
-import { createStorage, builtinDrivers } from 'unstorage';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import fs from 'node:fs';
-import http from 'node:http';
-import https from 'node:https';
-import enableDestroy from 'server-destroy';
-import os from 'node:os';
-import path from 'node:path';
-import url from 'node:url';
-import send from 'send';
+globalThis.process ??= {}; globalThis.process.env ??= {};
+import { g as getActionQueryString, a as deserializeActionResult, b as distExports, D as DEFAULT_404_ROUTE, A as ActionError, s as serializeActionResult, c as ACTION_RPC_ROUTE_PATTERN, f as ACTION_QUERY_PARAMS, h as stringify$2 } from './astro-designed-error-pages_4xWqsa9_.mjs';
+import { J as decryptString, K as createSlotValueFromString, M as isAstroComponentFactory, r as renderComponent, b as renderTemplate, x as REROUTE_DIRECTIVE_HEADER, A as AstroError, N as i18nNoLocaleFoundInPath, O as ResponseSentError, P as originPathnameSymbol, Q as RewriteWithBodyUsed, S as MiddlewareNoDataOrNextCalled, T as MiddlewareNotAResponse, V as GetStaticPathsRequired, W as InvalidGetStaticPathsReturn, X as InvalidGetStaticPathsEntry, Y as GetStaticPathsExpectedParams, Z as GetStaticPathsInvalidRouteParam, _ as PageNumberParamNotFound, D as DEFAULT_404_COMPONENT, $ as NoMatchingStaticPathFound, a0 as PrerenderDynamicEndpointPathCollide, a1 as ReservedSlotName, a2 as renderSlotToString, q as renderJSX, a3 as chunkToString, a4 as isRenderInstruction, a5 as SessionStorageSaveError, a6 as SessionStorageInitError, w as ROUTE_TYPE_HEADER, a7 as ForbiddenRewrite, a8 as ASTRO_VERSION, a9 as CspNotEnabled, aa as green, ab as LocalsReassigned, ac as PrerenderClientAddressNotAvailable, G as clientAddressSymbol, ad as ClientAddressNotAvailable, ae as StaticClientAddressNotAvailable, af as AstroResponseHeadersReassigned, I as responseSentSymbol$1, ag as renderPage, ah as REWRITE_DIRECTIVE_HEADER_KEY, ai as REWRITE_DIRECTIVE_HEADER_VALUE, aj as renderEndpoint } from './astro/server_BpfPtTmt.mjs';
+import { b as appendForwardSlash, j as joinPaths, a as removeTrailingForwardSlash, p as prependForwardSlash, t as trimSlashes } from './path_C-ZOwaTP.mjs';
+import { u as unflatten$1 } from './parse_EttCPxrw.mjs';
+
+const ACTION_API_CONTEXT_SYMBOL = Symbol.for("astro.actionAPIContext");
+const formContentTypes = ["application/x-www-form-urlencoded", "multipart/form-data"];
+function hasContentType(contentType, expected) {
+  const type = contentType.split(";")[0].toLowerCase();
+  return expected.some((t) => type === t);
+}
+
+function hasActionPayload(locals) {
+  return "_actionPayload" in locals;
+}
+function createGetActionResult(locals) {
+  return (actionFn) => {
+    if (!hasActionPayload(locals) || actionFn.toString() !== getActionQueryString(locals._actionPayload.actionName)) {
+      return void 0;
+    }
+    return deserializeActionResult(locals._actionPayload.actionResult);
+  };
+}
+function createCallAction(context) {
+  return (baseAction, input) => {
+    Reflect.set(context, ACTION_API_CONTEXT_SYMBOL, true);
+    const action = baseAction.bind(context);
+    return action(input);
+  };
+}
 
 function shouldAppendForwardSlash(trailingSlash, buildFormat) {
   switch (trailingSlash) {
@@ -211,125 +221,6 @@ function isRouteExternalRedirect(route) {
   return !!(route.type === "redirect" && route.redirect && redirectIsExternal(route.redirect));
 }
 
-function createI18nMiddleware(i18n, base, trailingSlash, format) {
-  if (!i18n) return (_, next) => next();
-  const payload = {
-    ...i18n,
-    trailingSlash,
-    base,
-    format};
-  const _redirectToDefaultLocale = redirectToDefaultLocale(payload);
-  const _noFoundForNonLocaleRoute = notFound(payload);
-  const _requestHasLocale = requestHasLocale(payload.locales);
-  const _redirectToFallback = redirectToFallback(payload);
-  const prefixAlways = (context, response) => {
-    const url = context.url;
-    if (url.pathname === base + "/" || url.pathname === base) {
-      return _redirectToDefaultLocale(context);
-    } else if (!_requestHasLocale(context)) {
-      return _noFoundForNonLocaleRoute(context, response);
-    }
-    return void 0;
-  };
-  const prefixOtherLocales = (context, response) => {
-    let pathnameContainsDefaultLocale = false;
-    const url = context.url;
-    for (const segment of url.pathname.split("/")) {
-      if (normalizeTheLocale(segment) === normalizeTheLocale(i18n.defaultLocale)) {
-        pathnameContainsDefaultLocale = true;
-        break;
-      }
-    }
-    if (pathnameContainsDefaultLocale) {
-      const newLocation = url.pathname.replace(`/${i18n.defaultLocale}`, "");
-      response.headers.set("Location", newLocation);
-      return _noFoundForNonLocaleRoute(context);
-    }
-    return void 0;
-  };
-  return async (context, next) => {
-    const response = await next();
-    const type = response.headers.get(ROUTE_TYPE_HEADER);
-    const isReroute = response.headers.get(REROUTE_DIRECTIVE_HEADER);
-    if (isReroute === "no" && typeof i18n.fallback === "undefined") {
-      return response;
-    }
-    if (type !== "page" && type !== "fallback") {
-      return response;
-    }
-    if (requestIs404Or500(context.request, base)) {
-      return response;
-    }
-    if (isRequestServerIsland(context.request, base)) {
-      return response;
-    }
-    const { currentLocale } = context;
-    switch (i18n.strategy) {
-      // NOTE: theoretically, we should never hit this code path
-      case "manual": {
-        return response;
-      }
-      case "domains-prefix-other-locales": {
-        if (localeHasntDomain(i18n, currentLocale)) {
-          const result = prefixOtherLocales(context, response);
-          if (result) {
-            return result;
-          }
-        }
-        break;
-      }
-      case "pathname-prefix-other-locales": {
-        const result = prefixOtherLocales(context, response);
-        if (result) {
-          return result;
-        }
-        break;
-      }
-      case "domains-prefix-always-no-redirect": {
-        if (localeHasntDomain(i18n, currentLocale)) {
-          const result = _noFoundForNonLocaleRoute(context, response);
-          if (result) {
-            return result;
-          }
-        }
-        break;
-      }
-      case "pathname-prefix-always-no-redirect": {
-        const result = _noFoundForNonLocaleRoute(context, response);
-        if (result) {
-          return result;
-        }
-        break;
-      }
-      case "pathname-prefix-always": {
-        const result = prefixAlways(context, response);
-        if (result) {
-          return result;
-        }
-        break;
-      }
-      case "domains-prefix-always": {
-        if (localeHasntDomain(i18n, currentLocale)) {
-          const result = prefixAlways(context, response);
-          if (result) {
-            return result;
-          }
-        }
-        break;
-      }
-    }
-    return _redirectToFallback(context, response);
-  };
-}
-function localeHasntDomain(i18n, currentLocale) {
-  for (const domainLocale of Object.values(i18n.domainLookupTable)) {
-    if (domainLocale === currentLocale) {
-      return false;
-    }
-  }
-  return true;
-}
-
 function requestHasLocale(locales) {
   return function(context) {
     return pathHasLocale(context.url.pathname, locales);
@@ -369,14 +260,16 @@ function getPathByLocale(locale, locales) {
 function normalizeTheLocale(locale) {
   return locale.replaceAll("_", "-").toLowerCase();
 }
-function toCodes(locales) {
-  return locales.map((loopLocale) => {
+function getAllCodes(locales) {
+  const result = [];
+  for (const loopLocale of locales) {
     if (typeof loopLocale === "string") {
-      return loopLocale;
+      result.push(loopLocale);
     } else {
-      return loopLocale.codes[0];
+      result.push(...loopLocale.codes);
     }
-  });
+  }
+  return result;
 }
 function redirectToDefaultLocale({
   trailingSlash,
@@ -386,7 +279,7 @@ function redirectToDefaultLocale({
 }) {
   return function(context, statusCode) {
     if (shouldAppendForwardSlash(trailingSlash, format)) {
-      return context.redirect(`${appendForwardSlash$1(joinPaths(base, defaultLocale))}`, statusCode);
+      return context.redirect(`${appendForwardSlash(joinPaths(base, defaultLocale))}`, statusCode);
     } else {
       return context.redirect(`${joinPaths(base, defaultLocale)}`, statusCode);
     }
@@ -466,9 +359,146 @@ function redirectToFallback({
   };
 }
 
+function parseLocale(header) {
+  if (header === "*") {
+    return [{ locale: header, qualityValue: void 0 }];
+  }
+  const result = [];
+  const localeValues = header.split(",").map((str) => str.trim());
+  for (const localeValue of localeValues) {
+    const split = localeValue.split(";").map((str) => str.trim());
+    const localeName = split[0];
+    const qualityValue = split[1];
+    if (!split) {
+      continue;
+    }
+    if (qualityValue && qualityValue.startsWith("q=")) {
+      const qualityValueAsFloat = Number.parseFloat(qualityValue.slice("q=".length));
+      if (Number.isNaN(qualityValueAsFloat) || qualityValueAsFloat > 1) {
+        result.push({
+          locale: localeName,
+          qualityValue: void 0
+        });
+      } else {
+        result.push({
+          locale: localeName,
+          qualityValue: qualityValueAsFloat
+        });
+      }
+    } else {
+      result.push({
+        locale: localeName,
+        qualityValue: void 0
+      });
+    }
+  }
+  return result;
+}
+function sortAndFilterLocales(browserLocaleList, locales) {
+  const normalizedLocales = getAllCodes(locales).map(normalizeTheLocale);
+  return browserLocaleList.filter((browserLocale) => {
+    if (browserLocale.locale !== "*") {
+      return normalizedLocales.includes(normalizeTheLocale(browserLocale.locale));
+    }
+    return true;
+  }).sort((a, b) => {
+    if (a.qualityValue && b.qualityValue) {
+      return Math.sign(b.qualityValue - a.qualityValue);
+    }
+    return 0;
+  });
+}
+function computePreferredLocale(request, locales) {
+  const acceptHeader = request.headers.get("Accept-Language");
+  let result = void 0;
+  if (acceptHeader) {
+    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
+    const firstResult = browserLocaleList.at(0);
+    if (firstResult && firstResult.locale !== "*") {
+      for (const currentLocale of locales) {
+        if (typeof currentLocale === "string") {
+          if (normalizeTheLocale(currentLocale) === normalizeTheLocale(firstResult.locale)) {
+            result = currentLocale;
+            break;
+          }
+        } else {
+          for (const currentCode of currentLocale.codes) {
+            if (normalizeTheLocale(currentCode) === normalizeTheLocale(firstResult.locale)) {
+              result = currentCode;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function computePreferredLocaleList(request, locales) {
+  const acceptHeader = request.headers.get("Accept-Language");
+  let result = [];
+  if (acceptHeader) {
+    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
+    if (browserLocaleList.length === 1 && browserLocaleList.at(0).locale === "*") {
+      return getAllCodes(locales);
+    } else if (browserLocaleList.length > 0) {
+      for (const browserLocale of browserLocaleList) {
+        for (const loopLocale of locales) {
+          if (typeof loopLocale === "string") {
+            if (normalizeTheLocale(loopLocale) === normalizeTheLocale(browserLocale.locale)) {
+              result.push(loopLocale);
+            }
+          } else {
+            for (const code of loopLocale.codes) {
+              if (code === browserLocale.locale) {
+                result.push(code);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function computeCurrentLocale(pathname, locales, defaultLocale) {
+  for (const segment of pathname.split("/")) {
+    for (const locale of locales) {
+      if (typeof locale === "string") {
+        if (!segment.includes(locale)) continue;
+        if (normalizeTheLocale(locale) === normalizeTheLocale(segment)) {
+          return locale;
+        }
+      } else {
+        if (locale.path === segment) {
+          return locale.codes.at(0);
+        } else {
+          for (const code of locale.codes) {
+            if (normalizeTheLocale(code) === normalizeTheLocale(segment)) {
+              return code;
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const locale of locales) {
+    if (typeof locale === "string") {
+      if (locale === defaultLocale) {
+        return locale;
+      }
+    } else {
+      if (locale.path === defaultLocale) {
+        return locale.codes.at(0);
+      }
+    }
+  }
+}
+
 const DELETED_EXPIRATION = /* @__PURE__ */ new Date(0);
 const DELETED_VALUE = "deleted";
 const responseSentSymbol = Symbol.for("astro.responseSent");
+const identity = (value) => value;
 class AstroCookie {
   constructor(value) {
     this.value = value;
@@ -519,7 +549,7 @@ class AstroCookies {
     };
     this.#ensureOutgoingMap().set(key, [
       DELETED_VALUE,
-      serialize(key, DELETED_VALUE, serializeOptions),
+      distExports.serialize(key, DELETED_VALUE, serializeOptions),
       false
     ]);
   }
@@ -539,25 +569,29 @@ class AstroCookies {
         return void 0;
       }
     }
-    const values = this.#ensureParsed(options);
+    const decode = options?.decode ?? decodeURIComponent;
+    const values = this.#ensureParsed();
     if (key in values) {
       const value = values[key];
-      return new AstroCookie(value);
+      if (value) {
+        return new AstroCookie(decode(value));
+      }
     }
   }
   /**
    * Astro.cookies.has(key) returns a boolean indicating whether this cookie is either
    * part of the initial request or set via Astro.cookies.set(key)
    * @param key The cookie to check for.
+   * @param _options This parameter is no longer used.
    * @returns
    */
-  has(key, options = void 0) {
+  has(key, _options) {
     if (this.#outgoing?.has(key)) {
       let [, , isSetValue] = this.#outgoing.get(key);
       return isSetValue;
     }
-    const values = this.#ensureParsed(options);
-    return !!values[key];
+    const values = this.#ensureParsed();
+    return values[key] !== void 0;
   }
   /**
    * Astro.cookies.set(key, value) is used to set a cookie's value. If provided
@@ -593,7 +627,7 @@ class AstroCookies {
     }
     this.#ensureOutgoingMap().set(key, [
       serializedValue,
-      serialize(key, serializedValue, serializeOptions),
+      distExports.serialize(key, serializedValue, serializeOptions),
       true
     ]);
     if (this.#request[responseSentSymbol]) {
@@ -634,9 +668,9 @@ class AstroCookies {
     cookies.#consumed = true;
     return cookies.headers();
   }
-  #ensureParsed(options = void 0) {
+  #ensureParsed() {
     if (!this.#requestValues) {
-      this.#parse(options);
+      this.#parse();
     }
     if (!this.#requestValues) {
       this.#requestValues = {};
@@ -649,12 +683,12 @@ class AstroCookies {
     }
     return this.#outgoing;
   }
-  #parse(options = void 0) {
+  #parse() {
     const raw = this.#request.headers.get("cookie");
     if (!raw) {
       return;
     }
-    this.#requestValues = parse(raw, options);
+    this.#requestValues = distExports.parse(raw, { decode: identity });
   }
 }
 
@@ -681,298 +715,238 @@ function* getSetCookiesFromResponse(response) {
   return [];
 }
 
-const dateTimeFormat = new Intl.DateTimeFormat([], {
-  hour: "2-digit",
-  minute: "2-digit",
-  second: "2-digit",
-  hour12: false
-});
-const levels = {
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  silent: 90
-};
-function log(opts, level, label, message, newLine = true) {
-  const logLevel = opts.level;
-  const dest = opts.dest;
-  const event = {
-    label,
-    level,
-    message,
-    newLine
-  };
-  if (!isLogLevelEnabled(logLevel, level)) {
-    return;
+function createRequest({
+  url,
+  headers,
+  method = "GET",
+  body = void 0,
+  logger,
+  isPrerendered = false,
+  routePattern,
+  init
+}) {
+  const headersObj = isPrerendered ? void 0 : headers instanceof Headers ? headers : new Headers(
+    // Filter out HTTP/2 pseudo-headers. These are internally-generated headers added to all HTTP/2 requests with trusted metadata about the request.
+    // Examples include `:method`, `:scheme`, `:authority`, and `:path`.
+    // They are always prefixed with a colon to distinguish them from other headers, and it is an error to add the to a Headers object manually.
+    // See https://httpwg.org/specs/rfc7540.html#HttpRequest
+    Object.entries(headers).filter(([name]) => !name.startsWith(":"))
+  );
+  if (typeof url === "string") url = new URL(url);
+  if (isPrerendered) {
+    url.search = "";
   }
-  dest.write(event);
-}
-function isLogLevelEnabled(configuredLogLevel, level) {
-  return levels[configuredLogLevel] <= levels[level];
-}
-function info(opts, label, message, newLine = true) {
-  return log(opts, "info", label, message, newLine);
-}
-function warn(opts, label, message, newLine = true) {
-  return log(opts, "warn", label, message, newLine);
-}
-function error(opts, label, message, newLine = true) {
-  return log(opts, "error", label, message, newLine);
-}
-function debug(...args) {
-  if ("_astroGlobalDebug" in globalThis) {
-    globalThis._astroGlobalDebug(...args);
+  const request = new Request(url, {
+    method,
+    headers: headersObj,
+    // body is made available only if the request is for a page that will be on-demand rendered
+    body: isPrerendered ? null : body,
+    ...init
+  });
+  if (isPrerendered) {
+    let _headers = request.headers;
+    const { value, writable, ...headersDesc } = Object.getOwnPropertyDescriptor(request, "headers") || {};
+    Object.defineProperty(request, "headers", {
+      ...headersDesc,
+      get() {
+        logger.warn(
+          null,
+          `\`Astro.request.headers\` was used when rendering the route \`${routePattern}'\`. \`Astro.request.headers\` is not available on prerendered pages. If you need access to request headers, make sure that the page is server-rendered using \`export const prerender = false;\` or by setting \`output\` to \`"server"\` in your Astro config to make all your pages server-rendered by default.`
+        );
+        return _headers;
+      },
+      set(newHeaders) {
+        _headers = newHeaders;
+      }
+    });
   }
+  return request;
 }
-function getEventPrefix({ level, label }) {
-  const timestamp = `${dateTimeFormat.format(/* @__PURE__ */ new Date())}`;
-  const prefix = [];
-  if (level === "error" || level === "warn") {
-    prefix.push(bold(timestamp));
-    prefix.push(`[${level.toUpperCase()}]`);
-  } else {
-    prefix.push(timestamp);
-  }
-  if (label) {
-    prefix.push(`[${label}]`);
-  }
-  if (level === "error") {
-    return red(prefix.join(" "));
-  }
-  if (level === "warn") {
-    return yellow(prefix.join(" "));
-  }
-  if (prefix.length === 1) {
-    return dim(prefix[0]);
-  }
-  return dim(prefix[0]) + " " + blue(prefix.splice(1).join(" "));
-}
-class Logger {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  info(label, message, newLine = true) {
-    info(this.options, label, message, newLine);
-  }
-  warn(label, message, newLine = true) {
-    warn(this.options, label, message, newLine);
-  }
-  error(label, message, newLine = true) {
-    error(this.options, label, message, newLine);
-  }
-  debug(label, ...messages) {
-    debug(label, ...messages);
-  }
-  level() {
-    return this.options.level;
-  }
-  forkIntegrationLogger(label) {
-    return new AstroIntegrationLogger(this.options, label);
+
+function findRouteToRewrite({
+  payload,
+  routes,
+  request,
+  trailingSlash,
+  buildFormat,
+  base,
+  outDir
+}) {
+  let newUrl = void 0;
+  if (payload instanceof URL) {
+    newUrl = payload;
+  } else if (payload instanceof Request) {
+    newUrl = new URL(payload.url);
+  } else {
+    newUrl = new URL(payload, new URL(request.url).origin);
   }
-}
-class AstroIntegrationLogger {
-  options;
-  label;
-  constructor(logging, label) {
-    this.options = logging;
-    this.label = label;
+  let pathname = newUrl.pathname;
+  const shouldAppendSlash = shouldAppendForwardSlash(trailingSlash, buildFormat);
+  if (base !== "/") {
+    const isBasePathRequest = newUrl.pathname === base || newUrl.pathname === removeTrailingForwardSlash(base);
+    if (isBasePathRequest) {
+      pathname = shouldAppendSlash ? "/" : "";
+    } else if (newUrl.pathname.startsWith(base)) {
+      pathname = shouldAppendSlash ? appendForwardSlash(newUrl.pathname) : removeTrailingForwardSlash(newUrl.pathname);
+      pathname = pathname.slice(base.length);
+    }
   }
-  /**
-   * Creates a new logger instance with a new label, but the same log options.
-   */
-  fork(label) {
-    return new AstroIntegrationLogger(this.options, label);
+  if (!pathname.startsWith("/") && shouldAppendSlash && newUrl.pathname.endsWith("/")) {
+    pathname = prependForwardSlash(pathname);
   }
-  info(message) {
-    info(this.options, this.label, message);
+  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
+    pathname = "";
   }
-  warn(message) {
-    warn(this.options, this.label, message);
+  if (buildFormat === "file") {
+    pathname = pathname.replace(/\.html$/, "");
   }
-  error(message) {
-    error(this.options, this.label, message);
+  if (base !== "/" && (pathname === "" || pathname === "/") && !shouldAppendSlash) {
+    newUrl.pathname = removeTrailingForwardSlash(base);
+  } else {
+    newUrl.pathname = joinPaths(...[base, pathname].filter(Boolean));
   }
-  debug(message) {
-    debug(this.label, message);
+  const decodedPathname = decodeURI(pathname);
+  let foundRoute;
+  for (const route of routes) {
+    if (route.pattern.test(decodedPathname)) {
+      if (route.params && route.params.length !== 0 && route.distURL && route.distURL.length !== 0) {
+        if (!route.distURL.find(
+          (url) => url.href.replace(outDir.toString(), "").replace(/(?:\/index\.html|\.html)$/, "") == trimSlashes(decodedPathname)
+        )) {
+          continue;
+        }
+      }
+      foundRoute = route;
+      break;
+    }
   }
-}
-
-const consoleLogDestination = {
-  write(event) {
-    let dest = console.error;
-    if (levels[event.level] < levels["error"]) {
-      dest = console.log;
-    }
-    if (event.label === "SKIP_FORMAT") {
-      dest(event.message);
+  if (foundRoute) {
+    return {
+      routeData: foundRoute,
+      newUrl,
+      pathname: decodedPathname
+    };
+  } else {
+    const custom404 = routes.find((route) => route.route === "/404");
+    if (custom404) {
+      return { routeData: custom404, newUrl, pathname };
     } else {
-      dest(getEventPrefix(event) + " " + event.message);
+      return { routeData: DEFAULT_404_ROUTE, newUrl, pathname };
     }
-    return true;
   }
-};
-
-const ACTION_API_CONTEXT_SYMBOL = Symbol.for("astro.actionAPIContext");
-
-function hasActionPayload(locals) {
-  return "_actionPayload" in locals;
 }
-function createGetActionResult(locals) {
-  return (actionFn) => {
-    if (!hasActionPayload(locals) || actionFn.toString() !== getActionQueryString(locals._actionPayload.actionName)) {
-      return void 0;
+function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
+  if (oldRequest.bodyUsed) {
+    throw new AstroError(RewriteWithBodyUsed);
+  }
+  return createRequest({
+    url: newUrl,
+    method: oldRequest.method,
+    body: oldRequest.body,
+    isPrerendered,
+    logger,
+    headers: isPrerendered ? {} : oldRequest.headers,
+    routePattern,
+    init: {
+      referrer: oldRequest.referrer,
+      referrerPolicy: oldRequest.referrerPolicy,
+      mode: oldRequest.mode,
+      credentials: oldRequest.credentials,
+      cache: oldRequest.cache,
+      redirect: oldRequest.redirect,
+      integrity: oldRequest.integrity,
+      signal: oldRequest.signal,
+      keepalive: oldRequest.keepalive,
+      // https://fetch.spec.whatwg.org/#dom-request-duplex
+      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
+      duplex: "half"
     }
-    return deserializeActionResult(locals._actionPayload.actionResult);
-  };
+  });
 }
-function createCallAction(context) {
-  return (baseAction, input) => {
-    Reflect.set(context, ACTION_API_CONTEXT_SYMBOL, true);
-    const action = baseAction.bind(context);
-    return action(input);
-  };
+function setOriginPathname(request, pathname) {
+  Reflect.set(request, originPathnameSymbol, encodeURIComponent(pathname));
 }
-
-function parseLocale(header) {
-  if (header === "*") {
-    return [{ locale: header, qualityValue: void 0 }];
-  }
-  const result = [];
-  const localeValues = header.split(",").map((str) => str.trim());
-  for (const localeValue of localeValues) {
-    const split = localeValue.split(";").map((str) => str.trim());
-    const localeName = split[0];
-    const qualityValue = split[1];
-    if (!split) {
-      continue;
-    }
-    if (qualityValue && qualityValue.startsWith("q=")) {
-      const qualityValueAsFloat = Number.parseFloat(qualityValue.slice("q=".length));
-      if (Number.isNaN(qualityValueAsFloat) || qualityValueAsFloat > 1) {
-        result.push({
-          locale: localeName,
-          qualityValue: void 0
-        });
-      } else {
-        result.push({
-          locale: localeName,
-          qualityValue: qualityValueAsFloat
-        });
-      }
-    } else {
-      result.push({
-        locale: localeName,
-        qualityValue: void 0
-      });
-    }
+function getOriginPathname(request) {
+  const origin = Reflect.get(request, originPathnameSymbol);
+  if (origin) {
+    return decodeURIComponent(origin);
   }
-  return result;
-}
-function sortAndFilterLocales(browserLocaleList, locales) {
-  const normalizedLocales = toCodes(locales).map(normalizeTheLocale);
-  return browserLocaleList.filter((browserLocale) => {
-    if (browserLocale.locale !== "*") {
-      return normalizedLocales.includes(normalizeTheLocale(browserLocale.locale));
-    }
-    return true;
-  }).sort((a, b) => {
-    if (a.qualityValue && b.qualityValue) {
-      return Math.sign(b.qualityValue - a.qualityValue);
-    }
-    return 0;
-  });
+  return new URL(request.url).pathname;
 }
-function computePreferredLocale(request, locales) {
-  const acceptHeader = request.headers.get("Accept-Language");
-  let result = void 0;
-  if (acceptHeader) {
-    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
-    const firstResult = browserLocaleList.at(0);
-    if (firstResult && firstResult.locale !== "*") {
-      for (const currentLocale of locales) {
-        if (typeof currentLocale === "string") {
-          if (normalizeTheLocale(currentLocale) === normalizeTheLocale(firstResult.locale)) {
-            result = currentLocale;
-          }
-        } else {
-          for (const currentCode of currentLocale.codes) {
-            if (normalizeTheLocale(currentCode) === normalizeTheLocale(firstResult.locale)) {
-              result = currentLocale.path;
-            }
+
+function getActionContext(context) {
+  const callerInfo = getCallerInfo(context);
+  const actionResultAlreadySet = Boolean(context.locals._actionPayload);
+  let action = void 0;
+  if (callerInfo && context.request.method === "POST" && !actionResultAlreadySet) {
+    action = {
+      calledFrom: callerInfo.from,
+      name: callerInfo.name,
+      handler: async () => {
+        const pipeline = Reflect.get(context, apiContextRoutesSymbol);
+        const callerInfoName = shouldAppendForwardSlash(
+          pipeline.manifest.trailingSlash,
+          pipeline.manifest.buildFormat
+        ) ? removeTrailingForwardSlash(callerInfo.name) : callerInfo.name;
+        const baseAction = await pipeline.getAction(callerInfoName);
+        let input;
+        try {
+          input = await parseRequestBody(context.request);
+        } catch (e) {
+          if (e instanceof TypeError) {
+            return { data: void 0, error: new ActionError({ code: "UNSUPPORTED_MEDIA_TYPE" }) };
           }
+          throw e;
         }
+        const omitKeys = ["props", "getActionResult", "callAction", "redirect"];
+        const actionAPIContext = Object.create(
+          Object.getPrototypeOf(context),
+          Object.fromEntries(
+            Object.entries(Object.getOwnPropertyDescriptors(context)).filter(
+              ([key]) => !omitKeys.includes(key)
+            )
+          )
+        );
+        Reflect.set(actionAPIContext, ACTION_API_CONTEXT_SYMBOL, true);
+        const handler = baseAction.bind(actionAPIContext);
+        return handler(input);
       }
-    }
+    };
   }
-  return result;
+  function setActionResult(actionName, actionResult) {
+    context.locals._actionPayload = {
+      actionResult,
+      actionName
+    };
+  }
+  return {
+    action,
+    setActionResult,
+    serializeActionResult,
+    deserializeActionResult
+  };
 }
-function computePreferredLocaleList(request, locales) {
-  const acceptHeader = request.headers.get("Accept-Language");
-  let result = [];
-  if (acceptHeader) {
-    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
-    if (browserLocaleList.length === 1 && browserLocaleList.at(0).locale === "*") {
-      return locales.map((locale) => {
-        if (typeof locale === "string") {
-          return locale;
-        } else {
-          return locale.codes.at(0);
-        }
-      });
-    } else if (browserLocaleList.length > 0) {
-      for (const browserLocale of browserLocaleList) {
-        for (const loopLocale of locales) {
-          if (typeof loopLocale === "string") {
-            if (normalizeTheLocale(loopLocale) === normalizeTheLocale(browserLocale.locale)) {
-              result.push(loopLocale);
-            }
-          } else {
-            for (const code of loopLocale.codes) {
-              if (code === browserLocale.locale) {
-                result.push(loopLocale.path);
-              }
-            }
-          }
-        }
-      }
-    }
+function getCallerInfo(ctx) {
+  if (ctx.routePattern === ACTION_RPC_ROUTE_PATTERN) {
+    return { from: "rpc", name: ctx.url.pathname.replace(/^.*\/_actions\//, "") };
   }
-  return result;
+  const queryParam = ctx.url.searchParams.get(ACTION_QUERY_PARAMS.actionName);
+  if (queryParam) {
+    return { from: "form", name: queryParam };
+  }
+  return void 0;
 }
-function computeCurrentLocale(pathname, locales, defaultLocale) {
-  for (const segment of pathname.split("/")) {
-    for (const locale of locales) {
-      if (typeof locale === "string") {
-        if (!segment.includes(locale)) continue;
-        if (normalizeTheLocale(locale) === normalizeTheLocale(segment)) {
-          return locale;
-        }
-      } else {
-        if (locale.path === segment) {
-          return locale.codes.at(0);
-        } else {
-          for (const code of locale.codes) {
-            if (normalizeTheLocale(code) === normalizeTheLocale(segment)) {
-              return code;
-            }
-          }
-        }
-      }
-    }
+async function parseRequestBody(request) {
+  const contentType = request.headers.get("content-type");
+  const contentLength = request.headers.get("Content-Length");
+  if (!contentType) return void 0;
+  if (hasContentType(contentType, formContentTypes)) {
+    return await request.clone().formData();
   }
-  for (const locale of locales) {
-    if (typeof locale === "string") {
-      if (locale === defaultLocale) {
-        return locale;
-      }
-    } else {
-      if (locale.path === defaultLocale) {
-        return locale.codes.at(0);
-      }
-    }
+  if (hasContentType(contentType, ["application/json"])) {
+    return contentLength === "0" ? void 0 : await request.clone().json();
   }
+  throw new TypeError("Unsupported content type");
 }
 
 async function callMiddleware(onRequest, apiContext, responseFunction) {
@@ -1008,190 +982,6 @@ async function callMiddleware(onRequest, apiContext, responseFunction) {
   });
 }
 
-function createRequest({
-  url,
-  headers,
-  method = "GET",
-  body = void 0,
-  logger,
-  isPrerendered = false,
-  routePattern,
-  init
-}) {
-  const headersObj = isPrerendered ? void 0 : headers instanceof Headers ? headers : new Headers(
-    // Filter out HTTP/2 pseudo-headers. These are internally-generated headers added to all HTTP/2 requests with trusted metadata about the request.
-    // Examples include `:method`, `:scheme`, `:authority`, and `:path`.
-    // They are always prefixed with a colon to distinguish them from other headers, and it is an error to add the to a Headers object manually.
-    // See https://httpwg.org/specs/rfc7540.html#HttpRequest
-    Object.entries(headers).filter(([name]) => !name.startsWith(":"))
-  );
-  if (typeof url === "string") url = new URL(url);
-  if (isPrerendered) {
-    url.search = "";
-  }
-  const request = new Request(url, {
-    method,
-    headers: headersObj,
-    // body is made available only if the request is for a page that will be on-demand rendered
-    body: isPrerendered ? null : body,
-    ...init
-  });
-  if (isPrerendered) {
-    let _headers = request.headers;
-    const { value, writable, ...headersDesc } = Object.getOwnPropertyDescriptor(request, "headers") || {};
-    Object.defineProperty(request, "headers", {
-      ...headersDesc,
-      get() {
-        logger.warn(
-          null,
-          `\`Astro.request.headers\` was used when rendering the route \`${routePattern}'\`. \`Astro.request.headers\` is not available on prerendered pages. If you need access to request headers, make sure that the page is server-rendered using \`export const prerender = false;\` or by setting \`output\` to \`"server"\` in your Astro config to make all your pages server-rendered by default.`
-        );
-        return _headers;
-      },
-      set(newHeaders) {
-        _headers = newHeaders;
-      }
-    });
-  }
-  return request;
-}
-
-function findRouteToRewrite({
-  payload,
-  routes,
-  request,
-  trailingSlash,
-  buildFormat,
-  base
-}) {
-  let newUrl = void 0;
-  if (payload instanceof URL) {
-    newUrl = payload;
-  } else if (payload instanceof Request) {
-    newUrl = new URL(payload.url);
-  } else {
-    newUrl = new URL(payload, new URL(request.url).origin);
-  }
-  let pathname = newUrl.pathname;
-  const shouldAppendSlash = shouldAppendForwardSlash(trailingSlash, buildFormat);
-  if (base !== "/" && newUrl.pathname.startsWith(base)) {
-    pathname = shouldAppendSlash ? appendForwardSlash$1(newUrl.pathname) : removeTrailingForwardSlash(newUrl.pathname);
-    pathname = pathname.slice(base.length);
-  }
-  if (!pathname.startsWith("/") && shouldAppendSlash && newUrl.pathname.endsWith("/")) {
-    pathname = prependForwardSlash$1(pathname);
-  }
-  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
-    pathname = "";
-  }
-  newUrl.pathname = joinPaths(...[base, pathname].filter(Boolean));
-  const decodedPathname = decodeURI(pathname);
-  let foundRoute;
-  for (const route of routes) {
-    if (route.pattern.test(decodedPathname)) {
-      foundRoute = route;
-      break;
-    }
-  }
-  if (foundRoute) {
-    return {
-      routeData: foundRoute,
-      newUrl,
-      pathname: decodedPathname
-    };
-  } else {
-    const custom404 = routes.find((route) => route.route === "/404");
-    if (custom404) {
-      return { routeData: custom404, newUrl, pathname };
-    } else {
-      return { routeData: DEFAULT_404_ROUTE, newUrl, pathname };
-    }
-  }
-}
-function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
-  if (oldRequest.bodyUsed) {
-    throw new AstroError(RewriteWithBodyUsed);
-  }
-  return createRequest({
-    url: newUrl,
-    method: oldRequest.method,
-    body: oldRequest.body,
-    isPrerendered,
-    logger,
-    headers: isPrerendered ? {} : oldRequest.headers,
-    routePattern,
-    init: {
-      referrer: oldRequest.referrer,
-      referrerPolicy: oldRequest.referrerPolicy,
-      mode: oldRequest.mode,
-      credentials: oldRequest.credentials,
-      cache: oldRequest.cache,
-      redirect: oldRequest.redirect,
-      integrity: oldRequest.integrity,
-      signal: oldRequest.signal,
-      keepalive: oldRequest.keepalive,
-      // https://fetch.spec.whatwg.org/#dom-request-duplex
-      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
-      duplex: "half"
-    }
-  });
-}
-function setOriginPathname(request, pathname) {
-  Reflect.set(request, originPathnameSymbol, encodeURIComponent(pathname));
-}
-function getOriginPathname(request) {
-  const origin = Reflect.get(request, originPathnameSymbol);
-  if (origin) {
-    return decodeURIComponent(origin);
-  }
-  return new URL(request.url).pathname;
-}
-
-const FORM_CONTENT_TYPES = [
-  "application/x-www-form-urlencoded",
-  "multipart/form-data",
-  "text/plain"
-];
-const SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
-function createOriginCheckMiddleware() {
-  return defineMiddleware((context, next) => {
-    const { request, url, isPrerendered } = context;
-    if (isPrerendered) {
-      return next();
-    }
-    if (SAFE_METHODS.includes(request.method)) {
-      return next();
-    }
-    const isSameOrigin = request.headers.get("origin") === url.origin;
-    const hasContentType = request.headers.has("content-type");
-    if (hasContentType) {
-      const formLikeHeader = hasFormLikeHeader(request.headers.get("content-type"));
-      if (formLikeHeader && !isSameOrigin) {
-        return new Response(`Cross-site ${request.method} form submissions are forbidden`, {
-          status: 403
-        });
-      }
-    } else {
-      if (!isSameOrigin) {
-        return new Response(`Cross-site ${request.method} form submissions are forbidden`, {
-          status: 403
-        });
-      }
-    }
-    return next();
-  });
-}
-function hasFormLikeHeader(contentType) {
-  if (contentType) {
-    for (const FORM_CONTENT_TYPE of FORM_CONTENT_TYPES) {
-      if (contentType.toLowerCase().includes(FORM_CONTENT_TYPE)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
 const VALID_PARAM_TYPES = ["string", "number", "undefined"];
 function validateGetStaticPathsParameter([key, value], route) {
   if (!VALID_PARAM_TYPES.includes(typeof value)) {
@@ -1418,74 +1208,6 @@ function findPathItemByKey(staticPaths, params, route, logger) {
   logger.debug("router", `findPathItemByKey() - Unexpected cache miss looking for ${paramsKey}`);
 }
 
-function createDefaultRoutes(manifest) {
-  const root = new URL(manifest.hrefRoot);
-  return [
-    {
-      instance: default404Instance,
-      matchesComponent: (filePath) => filePath.href === new URL(DEFAULT_404_COMPONENT, root).href,
-      route: DEFAULT_404_ROUTE.route,
-      component: DEFAULT_404_COMPONENT
-    },
-    {
-      instance: createEndpoint(manifest),
-      matchesComponent: (filePath) => filePath.href === new URL(SERVER_ISLAND_COMPONENT, root).href,
-      route: SERVER_ISLAND_ROUTE,
-      component: SERVER_ISLAND_COMPONENT
-    }
-  ];
-}
-
-class Pipeline {
-  constructor(logger, manifest, runtimeMode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest)) {
-    this.logger = logger;
-    this.manifest = manifest;
-    this.runtimeMode = runtimeMode;
-    this.renderers = renderers;
-    this.resolve = resolve;
-    this.serverLike = serverLike;
-    this.streaming = streaming;
-    this.adapterName = adapterName;
-    this.clientDirectives = clientDirectives;
-    this.inlinedScripts = inlinedScripts;
-    this.compressHTML = compressHTML;
-    this.i18n = i18n;
-    this.middleware = middleware;
-    this.routeCache = routeCache;
-    this.site = site;
-    this.defaultRoutes = defaultRoutes;
-    this.internalMiddleware = [];
-    if (i18n?.strategy !== "manual") {
-      this.internalMiddleware.push(
-        createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
-      );
-    }
-  }
-  internalMiddleware;
-  resolvedMiddleware = void 0;
-  /**
-   * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
-   * it returns a no-op function
-   */
-  async getMiddleware() {
-    if (this.resolvedMiddleware) {
-      return this.resolvedMiddleware;
-    } else if (this.middleware) {
-      const middlewareInstance = await this.middleware();
-      const onRequest = middlewareInstance.onRequest ?? NOOP_MIDDLEWARE_FN;
-      if (this.manifest.checkOrigin) {
-        this.resolvedMiddleware = sequence(createOriginCheckMiddleware(), onRequest);
-      } else {
-        this.resolvedMiddleware = onRequest;
-      }
-      return this.resolvedMiddleware;
-    } else {
-      this.resolvedMiddleware = NOOP_MIDDLEWARE_FN;
-      return this.resolvedMiddleware;
-    }
-  }
-}
-
 function routeIsRedirect(route) {
   return route?.type === "redirect";
 }
@@ -1493,19 +1215,6 @@ function routeIsFallback(route) {
   return route?.type === "fallback";
 }
 
-const RedirectComponentInstance = {
-  default() {
-    return new Response(null, {
-      status: 301
-    });
-  }
-};
-const RedirectSinglePageBuiltModule = {
-  page: () => Promise.resolve(RedirectComponentInstance),
-  onRequest: (_, next) => next(),
-  renderers: []
-};
-
 async function getProps(opts) {
   const { logger, mod, routeData: route, routeCache, pathname, serverLike, base } = opts;
   if (!route || route.pathname) {
@@ -1634,79 +1343,673 @@ class Slots {
   }
 }
 
-function sequence(...handlers) {
-  const filtered = handlers.filter((h) => !!h);
-  const length = filtered.length;
-  if (!length) {
-    return defineMiddleware((_context, next) => {
-      return next();
-    });
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
   }
-  return defineMiddleware((context, next) => {
-    let carriedPayload = void 0;
-    return applyHandle(0, context);
-    function applyHandle(i, handleContext) {
-      const handle = filtered[i];
-      const result = handle(handleContext, async (payload) => {
-        if (i < length - 1) {
-          if (payload) {
-            let newRequest;
-            if (payload instanceof Request) {
-              newRequest = payload;
-            } else if (payload instanceof URL) {
-              newRequest = new Request(payload, handleContext.request);
-            } else {
-              newRequest = new Request(
-                new URL(payload, handleContext.url.origin),
-                handleContext.request
-              );
-            }
-            const pipeline = Reflect.get(handleContext, apiContextRoutesSymbol);
-            const { routeData, pathname } = await pipeline.tryRewrite(
-              payload,
-              handleContext.request
-            );
-            if (pipeline.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
-              throw new AstroError({
-                ...ForbiddenRewrite,
-                message: ForbiddenRewrite.message(
-                  handleContext.url.pathname,
-                  pathname,
-                  routeData.component
-                ),
-                hint: ForbiddenRewrite.hint(routeData.component)
-              });
-            }
-            carriedPayload = payload;
-            handleContext.request = newRequest;
-            handleContext.url = new URL(newRequest.url);
-            handleContext.cookies = new AstroCookies(newRequest);
-            handleContext.params = getParams(routeData, pathname);
-          }
-          return applyHandle(i + 1, handleContext);
-        } else {
-          return next(payload ?? carriedPayload);
-        }
-      });
-      return result;
+  return value;
+}
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
+    return value.slice(1, -1);
+  }
+  const _value = value.trim();
+  if (_value.length <= 9) {
+    switch (_value.toLowerCase()) {
+      case "true": {
+        return true;
+      }
+      case "false": {
+        return false;
+      }
+      case "undefined": {
+        return void 0;
+      }
+      case "null": {
+        return null;
+      }
+      case "nan": {
+        return Number.NaN;
+      }
+      case "infinity": {
+        return Number.POSITIVE_INFINITY;
+      }
+      case "-infinity": {
+        return Number.NEGATIVE_INFINITY;
+      }
     }
-  });
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
 }
 
-function defineMiddleware(fn) {
-  return fn;
+function wrapToPromise(value) {
+  if (!value || typeof value.then !== "function") {
+    return Promise.resolve(value);
+  }
+  return value;
 }
-
-const PERSIST_SYMBOL = Symbol();
-const DEFAULT_COOKIE_NAME = "astro-session";
-const VALID_COOKIE_REGEX = /^[\w-]+$/;
-const unflatten = (parsed, _) => {
-  return unflatten$1(parsed, {
-    URL: (href) => new URL(href)
-  });
+function asyncCall(function_, ...arguments_) {
+  try {
+    return wrapToPromise(function_(...arguments_));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+function isPrimitive(value) {
+  const type = typeof value;
+  return value === null || type !== "object" && type !== "function";
+}
+function isPureObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return !proto || proto.isPrototypeOf(Object);
+}
+function stringify$1(value) {
+  if (isPrimitive(value)) {
+    return String(value);
+  }
+  if (isPureObject(value) || Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value.toJSON === "function") {
+    return stringify$1(value.toJSON());
+  }
+  throw new Error("[unstorage] Cannot stringify value!");
+}
+const BASE64_PREFIX = "base64:";
+function serializeRaw(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return BASE64_PREFIX + base64Encode(value);
+}
+function deserializeRaw(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (!value.startsWith(BASE64_PREFIX)) {
+    return value;
+  }
+  return base64Decode(value.slice(BASE64_PREFIX.length));
+}
+function base64Decode(input) {
+  if (globalThis.Buffer) {
+    return Buffer.from(input, "base64");
+  }
+  return Uint8Array.from(
+    globalThis.atob(input),
+    (c) => c.codePointAt(0)
+  );
+}
+function base64Encode(input) {
+  if (globalThis.Buffer) {
+    return Buffer.from(input).toString("base64");
+  }
+  return globalThis.btoa(String.fromCodePoint(...input));
+}
+function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.split("?")[0]?.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "") || "";
+}
+function joinKeys(...keys) {
+  return normalizeKey(keys.join(":"));
+}
+function normalizeBaseKey(base) {
+  base = normalizeKey(base);
+  return base ? base + ":" : "";
+}
+function filterKeyByDepth(key, depth) {
+  if (depth === void 0) {
+    return true;
+  }
+  let substrCount = 0;
+  let index = key.indexOf(":");
+  while (index > -1) {
+    substrCount++;
+    index = key.indexOf(":", index + 1);
+  }
+  return substrCount <= depth;
+}
+function filterKeyByBase(key, base) {
+  if (base) {
+    return key.startsWith(base) && key[key.length - 1] !== "$";
+  }
+  return key[key.length - 1] !== "$";
+}
+
+function defineDriver(factory) {
+  return factory;
+}
+
+const DRIVER_NAME = "memory";
+const memory = defineDriver(() => {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    name: DRIVER_NAME,
+    getInstance: () => data,
+    hasItem(key) {
+      return data.has(key);
+    },
+    getItem(key) {
+      return data.get(key) ?? null;
+    },
+    getItemRaw(key) {
+      return data.get(key) ?? null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    },
+    setItemRaw(key, value) {
+      data.set(key, value);
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+    getKeys() {
+      return [...data.keys()];
+    },
+    clear() {
+      data.clear();
+    },
+    dispose() {
+      data.clear();
+    }
+  };
+});
+
+function createStorage(options = {}) {
+  const context = {
+    mounts: { "": options.driver || memory() },
+    mountpoints: [""],
+    watching: false,
+    watchListeners: [],
+    unwatch: {}
+  };
+  const getMount = (key) => {
+    for (const base of context.mountpoints) {
+      if (key.startsWith(base)) {
+        return {
+          base,
+          relativeKey: key.slice(base.length),
+          driver: context.mounts[base]
+        };
+      }
+    }
+    return {
+      base: "",
+      relativeKey: key,
+      driver: context.mounts[""]
+    };
+  };
+  const getMounts = (base, includeParent) => {
+    return context.mountpoints.filter(
+      (mountpoint) => mountpoint.startsWith(base) || includeParent && base.startsWith(mountpoint)
+    ).map((mountpoint) => ({
+      relativeBase: base.length > mountpoint.length ? base.slice(mountpoint.length) : void 0,
+      mountpoint,
+      driver: context.mounts[mountpoint]
+    }));
+  };
+  const onChange = (event, key) => {
+    if (!context.watching) {
+      return;
+    }
+    key = normalizeKey(key);
+    for (const listener of context.watchListeners) {
+      listener(event, key);
+    }
+  };
+  const startWatch = async () => {
+    if (context.watching) {
+      return;
+    }
+    context.watching = true;
+    for (const mountpoint in context.mounts) {
+      context.unwatch[mountpoint] = await watch(
+        context.mounts[mountpoint],
+        onChange,
+        mountpoint
+      );
+    }
+  };
+  const stopWatch = async () => {
+    if (!context.watching) {
+      return;
+    }
+    for (const mountpoint in context.unwatch) {
+      await context.unwatch[mountpoint]();
+    }
+    context.unwatch = {};
+    context.watching = false;
+  };
+  const runBatch = (items, commonOptions, cb) => {
+    const batches = /* @__PURE__ */ new Map();
+    const getBatch = (mount) => {
+      let batch = batches.get(mount.base);
+      if (!batch) {
+        batch = {
+          driver: mount.driver,
+          base: mount.base,
+          items: []
+        };
+        batches.set(mount.base, batch);
+      }
+      return batch;
+    };
+    for (const item of items) {
+      const isStringItem = typeof item === "string";
+      const key = normalizeKey(isStringItem ? item : item.key);
+      const value = isStringItem ? void 0 : item.value;
+      const options2 = isStringItem || !item.options ? commonOptions : { ...commonOptions, ...item.options };
+      const mount = getMount(key);
+      getBatch(mount).items.push({
+        key,
+        value,
+        relativeKey: mount.relativeKey,
+        options: options2
+      });
+    }
+    return Promise.all([...batches.values()].map((batch) => cb(batch))).then(
+      (r) => r.flat()
+    );
+  };
+  const storage = {
+    // Item
+    hasItem(key, opts = {}) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return asyncCall(driver.hasItem, relativeKey, opts);
+    },
+    getItem(key, opts = {}) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return asyncCall(driver.getItem, relativeKey, opts).then(
+        (value) => destr(value)
+      );
+    },
+    getItems(items, commonOptions = {}) {
+      return runBatch(items, commonOptions, (batch) => {
+        if (batch.driver.getItems) {
+          return asyncCall(
+            batch.driver.getItems,
+            batch.items.map((item) => ({
+              key: item.relativeKey,
+              options: item.options
+            })),
+            commonOptions
+          ).then(
+            (r) => r.map((item) => ({
+              key: joinKeys(batch.base, item.key),
+              value: destr(item.value)
+            }))
+          );
+        }
+        return Promise.all(
+          batch.items.map((item) => {
+            return asyncCall(
+              batch.driver.getItem,
+              item.relativeKey,
+              item.options
+            ).then((value) => ({
+              key: item.key,
+              value: destr(value)
+            }));
+          })
+        );
+      });
+    },
+    getItemRaw(key, opts = {}) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (driver.getItemRaw) {
+        return asyncCall(driver.getItemRaw, relativeKey, opts);
+      }
+      return asyncCall(driver.getItem, relativeKey, opts).then(
+        (value) => deserializeRaw(value)
+      );
+    },
+    async setItem(key, value, opts = {}) {
+      if (value === void 0) {
+        return storage.removeItem(key);
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.setItem) {
+        return;
+      }
+      await asyncCall(driver.setItem, relativeKey, stringify$1(value), opts);
+      if (!driver.watch) {
+        onChange("update", key);
+      }
+    },
+    async setItems(items, commonOptions) {
+      await runBatch(items, commonOptions, async (batch) => {
+        if (batch.driver.setItems) {
+          return asyncCall(
+            batch.driver.setItems,
+            batch.items.map((item) => ({
+              key: item.relativeKey,
+              value: stringify$1(item.value),
+              options: item.options
+            })),
+            commonOptions
+          );
+        }
+        if (!batch.driver.setItem) {
+          return;
+        }
+        await Promise.all(
+          batch.items.map((item) => {
+            return asyncCall(
+              batch.driver.setItem,
+              item.relativeKey,
+              stringify$1(item.value),
+              item.options
+            );
+          })
+        );
+      });
+    },
+    async setItemRaw(key, value, opts = {}) {
+      if (value === void 0) {
+        return storage.removeItem(key, opts);
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (driver.setItemRaw) {
+        await asyncCall(driver.setItemRaw, relativeKey, value, opts);
+      } else if (driver.setItem) {
+        await asyncCall(driver.setItem, relativeKey, serializeRaw(value), opts);
+      } else {
+        return;
+      }
+      if (!driver.watch) {
+        onChange("update", key);
+      }
+    },
+    async removeItem(key, opts = {}) {
+      if (typeof opts === "boolean") {
+        opts = { removeMeta: opts };
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.removeItem) {
+        return;
+      }
+      await asyncCall(driver.removeItem, relativeKey, opts);
+      if (opts.removeMeta || opts.removeMata) {
+        await asyncCall(driver.removeItem, relativeKey + "$", opts);
+      }
+      if (!driver.watch) {
+        onChange("remove", key);
+      }
+    },
+    // Meta
+    async getMeta(key, opts = {}) {
+      if (typeof opts === "boolean") {
+        opts = { nativeOnly: opts };
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      const meta = /* @__PURE__ */ Object.create(null);
+      if (driver.getMeta) {
+        Object.assign(meta, await asyncCall(driver.getMeta, relativeKey, opts));
+      }
+      if (!opts.nativeOnly) {
+        const value = await asyncCall(
+          driver.getItem,
+          relativeKey + "$",
+          opts
+        ).then((value_) => destr(value_));
+        if (value && typeof value === "object") {
+          if (typeof value.atime === "string") {
+            value.atime = new Date(value.atime);
+          }
+          if (typeof value.mtime === "string") {
+            value.mtime = new Date(value.mtime);
+          }
+          Object.assign(meta, value);
+        }
+      }
+      return meta;
+    },
+    setMeta(key, value, opts = {}) {
+      return this.setItem(key + "$", value, opts);
+    },
+    removeMeta(key, opts = {}) {
+      return this.removeItem(key + "$", opts);
+    },
+    // Keys
+    async getKeys(base, opts = {}) {
+      base = normalizeBaseKey(base);
+      const mounts = getMounts(base, true);
+      let maskedMounts = [];
+      const allKeys = [];
+      let allMountsSupportMaxDepth = true;
+      for (const mount of mounts) {
+        if (!mount.driver.flags?.maxDepth) {
+          allMountsSupportMaxDepth = false;
+        }
+        const rawKeys = await asyncCall(
+          mount.driver.getKeys,
+          mount.relativeBase,
+          opts
+        );
+        for (const key of rawKeys) {
+          const fullKey = mount.mountpoint + normalizeKey(key);
+          if (!maskedMounts.some((p) => fullKey.startsWith(p))) {
+            allKeys.push(fullKey);
+          }
+        }
+        maskedMounts = [
+          mount.mountpoint,
+          ...maskedMounts.filter((p) => !p.startsWith(mount.mountpoint))
+        ];
+      }
+      const shouldFilterByDepth = opts.maxDepth !== void 0 && !allMountsSupportMaxDepth;
+      return allKeys.filter(
+        (key) => (!shouldFilterByDepth || filterKeyByDepth(key, opts.maxDepth)) && filterKeyByBase(key, base)
+      );
+    },
+    // Utils
+    async clear(base, opts = {}) {
+      base = normalizeBaseKey(base);
+      await Promise.all(
+        getMounts(base, false).map(async (m) => {
+          if (m.driver.clear) {
+            return asyncCall(m.driver.clear, m.relativeBase, opts);
+          }
+          if (m.driver.removeItem) {
+            const keys = await m.driver.getKeys(m.relativeBase || "", opts);
+            return Promise.all(
+              keys.map((key) => m.driver.removeItem(key, opts))
+            );
+          }
+        })
+      );
+    },
+    async dispose() {
+      await Promise.all(
+        Object.values(context.mounts).map((driver) => dispose(driver))
+      );
+    },
+    async watch(callback) {
+      await startWatch();
+      context.watchListeners.push(callback);
+      return async () => {
+        context.watchListeners = context.watchListeners.filter(
+          (listener) => listener !== callback
+        );
+        if (context.watchListeners.length === 0) {
+          await stopWatch();
+        }
+      };
+    },
+    async unwatch() {
+      context.watchListeners = [];
+      await stopWatch();
+    },
+    // Mount
+    mount(base, driver) {
+      base = normalizeBaseKey(base);
+      if (base && context.mounts[base]) {
+        throw new Error(`already mounted at ${base}`);
+      }
+      if (base) {
+        context.mountpoints.push(base);
+        context.mountpoints.sort((a, b) => b.length - a.length);
+      }
+      context.mounts[base] = driver;
+      if (context.watching) {
+        Promise.resolve(watch(driver, onChange, base)).then((unwatcher) => {
+          context.unwatch[base] = unwatcher;
+        }).catch(console.error);
+      }
+      return storage;
+    },
+    async unmount(base, _dispose = true) {
+      base = normalizeBaseKey(base);
+      if (!base || !context.mounts[base]) {
+        return;
+      }
+      if (context.watching && base in context.unwatch) {
+        context.unwatch[base]?.();
+        delete context.unwatch[base];
+      }
+      if (_dispose) {
+        await dispose(context.mounts[base]);
+      }
+      context.mountpoints = context.mountpoints.filter((key) => key !== base);
+      delete context.mounts[base];
+    },
+    getMount(key = "") {
+      key = normalizeKey(key) + ":";
+      const m = getMount(key);
+      return {
+        driver: m.driver,
+        base: m.base
+      };
+    },
+    getMounts(base = "", opts = {}) {
+      base = normalizeKey(base);
+      const mounts = getMounts(base, opts.parents);
+      return mounts.map((m) => ({
+        driver: m.driver,
+        base: m.mountpoint
+      }));
+    },
+    // Aliases
+    keys: (base, opts = {}) => storage.getKeys(base, opts),
+    get: (key, opts = {}) => storage.getItem(key, opts),
+    set: (key, value, opts = {}) => storage.setItem(key, value, opts),
+    has: (key, opts = {}) => storage.hasItem(key, opts),
+    del: (key, opts = {}) => storage.removeItem(key, opts),
+    remove: (key, opts = {}) => storage.removeItem(key, opts)
+  };
+  return storage;
+}
+function watch(driver, onChange, base) {
+  return driver.watch ? driver.watch((event, key) => onChange(event, base + key)) : () => {
+  };
+}
+async function dispose(driver) {
+  if (typeof driver.dispose === "function") {
+    await asyncCall(driver.dispose);
+  }
+}
+
+const builtinDrivers = {
+  "azure-app-configuration": "unstorage/drivers/azure-app-configuration",
+  "azureAppConfiguration": "unstorage/drivers/azure-app-configuration",
+  "azure-cosmos": "unstorage/drivers/azure-cosmos",
+  "azureCosmos": "unstorage/drivers/azure-cosmos",
+  "azure-key-vault": "unstorage/drivers/azure-key-vault",
+  "azureKeyVault": "unstorage/drivers/azure-key-vault",
+  "azure-storage-blob": "unstorage/drivers/azure-storage-blob",
+  "azureStorageBlob": "unstorage/drivers/azure-storage-blob",
+  "azure-storage-table": "unstorage/drivers/azure-storage-table",
+  "azureStorageTable": "unstorage/drivers/azure-storage-table",
+  "capacitor-preferences": "unstorage/drivers/capacitor-preferences",
+  "capacitorPreferences": "unstorage/drivers/capacitor-preferences",
+  "cloudflare-kv-binding": "unstorage/drivers/cloudflare-kv-binding",
+  "cloudflareKVBinding": "unstorage/drivers/cloudflare-kv-binding",
+  "cloudflare-kv-http": "unstorage/drivers/cloudflare-kv-http",
+  "cloudflareKVHttp": "unstorage/drivers/cloudflare-kv-http",
+  "cloudflare-r2-binding": "unstorage/drivers/cloudflare-r2-binding",
+  "cloudflareR2Binding": "unstorage/drivers/cloudflare-r2-binding",
+  "db0": "unstorage/drivers/db0",
+  "deno-kv-node": "unstorage/drivers/deno-kv-node",
+  "denoKVNode": "unstorage/drivers/deno-kv-node",
+  "deno-kv": "unstorage/drivers/deno-kv",
+  "denoKV": "unstorage/drivers/deno-kv",
+  "fs-lite": "unstorage/drivers/fs-lite",
+  "fsLite": "unstorage/drivers/fs-lite",
+  "fs": "unstorage/drivers/fs",
+  "github": "unstorage/drivers/github",
+  "http": "unstorage/drivers/http",
+  "indexedb": "unstorage/drivers/indexedb",
+  "localstorage": "unstorage/drivers/localstorage",
+  "lru-cache": "unstorage/drivers/lru-cache",
+  "lruCache": "unstorage/drivers/lru-cache",
+  "memory": "unstorage/drivers/memory",
+  "mongodb": "unstorage/drivers/mongodb",
+  "netlify-blobs": "unstorage/drivers/netlify-blobs",
+  "netlifyBlobs": "unstorage/drivers/netlify-blobs",
+  "null": "unstorage/drivers/null",
+  "overlay": "unstorage/drivers/overlay",
+  "planetscale": "unstorage/drivers/planetscale",
+  "redis": "unstorage/drivers/redis",
+  "s3": "unstorage/drivers/s3",
+  "session-storage": "unstorage/drivers/session-storage",
+  "sessionStorage": "unstorage/drivers/session-storage",
+  "uploadthing": "unstorage/drivers/uploadthing",
+  "upstash": "unstorage/drivers/upstash",
+  "vercel-blob": "unstorage/drivers/vercel-blob",
+  "vercelBlob": "unstorage/drivers/vercel-blob",
+  "vercel-kv": "unstorage/drivers/vercel-kv",
+  "vercelKV": "unstorage/drivers/vercel-kv"
+};
+
+const PERSIST_SYMBOL = Symbol();
+const DEFAULT_COOKIE_NAME = "astro-session";
+const VALID_COOKIE_REGEX = /^[\w-]+$/;
+const unflatten = (parsed, _) => {
+  return unflatten$1(parsed, {
+    URL: (href) => new URL(href)
+  });
 };
 const stringify = (data, _) => {
-  return stringify$1(data, {
+  return stringify$2(data, {
     // Support URL objects
     URL: (val) => val instanceof URL && val.href
   });
@@ -1739,10 +2042,11 @@ class AstroSession {
   // When we load the data from storage, we need to merge it with the local partial data,
   // preserving in-memory changes and deletions.
   #partial = true;
+  static #sharedStorage = /* @__PURE__ */ new Map();
   constructor(cookies, {
     cookie: cookieConfig = DEFAULT_COOKIE_NAME,
     ...config
-  }) {
+  }, runtimeMode) {
     this.#cookies = cookies;
     let cookieConfigObject;
     if (typeof cookieConfig === "object") {
@@ -1754,7 +2058,7 @@ class AstroSession {
     }
     this.#cookieConfig = {
       sameSite: "lax",
-      secure: true,
+      secure: runtimeMode === "production",
       path: "/",
       ...cookieConfigObject,
       httpOnly: true
@@ -1906,6 +2210,19 @@ class AstroSession {
   get sessionID() {
     return this.#sessionID;
   }
+  /**
+   * Loads a session from storage with the given ID, and replaces the current session.
+   * Any changes made to the current session will be lost.
+   * This is not normally needed, as the session is automatically loaded using the cookie.
+   * However it can be used to restore a session where the ID has been recorded somewhere
+   * else (e.g. in a database).
+   */
+  async load(sessionID) {
+    this.#sessionID = sessionID;
+    this.#data = void 0;
+    await this.#setCookie();
+    await this.#ensureData();
+  }
   /**
    * Sets the session cookie.
    */
@@ -2000,6 +2317,10 @@ class AstroSession {
     if (this.#storage) {
       return this.#storage;
     }
+    if (AstroSession.#sharedStorage.has(this.#config.driver)) {
+      this.#storage = AstroSession.#sharedStorage.get(this.#config.driver);
+      return this.#storage;
+    }
     if (this.#config.driver === "test") {
       this.#storage = this.#config.options.mockStorage;
       return this.#storage;
@@ -2018,12 +2339,14 @@ class AstroSession {
       });
     }
     let driver = null;
-    const driverPackage = await resolveSessionDriver(this.#config.driver);
     try {
       if (this.#config.driverModule) {
         driver = (await this.#config.driverModule()).default;
-      } else if (driverPackage) {
-        driver = (await import(driverPackage)).default;
+      } else if (this.#config.driver) {
+        const driverName = resolveSessionDriverName(this.#config.driver);
+        if (driverName) {
+          driver = (await import(driverName)).default;
+        }
       }
     } catch (err) {
       if (err.code === "ERR_MODULE_NOT_FOUND") {
@@ -2031,7 +2354,7 @@ class AstroSession {
           {
             ...SessionStorageInitError,
             message: SessionStorageInitError.message(
-              err.message.includes(`Cannot find package '${driverPackage}'`) ? "The driver module could not be found." : err.message,
+              err.message.includes(`Cannot find package`) ? "The driver module could not be found." : err.message,
               this.#config.driver
             )
           },
@@ -2053,6 +2376,7 @@ class AstroSession {
       this.#storage = createStorage({
         driver: driver(this.#config.options)
       });
+      AstroSession.#sharedStorage.set(this.#config.driver, this.#storage);
       return this.#storage;
     } catch (err) {
       throw new AstroError(
@@ -2065,16 +2389,16 @@ class AstroSession {
     }
   }
 }
-async function resolveSessionDriver(driver) {
+function resolveSessionDriverName(driver) {
   if (!driver) {
     return null;
   }
   try {
     if (driver === "fs") {
-      return await import.meta.resolve(builtinDrivers.fsLite);
+      return builtinDrivers.fsLite;
     }
     if (driver in builtinDrivers) {
-      return await import.meta.resolve(builtinDrivers[driver]);
+      return builtinDrivers[driver];
     }
   } catch {
     return null;
@@ -2084,10 +2408,11 @@ async function resolveSessionDriver(driver) {
 
 const apiContextRoutesSymbol = Symbol.for("context.routes");
 class RenderContext {
-  constructor(pipeline, locals, middleware, pathname, request, routeData, status, clientAddress, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = new URL(request.url), props = {}, partial = void 0, session = pipeline.manifest.sessionConfig ? new AstroSession(cookies, pipeline.manifest.sessionConfig) : void 0) {
+  constructor(pipeline, locals, middleware, actions, pathname, request, routeData, status, clientAddress, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = new URL(request.url), props = {}, partial = void 0, session = pipeline.manifest.sessionConfig ? new AstroSession(cookies, pipeline.manifest.sessionConfig, pipeline.runtimeMode) : void 0) {
     this.pipeline = pipeline;
     this.locals = locals;
     this.middleware = middleware;
+    this.actions = actions;
     this.pathname = pathname;
     this.request = request;
     this.routeData = routeData;
@@ -2108,6 +2433,7 @@ class RenderContext {
    * A safety net in case of loops
    */
   counter = 0;
+  result = void 0;
   static async create({
     locals = {},
     middleware,
@@ -2118,14 +2444,17 @@ class RenderContext {
     clientAddress,
     status = 200,
     props,
-    partial = void 0
+    partial = void 0,
+    actions
   }) {
     const pipelineMiddleware = await pipeline.getMiddleware();
+    const pipelineActions = actions ?? await pipeline.getActions();
     setOriginPathname(request, pathname);
     return new RenderContext(
       pipeline,
       locals,
       sequence(...pipeline.internalMiddleware, middleware ?? pipelineMiddleware),
+      pipelineActions,
       pathname,
       request,
       routeData,
@@ -2161,7 +2490,8 @@ class RenderContext {
       serverLike,
       base: manifest.base
     });
-    const apiContext = this.createAPIContext(props);
+    const actionApiContext = this.createActionAPIContext();
+    const apiContext = this.createAPIContext(props, actionApiContext);
     this.counter++;
     if (this.counter === 4) {
       return new Response("Loop Detected", {
@@ -2172,6 +2502,7 @@ class RenderContext {
     }
     const lastNext = async (ctx, payload) => {
       if (payload) {
+        const oldPathname = this.pathname;
         pipeline.logger.debug("router", "Called rewriting to:", payload);
         const {
           routeData,
@@ -2202,12 +2533,19 @@ class RenderContext {
         }
         this.isRewriting = true;
         this.url = new URL(this.request.url);
-        this.cookies = new AstroCookies(this.request);
         this.params = getParams(routeData, pathname);
         this.pathname = pathname;
         this.status = 200;
+        setOriginPathname(this.request, oldPathname);
       }
       let response2;
+      if (!ctx.isPrerendered) {
+        const { action, setActionResult, serializeActionResult } = getActionContext(ctx);
+        if (action?.calledFrom === "form") {
+          const actionResult = await action.handler();
+          setActionResult(action.name, serializeActionResult(actionResult));
+        }
+      }
       switch (this.routeData.type) {
         case "endpoint": {
           response2 = await renderEndpoint(
@@ -2221,10 +2559,10 @@ class RenderContext {
         case "redirect":
           return renderRedirect(this);
         case "page": {
-          const result = await this.createResult(componentInstance);
+          this.result = await this.createResult(componentInstance, actionApiContext);
           try {
             response2 = await renderPage(
-              result,
+              this.result,
               componentInstance?.default,
               props,
               slots,
@@ -2232,7 +2570,7 @@ class RenderContext {
               this.routeData
             );
           } catch (e) {
-            result.cancelled = true;
+            this.result.cancelled = true;
             throw e;
           }
           response2.headers.set(ROUTE_TYPE_HEADER, "page");
@@ -2264,8 +2602,7 @@ class RenderContext {
     attachCookiesToResponse(response, cookies);
     return response;
   }
-  createAPIContext(props) {
-    const context = this.createActionAPIContext();
+  createAPIContext(props, context) {
     const redirect = (path, status = 302) => new Response(null, { status, headers: { Location: path } });
     Reflect.set(context, apiContextRoutesSymbol, this.pipeline);
     return Object.assign(context, {
@@ -2277,11 +2614,12 @@ class RenderContext {
   }
   async #executeRewrite(reroutePayload) {
     this.pipeline.logger.debug("router", "Calling rewrite: ", reroutePayload);
+    const oldPathname = this.pathname;
     const { routeData, componentInstance, newUrl, pathname } = await this.pipeline.tryRewrite(
       reroutePayload,
       this.request
     );
-    if (this.pipeline.serverLike === true && this.routeData.prerender === false && routeData.prerender === true) {
+    if (this.pipeline.serverLike && !this.routeData.prerender && routeData.prerender) {
       throw new AstroError({
         ...ForbiddenRewrite,
         message: ForbiddenRewrite.message(this.pathname, pathname, routeData.component),
@@ -2307,11 +2645,12 @@ class RenderContext {
     this.pathname = pathname;
     this.isRewriting = true;
     this.status = 200;
+    setOriginPathname(this.request, oldPathname);
     return await this.render(componentInstance);
   }
   createActionAPIContext() {
     const renderContext = this;
-    const { cookies, params, pipeline, url, session } = this;
+    const { cookies, params, pipeline, url } = this;
     const generator = `Astro v${ASTRO_VERSION}`;
     const rewrite = async (reroutePayload) => {
       return await this.#executeRewrite(reroutePayload);
@@ -2347,10 +2686,56 @@ class RenderContext {
       get originPathname() {
         return getOriginPathname(renderContext.request);
       },
-      session
+      get session() {
+        if (this.isPrerendered) {
+          pipeline.logger.warn(
+            "session",
+            `context.session was used when rendering the route ${green(this.routePattern)}, but it is not available on prerendered routes. If you need access to sessions, make sure that the route is server-rendered using \`export const prerender = false;\` or by setting \`output\` to \`"server"\` in your Astro config to make all your routes server-rendered by default. For more information, see https://docs.astro.build/en/guides/sessions/`
+          );
+          return void 0;
+        }
+        if (!renderContext.session) {
+          pipeline.logger.warn(
+            "session",
+            `context.session was used when rendering the route ${green(this.routePattern)}, but no storage configuration was provided. Either configure the storage manually or use an adapter that provides session storage. For more information, see https://docs.astro.build/en/guides/sessions/`
+          );
+          return void 0;
+        }
+        return renderContext.session;
+      },
+      insertDirective(payload) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.directives.push(payload);
+      },
+      insertScriptResource(resource) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.scriptResources.push(resource);
+      },
+      insertStyleResource(resource) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.styleResources.push(resource);
+      },
+      insertStyleHash(hash) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.styleHashes.push(hash);
+      },
+      insertScriptHash(hash) {
+        if (!!pipeline.manifest.csp === false) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.scriptHashes.push(hash);
+      }
     };
   }
-  async createResult(mod) {
+  async createResult(mod, ctx) {
     const { cookies, pathname, pipeline, routeData, status } = this;
     const { clientDirectives, inlinedScripts, compressHTML, manifest, renderers, resolve } = pipeline;
     const { links, scripts, styles } = await pipeline.headElements(routeData);
@@ -2379,7 +2764,7 @@ class RenderContext {
       compressHTML,
       cookies,
       /** This function returns the `Astro` faux-global */
-      createAstro: (astroGlobal, props, slots) => this.createAstro(result, astroGlobal, props, slots),
+      createAstro: (astroGlobal, props, slots) => this.createAstro(result, astroGlobal, props, slots, ctx),
       links,
       params: this.params,
       partial,
@@ -2400,10 +2785,23 @@ class RenderContext {
         hasRenderedHead: false,
         renderedScripts: /* @__PURE__ */ new Set(),
         hasDirectives: /* @__PURE__ */ new Set(),
+        hasRenderedServerIslandRuntime: false,
         headInTree: false,
         extraHead: [],
+        extraStyleHashes: [],
+        extraScriptHashes: [],
         propagators: /* @__PURE__ */ new Set()
-      }
+      },
+      cspDestination: manifest.csp?.cspDestination ?? (routeData.prerender ? "meta" : "header"),
+      shouldInjectCspMetaTags: !!manifest.csp,
+      cspAlgorithm: manifest.csp?.algorithm ?? "SHA-256",
+      // The following arrays must be cloned, otherwise they become mutable across routes.
+      scriptHashes: manifest.csp?.scriptHashes ? [...manifest.csp.scriptHashes] : [],
+      scriptResources: manifest.csp?.scriptResources ? [...manifest.csp.scriptResources] : [],
+      styleHashes: manifest.csp?.styleHashes ? [...manifest.csp.styleHashes] : [],
+      styleResources: manifest.csp?.styleResources ? [...manifest.csp.styleResources] : [],
+      directives: manifest.csp?.directives ? [...manifest.csp.directives] : [],
+      isStrictDynamic: manifest.csp?.isStrictDynamic ?? false
     };
     return result;
   }
@@ -2416,17 +2814,19 @@ class RenderContext {
    *
    * The page level partial is used as the prototype of the user-visible `Astro` global object, which is instantiated once per use of a component.
    */
-  createAstro(result, astroStaticPartial, props, slotValues) {
+  createAstro(result, astroStaticPartial, props, slotValues, apiContext) {
     let astroPagePartial;
     if (this.isRewriting) {
       astroPagePartial = this.#astroPagePartial = this.createAstroPagePartial(
         result,
-        astroStaticPartial
+        astroStaticPartial,
+        apiContext
       );
     } else {
       astroPagePartial = this.#astroPagePartial ??= this.createAstroPagePartial(
         result,
-        astroStaticPartial
+        astroStaticPartial,
+        apiContext
       );
     }
     const astroComponentPartial = { props, self: null };
@@ -2449,9 +2849,9 @@ class RenderContext {
     });
     return Astro;
   }
-  createAstroPagePartial(result, astroStaticPartial) {
+  createAstroPagePartial(result, astroStaticPartial, apiContext) {
     const renderContext = this;
-    const { cookies, locals, params, pipeline, url, session } = this;
+    const { cookies, locals, params, pipeline, url } = this;
     const { response } = result;
     const redirect = (path, status = 302) => {
       if (this.request[responseSentSymbol$1]) {
@@ -2464,13 +2864,30 @@ class RenderContext {
     const rewrite = async (reroutePayload) => {
       return await this.#executeRewrite(reroutePayload);
     };
+    const callAction = createCallAction(apiContext);
     return {
       generator: astroStaticPartial.generator,
       glob: astroStaticPartial.glob,
       routePattern: this.routeData.route,
       isPrerendered: this.routeData.prerender,
       cookies,
-      session,
+      get session() {
+        if (this.isPrerendered) {
+          pipeline.logger.warn(
+            "session",
+            `Astro.session was used when rendering the route ${green(this.routePattern)}, but it is not available on prerendered pages. If you need access to sessions, make sure that the page is server-rendered using \`export const prerender = false;\` or by setting \`output\` to \`"server"\` in your Astro config to make all your pages server-rendered by default. For more information, see https://docs.astro.build/en/guides/sessions/`
+          );
+          return void 0;
+        }
+        if (!renderContext.session) {
+          pipeline.logger.warn(
+            "session",
+            `Astro.session was used when rendering the route ${green(this.routePattern)}, but no storage configuration was provided. Either configure the storage manually or use an adapter that provides session storage. For more information, see https://docs.astro.build/en/guides/sessions/`
+          );
+          return void 0;
+        }
+        return renderContext.session;
+      },
       get clientAddress() {
         return renderContext.getClientAddress();
       },
@@ -2492,18 +2909,51 @@ class RenderContext {
       site: pipeline.site,
       getActionResult: createGetActionResult(locals),
       get callAction() {
-        return createCallAction(this);
+        return callAction;
       },
       url,
       get originPathname() {
         return getOriginPathname(renderContext.request);
+      },
+      insertDirective(payload) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.directives.push(payload);
+      },
+      insertScriptResource(resource) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.scriptResources.push(resource);
+      },
+      insertStyleResource(resource) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.styleResources.push(resource);
+      },
+      insertStyleHash(hash) {
+        if (!pipeline.manifest.csp) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.styleHashes.push(hash);
+      },
+      insertScriptHash(hash) {
+        if (!!pipeline.manifest.csp === false) {
+          throw new AstroError(CspNotEnabled);
+        }
+        renderContext.result?.scriptHashes.push(hash);
       }
     };
   }
   getClientAddress() {
     const { pipeline, request, routeData, clientAddress } = this;
     if (routeData.prerender) {
-      throw new AstroError(PrerenderClientAddressNotAvailable);
+      throw new AstroError({
+        ...PrerenderClientAddressNotAvailable,
+        message: PrerenderClientAddressNotAvailable.message(routeData.component)
+      });
     }
     if (clientAddress) {
       return clientAddress;
@@ -2581,1041 +3031,69 @@ class RenderContext {
   }
 }
 
-function getAssetsPrefix(fileExtension, assetsPrefix) {
-  if (!assetsPrefix) return "";
-  if (typeof assetsPrefix === "string") return assetsPrefix;
-  const dotLessFileExtension = fileExtension.slice(1);
-  if (assetsPrefix[dotLessFileExtension]) {
-    return assetsPrefix[dotLessFileExtension];
+function sequence(...handlers) {
+  const filtered = handlers.filter((h) => !!h);
+  const length = filtered.length;
+  if (!length) {
+    return defineMiddleware((_context, next) => {
+      return next();
+    });
   }
-  return assetsPrefix.fallback;
+  return defineMiddleware((context, next) => {
+    let carriedPayload = void 0;
+    return applyHandle(0, context);
+    function applyHandle(i, handleContext) {
+      const handle = filtered[i];
+      const result = handle(handleContext, async (payload) => {
+        if (i < length - 1) {
+          if (payload) {
+            let newRequest;
+            if (payload instanceof Request) {
+              newRequest = payload;
+            } else if (payload instanceof URL) {
+              newRequest = new Request(payload, handleContext.request.clone());
+            } else {
+              newRequest = new Request(
+                new URL(payload, handleContext.url.origin),
+                handleContext.request.clone()
+              );
+            }
+            const oldPathname = handleContext.url.pathname;
+            const pipeline = Reflect.get(handleContext, apiContextRoutesSymbol);
+            const { routeData, pathname } = await pipeline.tryRewrite(
+              payload,
+              handleContext.request
+            );
+            if (pipeline.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
+              throw new AstroError({
+                ...ForbiddenRewrite,
+                message: ForbiddenRewrite.message(
+                  handleContext.url.pathname,
+                  pathname,
+                  routeData.component
+                ),
+                hint: ForbiddenRewrite.hint(routeData.component)
+              });
+            }
+            carriedPayload = payload;
+            handleContext.request = newRequest;
+            handleContext.url = new URL(newRequest.url);
+            handleContext.cookies = new AstroCookies(newRequest);
+            handleContext.params = getParams(routeData, pathname);
+            setOriginPathname(handleContext.request, oldPathname);
+          }
+          return applyHandle(i + 1, handleContext);
+        } else {
+          return next(payload ?? carriedPayload);
+        }
+      });
+      return result;
+    }
+  });
 }
 
-function createAssetLink(href, base, assetsPrefix) {
-  if (assetsPrefix) {
-    const pf = getAssetsPrefix(fileExtension(href), assetsPrefix);
-    return joinPaths(pf, slash(href));
-  } else if (base) {
-    return prependForwardSlash$1(joinPaths(base, slash(href)));
-  } else {
-    return href;
-  }
-}
-function createStylesheetElement(stylesheet, base, assetsPrefix) {
-  if (stylesheet.type === "inline") {
-    return {
-      props: {},
-      children: stylesheet.content
-    };
-  } else {
-    return {
-      props: {
-        rel: "stylesheet",
-        href: createAssetLink(stylesheet.src, base, assetsPrefix)
-      },
-      children: ""
-    };
-  }
-}
-function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
-  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
-}
-function createModuleScriptElement(script, base, assetsPrefix) {
-  if (script.type === "external") {
-    return createModuleScriptElementWithSrc(script.value, base, assetsPrefix);
-  } else {
-    return {
-      props: {
-        type: "module"
-      },
-      children: script.value
-    };
-  }
-}
-function createModuleScriptElementWithSrc(src, base, assetsPrefix) {
-  return {
-    props: {
-      type: "module",
-      src: createAssetLink(src, base, assetsPrefix)
-    },
-    children: ""
-  };
-}
-
-function redirectTemplate({ status, location, from }) {
-  const delay = status === 302 ? 2 : 0;
-  return `<!doctype html>
-<title>Redirecting to: ${location}</title>
-<meta http-equiv="refresh" content="${delay};url=${location}">
-<meta name="robots" content="noindex">
-<link rel="canonical" href="${location}">
-<body>
-	<a href="${location}">Redirecting ${from ? `from <code>${from}</code> ` : ""}to <code>${location}</code></a>
-</body>`;
-}
-
-class AppPipeline extends Pipeline {
-  #manifestData;
-  static create(manifestData, {
-    logger,
-    manifest,
-    runtimeMode,
-    renderers,
-    resolve,
-    serverLike,
-    streaming,
-    defaultRoutes
-  }) {
-    const pipeline = new AppPipeline(
-      logger,
-      manifest,
-      runtimeMode,
-      renderers,
-      resolve,
-      serverLike,
-      streaming,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      defaultRoutes
-    );
-    pipeline.#manifestData = manifestData;
-    return pipeline;
-  }
-  headElements(routeData) {
-    const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
-    const links = /* @__PURE__ */ new Set();
-    const scripts = /* @__PURE__ */ new Set();
-    const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
-    for (const script of routeInfo?.scripts ?? []) {
-      if ("stage" in script) {
-        if (script.stage === "head-inline") {
-          scripts.add({
-            props: {},
-            children: script.children
-          });
-        }
-      } else {
-        scripts.add(createModuleScriptElement(script));
-      }
-    }
-    return { links, styles, scripts };
-  }
-  componentMetadata() {
-  }
-  async getComponentByRoute(routeData) {
-    const module = await this.getModuleForRoute(routeData);
-    return module.page();
-  }
-  async tryRewrite(payload, request) {
-    const { newUrl, pathname, routeData } = findRouteToRewrite({
-      payload,
-      request,
-      routes: this.manifest?.routes.map((r) => r.routeData),
-      trailingSlash: this.manifest.trailingSlash,
-      buildFormat: this.manifest.buildFormat,
-      base: this.manifest.base
-    });
-    const componentInstance = await this.getComponentByRoute(routeData);
-    return { newUrl, pathname, componentInstance, routeData };
-  }
-  async getModuleForRoute(route) {
-    for (const defaultRoute of this.defaultRoutes) {
-      if (route.component === defaultRoute.component) {
-        return {
-          page: () => Promise.resolve(defaultRoute.instance),
-          renderers: []
-        };
-      }
-    }
-    if (route.type === "redirect") {
-      return RedirectSinglePageBuiltModule;
-    } else {
-      if (this.manifest.pageMap) {
-        const importComponentInstance = this.manifest.pageMap.get(route.component);
-        if (!importComponentInstance) {
-          throw new Error(
-            `Unexpectedly unable to find a component instance for route ${route.route}`
-          );
-        }
-        return await importComponentInstance();
-      } else if (this.manifest.pageModule) {
-        return this.manifest.pageModule;
-      }
-      throw new Error(
-        "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
-      );
-    }
-  }
-}
-
-class App {
-  #manifest;
-  #manifestData;
-  #logger = new Logger({
-    dest: consoleLogDestination,
-    level: "info"
-  });
-  #baseWithoutTrailingSlash;
-  #pipeline;
-  #adapterLogger;
-  #renderOptionsDeprecationWarningShown = false;
-  constructor(manifest, streaming = true) {
-    this.#manifest = manifest;
-    this.#manifestData = {
-      routes: manifest.routes.map((route) => route.routeData)
-    };
-    ensure404Route(this.#manifestData);
-    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
-    this.#pipeline = this.#createPipeline(this.#manifestData, streaming);
-    this.#adapterLogger = new AstroIntegrationLogger(
-      this.#logger.options,
-      this.#manifest.adapterName
-    );
-  }
-  getAdapterLogger() {
-    return this.#adapterLogger;
-  }
-  /**
-   * Creates a pipeline by reading the stored manifest
-   *
-   * @param manifestData
-   * @param streaming
-   * @private
-   */
-  #createPipeline(manifestData, streaming = false) {
-    return AppPipeline.create(manifestData, {
-      logger: this.#logger,
-      manifest: this.#manifest,
-      runtimeMode: "production",
-      renderers: this.#manifest.renderers,
-      defaultRoutes: createDefaultRoutes(this.#manifest),
-      resolve: async (specifier) => {
-        if (!(specifier in this.#manifest.entryModules)) {
-          throw new Error(`Unable to resolve [${specifier}]`);
-        }
-        const bundlePath = this.#manifest.entryModules[specifier];
-        if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
-          return bundlePath;
-        } else {
-          return createAssetLink(bundlePath, this.#manifest.base, this.#manifest.assetsPrefix);
-        }
-      },
-      serverLike: true,
-      streaming
-    });
-  }
-  set setManifestData(newManifestData) {
-    this.#manifestData = newManifestData;
-  }
-  removeBase(pathname) {
-    if (pathname.startsWith(this.#manifest.base)) {
-      return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
-    }
-    return pathname;
-  }
-  /**
-   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
-   *
-   * If the decoding fails, it logs the error and return the pathname as is.
-   * @param request
-   * @private
-   */
-  #getPathnameFromRequest(request) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash$1(this.removeBase(url.pathname));
-    try {
-      return decodeURI(pathname);
-    } catch (e) {
-      this.getAdapterLogger().error(e.toString());
-      return pathname;
-    }
-  }
-  match(request) {
-    const url = new URL(request.url);
-    if (this.#manifest.assets.has(url.pathname)) return void 0;
-    let pathname = this.#computePathnameFromDomain(request);
-    if (!pathname) {
-      pathname = prependForwardSlash$1(this.removeBase(url.pathname));
-    }
-    let routeData = matchRoute(decodeURI(pathname), this.#manifestData);
-    if (!routeData || routeData.prerender) return void 0;
-    return routeData;
-  }
-  #computePathnameFromDomain(request) {
-    let pathname = void 0;
-    const url = new URL(request.url);
-    if (this.#manifest.i18n && (this.#manifest.i18n.strategy === "domains-prefix-always" || this.#manifest.i18n.strategy === "domains-prefix-other-locales" || this.#manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
-      let host = request.headers.get("X-Forwarded-Host");
-      let protocol = request.headers.get("X-Forwarded-Proto");
-      if (protocol) {
-        protocol = protocol + ":";
-      } else {
-        protocol = url.protocol;
-      }
-      if (!host) {
-        host = request.headers.get("Host");
-      }
-      if (host && protocol) {
-        host = host.split(":")[0];
-        try {
-          let locale;
-          const hostAsUrl = new URL(`${protocol}//${host}`);
-          for (const [domainKey, localeValue] of Object.entries(
-            this.#manifest.i18n.domainLookupTable
-          )) {
-            const domainKeyAsUrl = new URL(domainKey);
-            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
-              locale = localeValue;
-              break;
-            }
-          }
-          if (locale) {
-            pathname = prependForwardSlash$1(
-              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
-            );
-            if (url.pathname.endsWith("/")) {
-              pathname = appendForwardSlash$1(pathname);
-            }
-          }
-        } catch (e) {
-          this.#logger.error(
-            "router",
-            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
-          );
-          this.#logger.error("router", `Error: ${e}`);
-        }
-      }
-    }
-    return pathname;
-  }
-  #redirectTrailingSlash(pathname) {
-    const { trailingSlash } = this.#manifest;
-    if (pathname === "/" || pathname.startsWith("/_")) {
-      return pathname;
-    }
-    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
-    if (path !== pathname) {
-      return path;
-    }
-    if (trailingSlash === "ignore") {
-      return pathname;
-    }
-    if (trailingSlash === "always" && !hasFileExtension$1(pathname)) {
-      return appendForwardSlash$1(pathname);
-    }
-    if (trailingSlash === "never") {
-      return removeTrailingForwardSlash(pathname);
-    }
-    return pathname;
-  }
-  async render(request, renderOptions) {
-    let routeData;
-    let locals;
-    let clientAddress;
-    let addCookieHeader;
-    const url = new URL(request.url);
-    const redirect = this.#redirectTrailingSlash(url.pathname);
-    if (redirect !== url.pathname) {
-      const status = request.method === "GET" ? 301 : 308;
-      return new Response(redirectTemplate({ status, location: redirect, from: request.url }), {
-        status,
-        headers: {
-          location: redirect + url.search
-        }
-      });
-    }
-    addCookieHeader = renderOptions?.addCookieHeader;
-    clientAddress = renderOptions?.clientAddress ?? Reflect.get(request, clientAddressSymbol);
-    routeData = renderOptions?.routeData;
-    locals = renderOptions?.locals;
-    if (routeData) {
-      this.#logger.debug(
-        "router",
-        "The adapter " + this.#manifest.adapterName + " provided a custom RouteData for ",
-        request.url
-      );
-      this.#logger.debug("router", "RouteData:\n" + routeData);
-    }
-    if (locals) {
-      if (typeof locals !== "object") {
-        const error = new AstroError(LocalsNotAnObject);
-        this.#logger.error(null, error.stack);
-        return this.#renderError(request, { status: 500, error, clientAddress });
-      }
-    }
-    if (!routeData) {
-      routeData = this.match(request);
-      this.#logger.debug("router", "Astro matched the following route for " + request.url);
-      this.#logger.debug("router", "RouteData:\n" + routeData);
-    }
-    if (!routeData) {
-      this.#logger.debug("router", "Astro hasn't found routes that match " + request.url);
-      this.#logger.debug("router", "Here's the available routes:\n", this.#manifestData);
-      return this.#renderError(request, { locals, status: 404, clientAddress });
-    }
-    const pathname = this.#getPathnameFromRequest(request);
-    const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
-    let response;
-    let session;
-    try {
-      const mod = await this.#pipeline.getModuleForRoute(routeData);
-      const renderContext = await RenderContext.create({
-        pipeline: this.#pipeline,
-        locals,
-        pathname,
-        request,
-        routeData,
-        status: defaultStatus,
-        clientAddress
-      });
-      session = renderContext.session;
-      response = await renderContext.render(await mod.page());
-    } catch (err) {
-      this.#logger.error(null, err.stack || err.message || String(err));
-      return this.#renderError(request, { locals, status: 500, error: err, clientAddress });
-    } finally {
-      await session?.[PERSIST_SYMBOL]();
-    }
-    if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
-      return this.#renderError(request, {
-        locals,
-        response,
-        status: response.status,
-        // We don't have an error to report here. Passing null means we pass nothing intentionally
-        // while undefined means there's no error
-        error: response.status === 500 ? null : void 0,
-        clientAddress
-      });
-    }
-    if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
-      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
-    }
-    if (addCookieHeader) {
-      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
-        response.headers.append("set-cookie", setCookieHeaderValue);
-      }
-    }
-    Reflect.set(response, responseSentSymbol$1, true);
-    return response;
-  }
-  setCookieHeaders(response) {
-    return getSetCookiesFromResponse(response);
-  }
-  /**
-   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
-   * For example,
-   * ```ts
-   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
-   *     const cookie: string = cookie_
-   * }
-   * ```
-   * @param response The response to read cookies from.
-   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
-   */
-  static getSetCookieFromResponse = getSetCookiesFromResponse;
-  /**
-   * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
-   * This also handles pre-rendered /404 or /500 routes
-   */
-  async #renderError(request, {
-    locals,
-    status,
-    response: originalResponse,
-    skipMiddleware = false,
-    error,
-    clientAddress
-  }) {
-    const errorRoutePath = `/${status}${this.#manifest.trailingSlash === "always" ? "/" : ""}`;
-    const errorRouteData = matchRoute(errorRoutePath, this.#manifestData);
-    const url = new URL(request.url);
-    if (errorRouteData) {
-      if (errorRouteData.prerender) {
-        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
-        const statusURL = new URL(
-          `${this.#baseWithoutTrailingSlash}/${status}${maybeDotHtml}`,
-          url
-        );
-        if (statusURL.toString() !== request.url) {
-          const response2 = await fetch(statusURL.toString());
-          const override = { status };
-          return this.#mergeResponses(response2, originalResponse, override);
-        }
-      }
-      const mod = await this.#pipeline.getModuleForRoute(errorRouteData);
-      let session;
-      try {
-        const renderContext = await RenderContext.create({
-          locals,
-          pipeline: this.#pipeline,
-          middleware: skipMiddleware ? NOOP_MIDDLEWARE_FN : void 0,
-          pathname: this.#getPathnameFromRequest(request),
-          request,
-          routeData: errorRouteData,
-          status,
-          props: { error },
-          clientAddress
-        });
-        session = renderContext.session;
-        const response2 = await renderContext.render(await mod.page());
-        return this.#mergeResponses(response2, originalResponse);
-      } catch {
-        if (skipMiddleware === false) {
-          return this.#renderError(request, {
-            locals,
-            status,
-            response: originalResponse,
-            skipMiddleware: true,
-            clientAddress
-          });
-        }
-      } finally {
-        await session?.[PERSIST_SYMBOL]();
-      }
-    }
-    const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
-    Reflect.set(response, responseSentSymbol$1, true);
-    return response;
-  }
-  #mergeResponses(newResponse, originalResponse, override) {
-    if (!originalResponse) {
-      if (override !== void 0) {
-        return new Response(newResponse.body, {
-          status: override.status,
-          statusText: newResponse.statusText,
-          headers: newResponse.headers
-        });
-      }
-      return newResponse;
-    }
-    const status = override?.status ? override.status : originalResponse.status === 200 ? newResponse.status : originalResponse.status;
-    try {
-      originalResponse.headers.delete("Content-type");
-    } catch {
-    }
-    const mergedHeaders = new Map([
-      ...Array.from(newResponse.headers),
-      ...Array.from(originalResponse.headers)
-    ]);
-    const newHeaders = new Headers();
-    for (const [name, value] of mergedHeaders) {
-      newHeaders.set(name, value);
-    }
-    return new Response(newResponse.body, {
-      status,
-      statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
-      // If you're looking at here for possible bugs, it means that it's not a bug.
-      // With the middleware, users can meddle with headers, and we should pass to the 404/500.
-      // If users see something weird, it's because they are setting some headers they should not.
-      //
-      // Although, we don't want it to replace the content-type, because the error page must return `text/html`
-      headers: newHeaders
-    });
-  }
-  #getDefaultStatusCode(routeData, pathname) {
-    if (!routeData.pattern.test(pathname)) {
-      for (const fallbackRoute of routeData.fallbackRoutes) {
-        if (fallbackRoute.pattern.test(pathname)) {
-          return 302;
-        }
-      }
-    }
-    const route = removeTrailingForwardSlash(routeData.route);
-    if (route.endsWith("/404")) return 404;
-    if (route.endsWith("/500")) return 500;
-    return 200;
-  }
-}
-
-const createOutgoingHttpHeaders = (headers) => {
-  if (!headers) {
-    return void 0;
-  }
-  const nodeHeaders = Object.fromEntries(headers.entries());
-  if (Object.keys(nodeHeaders).length === 0) {
-    return void 0;
-  }
-  if (headers.has("set-cookie")) {
-    const cookieHeaders = headers.getSetCookie();
-    if (cookieHeaders.length > 1) {
-      nodeHeaders["set-cookie"] = cookieHeaders;
-    }
-  }
-  return nodeHeaders;
-};
-
-function apply() {
-  if (!globalThis.crypto) {
-    Object.defineProperty(globalThis, "crypto", {
-      value: crypto$1.webcrypto
-    });
-  }
-  if (!globalThis.File) {
-    Object.defineProperty(globalThis, "File", {
-      value: buffer.File
-    });
-  }
-}
-
-class NodeApp extends App {
-  match(req) {
-    if (!(req instanceof Request)) {
-      req = NodeApp.createRequest(req, {
-        skipBody: true
-      });
-    }
-    return super.match(req);
-  }
-  render(req, routeDataOrOptions, maybeLocals) {
-    if (!(req instanceof Request)) {
-      req = NodeApp.createRequest(req);
-    }
-    return super.render(req, routeDataOrOptions, maybeLocals);
-  }
-  /**
-   * Converts a NodeJS IncomingMessage into a web standard Request.
-   * ```js
-   * import { NodeApp } from 'astro/app/node';
-   * import { createServer } from 'node:http';
-   *
-   * const server = createServer(async (req, res) => {
-   *     const request = NodeApp.createRequest(req);
-   *     const response = await app.render(request);
-   *     await NodeApp.writeResponse(response, res);
-   * })
-   * ```
-   */
-  static createRequest(req, { skipBody = false } = {}) {
-    const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
-    const getFirstForwardedValue = (multiValueHeader) => {
-      return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
-    };
-    const forwardedProtocol = getFirstForwardedValue(req.headers["x-forwarded-proto"]);
-    const protocol = forwardedProtocol ?? (isEncrypted ? "https" : "http");
-    const forwardedHostname = getFirstForwardedValue(req.headers["x-forwarded-host"]);
-    const hostname = forwardedHostname ?? req.headers.host ?? req.headers[":authority"];
-    const port = getFirstForwardedValue(req.headers["x-forwarded-port"]);
-    const portInHostname = typeof hostname === "string" && /:\d+$/.test(hostname);
-    const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
-    const url = `${protocol}://${hostnamePort}${req.url}`;
-    const options = {
-      method: req.method || "GET",
-      headers: makeRequestHeaders(req)
-    };
-    const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
-    if (bodyAllowed) {
-      Object.assign(options, makeRequestBody(req));
-    }
-    const request = new Request(url, options);
-    const forwardedClientIp = getFirstForwardedValue(req.headers["x-forwarded-for"]);
-    const clientIp = forwardedClientIp || req.socket?.remoteAddress;
-    if (clientIp) {
-      Reflect.set(request, clientAddressSymbol, clientIp);
-    }
-    return request;
-  }
-  /**
-   * Streams a web-standard Response into a NodeJS Server Response.
-   * ```js
-   * import { NodeApp } from 'astro/app/node';
-   * import { createServer } from 'node:http';
-   *
-   * const server = createServer(async (req, res) => {
-   *     const request = NodeApp.createRequest(req);
-   *     const response = await app.render(request);
-   *     await NodeApp.writeResponse(response, res);
-   * })
-   * ```
-   * @param source WhatWG Response
-   * @param destination NodeJS ServerResponse
-   */
-  static async writeResponse(source, destination) {
-    const { status, headers, body, statusText } = source;
-    if (!(destination instanceof Http2ServerResponse)) {
-      destination.statusMessage = statusText;
-    }
-    destination.writeHead(status, createOutgoingHttpHeaders(headers));
-    if (!body) return destination.end();
-    try {
-      const reader = body.getReader();
-      destination.on("close", () => {
-        reader.cancel().catch((err) => {
-          console.error(
-            `There was an uncaught error in the middle of the stream while rendering ${destination.req.url}.`,
-            err
-          );
-        });
-      });
-      let result = await reader.read();
-      while (!result.done) {
-        destination.write(result.value);
-        result = await reader.read();
-      }
-      destination.end();
-    } catch (err) {
-      destination.write("Internal server error", () => {
-        err instanceof Error ? destination.destroy(err) : destination.destroy();
-      });
-    }
-  }
-}
-function makeRequestHeaders(req) {
-  const headers = new Headers();
-  for (const [name, value] of Object.entries(req.headers)) {
-    if (value === void 0) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(name, item);
-      }
-    } else {
-      headers.append(name, value);
-    }
-  }
-  return headers;
-}
-function makeRequestBody(req) {
-  if (req.body !== void 0) {
-    if (typeof req.body === "string" && req.body.length > 0) {
-      return { body: Buffer.from(req.body) };
-    }
-    if (typeof req.body === "object" && req.body !== null && Object.keys(req.body).length > 0) {
-      return { body: Buffer.from(JSON.stringify(req.body)) };
-    }
-    if (typeof req.body === "object" && req.body !== null && typeof req.body[Symbol.asyncIterator] !== "undefined") {
-      return asyncIterableToBodyProps(req.body);
-    }
-  }
-  return asyncIterableToBodyProps(req);
-}
-function asyncIterableToBodyProps(iterable) {
-  return {
-    // Node uses undici for the Request implementation. Undici accepts
-    // a non-standard async iterable for the body.
-    // @ts-expect-error
-    body: iterable,
-    // The duplex property is required when using a ReadableStream or async
-    // iterable for the body. The type definitions do not include the duplex
-    // property because they are not up-to-date.
-    duplex: "half"
-  };
-}
-
-apply();
-
-function createAppHandler(app) {
-  const als = new AsyncLocalStorage();
-  const logger = app.getAdapterLogger();
-  process.on("unhandledRejection", (reason) => {
-    const requestUrl = als.getStore();
-    logger.error(`Unhandled rejection while rendering ${requestUrl}`);
-    console.error(reason);
-  });
-  return async (req, res, next, locals) => {
-    let request;
-    try {
-      request = NodeApp.createRequest(req);
-    } catch (err) {
-      logger.error(`Could not render ${req.url}`);
-      console.error(err);
-      res.statusCode = 500;
-      res.end("Internal Server Error");
-      return;
-    }
-    const routeData = app.match(request);
-    if (routeData) {
-      const response = await als.run(
-        request.url,
-        () => app.render(request, {
-          addCookieHeader: true,
-          locals,
-          routeData
-        })
-      );
-      await NodeApp.writeResponse(response, res);
-    } else if (next) {
-      return next();
-    } else {
-      const response = await app.render(req);
-      await NodeApp.writeResponse(response, res);
-    }
-  };
-}
-
-function createMiddleware(app) {
-  const handler = createAppHandler(app);
-  const logger = app.getAdapterLogger();
-  return async (...args) => {
-    const [req, res, next, locals] = args;
-    if (req instanceof Error) {
-      const error = req;
-      if (next) {
-        return next(error);
-      } else {
-        throw error;
-      }
-    }
-    try {
-      await handler(req, res, next, locals);
-    } catch (err) {
-      logger.error(`Could not render ${req.url}`);
-      console.error(err);
-      if (!res.headersSent) {
-        res.writeHead(500, `Server error`);
-        res.end();
-      }
-    }
-  };
-}
-
-const wildcardHosts = /* @__PURE__ */ new Set(["0.0.0.0", "::", "0000:0000:0000:0000:0000:0000:0000:0000"]);
-async function logListeningOn(logger, server, configuredHost) {
-  await new Promise((resolve) => server.once("listening", resolve));
-  const protocol = server instanceof https.Server ? "https" : "http";
-  const host = getResolvedHostForHttpServer(configuredHost);
-  const { port } = server.address();
-  const address = getNetworkAddress(protocol, host, port);
-  if (host === void 0 || wildcardHosts.has(host)) {
-    logger.info(
-      `Server listening on 
-  local: ${address.local[0]} 	
-  network: ${address.network[0]}
-`
-    );
-  } else {
-    logger.info(`Server listening on ${address.local[0]}`);
-  }
-}
-function getResolvedHostForHttpServer(host) {
-  if (host === false) {
-    return "localhost";
-  } else if (host === true) {
-    return void 0;
-  } else {
-    return host;
-  }
-}
-function getNetworkAddress(protocol = "http", hostname, port, base) {
-  const NetworkAddress = {
-    local: [],
-    network: []
-  };
-  Object.values(os.networkInterfaces()).flatMap((nInterface) => nInterface ?? []).filter(
-    (detail) => detail && detail.address && (detail.family === "IPv4" || // @ts-expect-error Node 18.0 - 18.3 returns number
-    detail.family === 4)
-  ).forEach((detail) => {
-    let host = detail.address.replace(
-      "127.0.0.1",
-      hostname === void 0 || wildcardHosts.has(hostname) ? "localhost" : hostname
-    );
-    if (host.includes(":")) {
-      host = `[${host}]`;
-    }
-    const url = `${protocol}://${host}:${port}${""}`;
-    if (detail.address.includes("127.0.0.1")) {
-      NetworkAddress.local.push(url);
-    } else {
-      NetworkAddress.network.push(url);
-    }
-  });
-  return NetworkAddress;
-}
-
-const WITH_FILE_EXT = /\/[^/]+\.\w+$/;
-function hasFileExtension(path) {
-  return WITH_FILE_EXT.test(path);
-}
-
-function createStaticHandler(app, options) {
-  const client = resolveClientDir(options);
-  return (req, res, ssr) => {
-    if (req.url) {
-      const [urlPath, urlQuery] = req.url.split("?");
-      const filePath = path.join(client, app.removeBase(urlPath));
-      let isDirectory = false;
-      try {
-        isDirectory = fs.lstatSync(filePath).isDirectory();
-      } catch {
-      }
-      const { trailingSlash = "ignore" } = options;
-      const hasSlash = urlPath.endsWith("/");
-      let pathname = urlPath;
-      switch (trailingSlash) {
-        case "never": {
-          if (isDirectory && urlPath !== "/" && hasSlash) {
-            pathname = urlPath.slice(0, -1) + (urlQuery ? "?" + urlQuery : "");
-            res.statusCode = 301;
-            res.setHeader("Location", pathname);
-            return res.end();
-          }
-          if (isDirectory && !hasSlash) {
-            pathname = `${urlPath}/index.html`;
-          }
-          break;
-        }
-        case "ignore": {
-          if (isDirectory && !hasSlash) {
-            pathname = `${urlPath}/index.html`;
-          }
-          break;
-        }
-        case "always": {
-          if (!hasSlash && !hasFileExtension(urlPath)) {
-            pathname = urlPath + "/" + (urlQuery ? "?" + urlQuery : "");
-            res.statusCode = 301;
-            res.setHeader("Location", pathname);
-            return res.end();
-          }
-          break;
-        }
-      }
-      pathname = prependForwardSlash(app.removeBase(pathname));
-      const stream = send(req, pathname, {
-        root: client,
-        dotfiles: pathname.startsWith("/.well-known/") ? "allow" : "deny"
-      });
-      let forwardError = false;
-      stream.on("error", (err) => {
-        if (forwardError) {
-          console.error(err.toString());
-          res.writeHead(500);
-          res.end("Internal server error");
-          return;
-        }
-        ssr();
-      });
-      stream.on("headers", (_res) => {
-        if (pathname.startsWith(`/${options.assets}/`)) {
-          _res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-        }
-      });
-      stream.on("file", () => {
-        forwardError = true;
-      });
-      stream.pipe(res);
-    } else {
-      ssr();
-    }
-  };
-}
-function resolveClientDir(options) {
-  const clientURLRaw = new URL(options.client);
-  const serverURLRaw = new URL(options.server);
-  const rel = path.relative(url.fileURLToPath(serverURLRaw), url.fileURLToPath(clientURLRaw));
-  const serverFolder = path.basename(options.server);
-  let serverEntryFolderURL = path.dirname(import.meta.url);
-  while (!serverEntryFolderURL.endsWith(serverFolder)) {
-    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
-  }
-  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
-  const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
-  const client = url.fileURLToPath(clientURL);
-  return client;
-}
-function prependForwardSlash(pth) {
-  return pth.startsWith("/") ? pth : "/" + pth;
-}
-function appendForwardSlash(pth) {
-  return pth.endsWith("/") ? pth : pth + "/";
-}
-
-const hostOptions = (host) => {
-  if (typeof host === "boolean") {
-    return host ? "0.0.0.0" : "localhost";
-  }
-  return host;
-};
-function standalone(app, options) {
-  const port = process.env.PORT ? Number(process.env.PORT) : options.port ?? 8080;
-  const host = process.env.HOST ?? hostOptions(options.host);
-  const handler = createStandaloneHandler(app, options);
-  const server = createServer(handler, host, port);
-  server.server.listen(port, host);
-  if (process.env.ASTRO_NODE_LOGGING !== "disabled") {
-    logListeningOn(app.getAdapterLogger(), server.server, host);
-  }
-  return {
-    server,
-    done: server.closed()
-  };
-}
-function createStandaloneHandler(app, options) {
-  const appHandler = createAppHandler(app);
-  const staticHandler = createStaticHandler(app, options);
-  return (req, res) => {
-    try {
-      decodeURI(req.url);
-    } catch {
-      res.writeHead(400);
-      res.end("Bad request.");
-      return;
-    }
-    staticHandler(req, res, () => appHandler(req, res));
-  };
-}
-function createServer(listener, host, port) {
-  let httpServer;
-  if (process.env.SERVER_CERT_PATH && process.env.SERVER_KEY_PATH) {
-    httpServer = https.createServer(
-      {
-        key: fs.readFileSync(process.env.SERVER_KEY_PATH),
-        cert: fs.readFileSync(process.env.SERVER_CERT_PATH)
-      },
-      listener
-    );
-  } else {
-    httpServer = http.createServer(listener);
-  }
-  enableDestroy(httpServer);
-  const closed = new Promise((resolve, reject) => {
-    httpServer.addListener("close", resolve);
-    httpServer.addListener("error", reject);
-  });
-  const previewable = {
-    host,
-    port,
-    closed() {
-      return closed;
-    },
-    async stop() {
-      await new Promise((resolve, reject) => {
-        httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
-  };
-  return {
-    server: httpServer,
-    ...previewable
-  };
-}
-
-function createExports(manifest, options) {
-  const app = new NodeApp(manifest);
-  options.trailingSlash = manifest.trailingSlash;
-  return {
-    options,
-    handler: options.mode === "middleware" ? createMiddleware(app) : createStandaloneHandler(app, options),
-    startServer: () => standalone(app, options)
-  };
-}
-function start(manifest, options) {
-  if (options.mode !== "standalone" || process.env.ASTRO_NODE_AUTOSTART === "disabled") {
-    return;
-  }
-  const app = new NodeApp(manifest);
-  standalone(app, options);
+function defineMiddleware(fn) {
+  return fn;
 }
 
-const serverEntrypointModule = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  createExports,
-  start
-}, Symbol.toStringTag, { value: 'Module' }));
-
-export { start as a, createExports as c, serverEntrypointModule as s };
+export { PERSIST_SYMBOL as P, RouteCache as R, SERVER_ISLAND_COMPONENT as S, redirectToFallback as a, redirectToDefaultLocale as b, requestHasLocale as c, normalizeTheLocale as d, defineMiddleware as e, SERVER_ISLAND_ROUTE as f, createEndpoint as g, findRouteToRewrite as h, isRequestServerIsland as i, RenderContext as j, getSetCookiesFromResponse as k, matchRoute as m, notFound as n, requestIs404Or500 as r, sequence as s };