astro 7.2.2 → 7.2.4

package/dist/core/rewrites/handler.d.ts

@@ -18,8 +18,8 @@ interface TryRewriteResult {
  * - Invalidates cached API contexts so they're re-derived from the
  *   new route.
  *
- * Called by both `Rewrites.execute()` (user-triggered `Astro.rewrite`)
- * and `AstroMiddleware` (middleware `next(payload)`).
+ * Called by both `executeRewrite()` (user-triggered `Astro.rewrite`)
+ * and `handleMiddleware` (middleware `next(payload)`).
  */
 export declare function applyRewriteToState(state: FetchState, payload: RewritePayload, { routeData, componentInstance, newUrl, pathname }: TryRewriteResult, { mergeCookies }?: {
     mergeCookies?: boolean;
@@ -27,11 +27,9 @@ export declare function applyRewriteToState(state: FetchState, payload: RewriteP
 /**
  * Executes a user-triggered rewrite (`Astro.rewrite(...)` /
  * `ctx.rewrite(...)`) against a `FetchState`. Resolves the rewrite
- * target via `pipeline.tryRewrite`, validates it, mutates the
+ * target via the environment's `tryRewrite`, validates it, mutates the
  * `FetchState` to reflect the new route, and re-runs the middleware
  * and page dispatch to produce the new response.
  */
-export declare class Rewrites {
-    execute(state: FetchState, payload: RewritePayload): Promise<Response>;
-}
+export declare function executeRewrite(state: FetchState, payload: RewritePayload): Promise<Response>;
 export {};

package/dist/core/rewrites/handler.js

@@ -1,16 +1,16 @@
 import { AstroCookies } from "../cookies/index.js";
+import { getEnvironment } from "../environment/index.js";
 import { ForbiddenRewrite } from "../errors/errors-data.js";
 import { AstroError } from "../errors/errors.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
-import { getParams } from "../render/index.js";
+import { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
+import { getParams } from "../render/params-and-props.js";
 import { copyRequest, setOriginPathname } from "../routing/rewrite.js";
 import { createNormalizedUrl } from "../util/normalized-url.js";
 function applyRewriteToState(state, payload, { routeData, componentInstance, newUrl, pathname }, { mergeCookies = false } = {}) {
-  const pipeline = state.pipeline;
   const oldPathname = state.pathname;
   const isI18nFallback = routeData.fallbackRoutes && routeData.fallbackRoutes.length > 0;
-  if (pipeline.manifest.serverLike && !state.routeData.prerender && routeData.prerender && !isI18nFallback) {
+  if (state.manifest.serverLike && !state.routeData.prerender && routeData.prerender && !isI18nFallback) {
     throw new AstroError({
       ...ForbiddenRewrite,
       message: ForbiddenRewrite.message(state.pathname, pathname, routeData.component),
@@ -26,7 +26,7 @@ function applyRewriteToState(state, payload, { routeData, componentInstance, new
       newUrl,
       state.request,
       routeData.prerender,
-      pipeline.logger,
+      state.logger,
       state.routeData.route
     );
   }
@@ -45,23 +45,22 @@ function applyRewriteToState(state, payload, { routeData, componentInstance, new
   setOriginPathname(
     state.request,
     oldPathname,
-    pipeline.manifest.trailingSlash,
-    pipeline.manifest.buildFormat
+    state.manifest.trailingSlash,
+    state.manifest.buildFormat
   );
   state.invalidateContexts();
 }
-class Rewrites {
-  async execute(state, payload) {
-    const pipeline = state.pipeline;
-    pipeline.logger.debug("router", "Calling rewrite: ", payload);
-    const result = await pipeline.tryRewrite(payload, state.request);
-    applyRewriteToState(state, payload, result, { mergeCookies: true });
-    const middleware = new AstroMiddleware(pipeline);
-    const pagesHandler = new PagesHandler(pipeline);
-    return middleware.handle(state, pagesHandler.handle.bind(pagesHandler));
-  }
+async function executeRewrite(state, payload) {
+  state.logger.debug("router", "Calling rewrite: ", payload);
+  const result = await getEnvironment(state.manifest).tryRewrite(
+    state.manifest,
+    payload,
+    state.request
+  );
+  applyRewriteToState(state, payload, result, { mergeCookies: true });
+  return handleMiddleware(state, handlePages);
 }
 export {
-  Rewrites,
-  applyRewriteToState
+  applyRewriteToState,
+  executeRewrite
 };

package/dist/core/routing/default.d.ts

@@ -8,3 +8,5 @@ export interface DefaultRouteParams {
 }
 export declare const DEFAULT_COMPONENTS: string[];
 export declare function createDefaultRoutes(manifest: SSRManifest): DefaultRouteParams[];
+/** The built-in internal routes for a manifest, derived once per manifest. */
+export declare function getDefaultRoutes(manifest: SSRManifest): DefaultRouteParams[];

package/dist/core/routing/default.js

@@ -1,4 +1,5 @@
 import { DEFAULT_404_COMPONENT } from "../constants.js";
+import { createManifestMemo } from "../manifest/memo.js";
 import {
   createEndpoint as createServerIslandEndpoint,
   SERVER_ISLAND_COMPONENT,
@@ -23,7 +24,12 @@ function createDefaultRoutes(manifest) {
     }
   ];
 }
+const defaultRoutesMemo = createManifestMemo(createDefaultRoutes);
+function getDefaultRoutes(manifest) {
+  return defaultRoutesMemo.get(manifest);
+}
 export {
   DEFAULT_COMPONENTS,
-  createDefaultRoutes
+  createDefaultRoutes,
+  getDefaultRoutes
 };

package/dist/core/routing/dev.d.ts

@@ -1,16 +1,14 @@
 /**
  * Use this module only to have functions needed in development
  */
-import type { RoutesList } from '../../types/astro.js';
 import type { SSRManifest } from '../app/types.js';
 import type { RouteData } from '../../types/public/index.js';
-import type { RunnablePipeline } from '../../vite-plugin-app/pipeline.js';
 interface MatchedRoute {
     route: RouteData;
     filePath: URL;
     resolvedPathname: string;
 }
-export declare function matchRoute(pathname: string, routesList: RoutesList, pipeline: RunnablePipeline, manifest: SSRManifest, { prerenderOnly }?: {
+export declare function matchRoute(manifest: SSRManifest, pathname: string, { prerenderOnly }?: {
     prerenderOnly?: boolean;
 }): Promise<MatchedRoute | undefined>;
 export {};

package/dist/core/routing/dev.js

@@ -4,9 +4,16 @@ import { getProps } from "../render/index.js";
 import { getCustom404Route } from "./helpers.js";
 import { NoMatchingStaticPathFound } from "../errors/errors-data.js";
 import { isAstroError } from "../errors/errors.js";
+import { getEnvironment } from "../environment/index.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { getRouteCache } from "../render/route-cache.js";
+import { getRouteTable } from "./route-table.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
-async function matchRoute(pathname, routesList, pipeline, manifest, { prerenderOnly } = {}) {
-  const { logger, routeCache } = pipeline;
+async function matchRoute(manifest, pathname, { prerenderOnly } = {}) {
+  const logger = getLogger(manifest);
+  const routeCache = getRouteCache(manifest);
+  const env = getEnvironment(manifest);
+  const routesList = getRouteTable(manifest);
   const matches = matchAllRoutes(pathname, routesList);
   const preloadedMatches = getSortedPreloadedMatches({
     matches,
@@ -21,12 +28,12 @@ async function matchRoute(pathname, routesList, pipeline, manifest, { prerenderO
     }
     try {
       await getProps({
-        mod: await pipeline.getComponentByRoute(maybeRoute),
+        mod: await env.getComponentByRoute(manifest, maybeRoute),
         routeData: maybeRoute,
         routeCache,
         pathname,
         logger,
-        serverLike: pipeline.manifest.serverLike,
+        serverLike: manifest.serverLike,
         base: manifest.base,
         trailingSlash: manifest.trailingSlash
       });
@@ -48,7 +55,7 @@ async function matchRoute(pathname, routesList, pipeline, manifest, { prerenderO
   }
   const altPathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
   if (altPathname !== pathname) {
-    return await matchRoute(altPathname, routesList, pipeline, manifest, { prerenderOnly });
+    return await matchRoute(manifest, altPathname, { prerenderOnly });
   }
   if (skippedPrerenderOnly) {
     return void 0;

package/dist/core/routing/handler.d.ts

@@ -1,17 +1,7 @@
 import type { FetchState } from '../fetch/fetch-state.js';
-import type { BaseApp } from '../app/base.js';
-import { type Pipeline } from '../base-pipeline.js';
-export declare class AstroHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    handle(state: FetchState): Promise<Response>;
-    /**
-     * Renders a response for the given `FetchState`. Assumes
-     * trailing-slash redirects and routeData resolution have already run.
-     *
-     * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
-     * `Rewrites.execute` on the current `FetchState` — they mutate the
-     * existing state in place and re-run middleware + page dispatch.
-     */
-    render(state: FetchState): Promise<Response>;
-}
+/**
+ * The composite "batteries-included" handler that wires up every request
+ * feature internally; `astro(state)` (astro/fetch) delegates here, as does
+ * `BaseApp.render`'s default-handler fast path.
+ */
+export declare function handleRequest(state: FetchState): Promise<Response>;

package/dist/core/routing/handler.js

@@ -1,183 +1,145 @@
-import { ActionHandler } from "../../actions/handler.js";
+import { handleAction } from "../../actions/handler.js";
 import { REROUTABLE_STATUS_CODES } from "../constants.js";
-import { TrailingSlashHandler } from "./trailing-slash-handler.js";
-import { CacheHandler, provideCache } from "../cache/handler.js";
-import { I18n } from "../i18n/handler.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { handleTrailingSlash } from "./trailing-slash-handler.js";
+import { handleCache, provideCache } from "../cache/handler.js";
+import { getEnvironment } from "../environment/index.js";
+import { renderErrorFromState } from "../errors/handler.js";
+import { ALL_FETCH_FEATURES, markFeatureUsed, FetchFeatures } from "../fetch/features.js";
+import { finalizeI18n, getI18n } from "../i18n/handler.js";
+import { getResolvedLogger } from "../logger/manifest-logger.js";
+import { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
 import { provideSession } from "../session/provider.js";
 import { prepareResponse } from "../app/prepare-response.js";
-import { ALL_PIPELINE_FEATURES, PipelineFeatures } from "../base-pipeline.js";
-class AstroHandler {
-  #app;
-  #trailingSlashHandler;
-  #actionHandler;
-  #astroMiddleware;
-  #pagesHandler;
-  #cacheHandler;
-  /** Bound callback for the middleware chain — created once, reused per request. */
-  #renderRouteCallback;
-  /**
-   * i18n post-processor. Only set when the app has i18n configured and
-   * the strategy is not `manual` — for the manual strategy users wire
-   * `astro:i18n.middleware(...)` into their own `onRequest`.
-   */
-  #i18n;
-  /** Whether sessions are configured on the manifest. */
-  #hasSession;
-  constructor(app) {
-    this.#app = app;
-    this.#trailingSlashHandler = new TrailingSlashHandler(app);
-    this.#actionHandler = new ActionHandler();
-    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
-    this.#pagesHandler = new PagesHandler(app.pipeline);
-    this.#cacheHandler = new CacheHandler(app);
-    this.#renderRouteCallback = this.#actionsAndPages.bind(this);
-    this.#hasSession = !!app.manifest.sessionConfig;
-    const i18n = app.manifest.i18n;
-    if (i18n && i18n.strategy !== "manual") {
-      this.#i18n = new I18n(
-        i18n,
-        app.manifest.base,
-        app.manifest.trailingSlash,
-        app.manifest.buildFormat
-      );
-    }
+import { getDefaultStatusCode } from "./helpers.js";
+function logRequestFromState(state, payload) {
+  if (state.logRequest) {
+    state.logRequest(payload);
+  } else {
+    getEnvironment(state.manifest).logRequest(state.manifest, payload);
   }
-  /**
-   * Runs actions then pages — the callback at the bottom of the
-   * middleware chain. Bound once in the constructor to avoid
-   * per-request closure allocation.
-   */
-  #actionsAndPages(state, ctx) {
-    if (!state.skipMiddleware) {
-      const actionResult = this.#actionHandler.handle(ctx, state);
-      if (actionResult) {
-        return actionResult.then((response) => response ?? this.#pagesHandler.handle(state, ctx));
-      }
+}
+function actionsAndPages(state, ctx) {
+  if (!state.skipMiddleware) {
+    const actionResult = handleAction(ctx, state);
+    if (actionResult) {
+      return actionResult.then((response) => response ?? handlePages(state, ctx));
     }
-    return this.#pagesHandler.handle(state, ctx);
   }
-  async handle(state) {
-    state.pipeline.usedFeatures |= ALL_PIPELINE_FEATURES;
-    if (state.invalidEncoding) {
-      return new Response(null, { status: 400, statusText: "Bad Request" });
-    }
-    const trailingSlashRedirect = this.#trailingSlashHandler.handle(state);
-    if (trailingSlashRedirect) {
-      return trailingSlashRedirect;
-    }
-    if (!state.routeData) {
-      return this.#app.renderError(state.request, {
-        ...state.renderOptions,
-        status: 404,
-        pathname: state.pathname
-      });
-    }
-    return this.render(state);
+  return handlePages(state, ctx);
+}
+async function handleRequest(state) {
+  await getResolvedLogger(state.manifest);
+  markFeatureUsed(state.manifest, ALL_FETCH_FEATURES);
+  if (state.invalidEncoding) {
+    return new Response(null, { status: 400, statusText: "Bad Request" });
   }
-  /**
-   * Renders a response for the given `FetchState`. Assumes
-   * trailing-slash redirects and routeData resolution have already run.
-   *
-   * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
-   * `Rewrites.execute` on the current `FetchState` — they mutate the
-   * existing state in place and re-run middleware + page dispatch.
-   */
-  async render(state) {
-    const routeData = state.routeData;
-    const pathname = state.pathname;
-    const request = state.request;
-    const { addCookieHeader } = state.renderOptions;
-    const defaultStatus = this.#app.getDefaultStatusCode(routeData, pathname);
-    state.status = defaultStatus;
-    let response;
-    let finalizeError;
-    try {
-      const sessionP = this.#hasSession ? provideSession(state) : void 0;
-      const cacheP = provideCache(state);
-      if (sessionP || cacheP) await Promise.all([sessionP, cacheP]);
-      state.pipeline.usedFeatures |= PipelineFeatures.sessions;
-      if (routeData.type === "redirect") {
-        const redirectResponse = await renderRedirect(state);
-        this.#app.logThisRequest({
-          pathname,
-          method: request.method,
-          statusCode: redirectResponse.status,
-          isRewrite: false,
-          timeStart: state.timeStart
-        });
-        prepareResponse(redirectResponse, { addCookieHeader });
-        this.#app.pipeline.logger.flush();
-        return redirectResponse;
-      }
-      if (!this.#app.pipeline.cacheProvider) {
-        this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
-        response = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
-        if (this.#i18n) {
-          response = await this.#i18n.finalize(state, response);
-        }
-      } else {
-        const runPipeline = async () => {
-          let res = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
-          if (this.#i18n) {
-            res = await this.#i18n.finalize(state, res);
-          }
-          return res;
-        };
-        response = await this.#cacheHandler.handle(state, runPipeline);
-      }
-      this.#app.logThisRequest({
+  const trailingSlashRedirect = handleTrailingSlash(state);
+  if (trailingSlashRedirect) {
+    return trailingSlashRedirect;
+  }
+  if (!state.routeData) {
+    return renderErrorFromState(state, state.request, {
+      ...state.renderOptions,
+      status: 404,
+      pathname: state.pathname
+    });
+  }
+  return render(state);
+}
+async function render(state) {
+  const routeData = state.routeData;
+  const pathname = state.pathname;
+  const request = state.request;
+  const { addCookieHeader } = state.renderOptions;
+  state.status = getDefaultStatusCode(state.manifest, routeData, pathname);
+  let response;
+  let finalizeError;
+  try {
+    const sessionP = state.manifest.sessionConfig ? provideSession(state) : void 0;
+    const cacheP = provideCache(state);
+    if (sessionP || cacheP) await Promise.all([sessionP, cacheP]);
+    markFeatureUsed(state.manifest, FetchFeatures.sessions);
+    if (routeData.type === "redirect") {
+      const redirectResponse = await renderRedirect(state);
+      logRequestFromState(state, {
         pathname,
         method: request.method,
-        statusCode: response.status,
-        isRewrite: state.isRewriting,
+        statusCode: redirectResponse.status,
+        isRewrite: false,
         timeStart: state.timeStart
       });
-    } catch (err) {
-      this.#app.logger.error(null, err.stack || err.message || String(err));
-      return this.#app.renderError(request, {
-        ...state.renderOptions,
-        status: 500,
-        error: err,
-        pathname: state.pathname
-      });
-    } finally {
-      try {
-        const finalize = state.finalizeAll();
-        if (finalize) await finalize;
-      } catch (err) {
-        finalizeError = err;
-        this.#app.logger.error(null, err.stack || err.message || String(err));
-      }
+      prepareResponse(redirectResponse, { addCookieHeader });
+      state.logger.flush();
+      return redirectResponse;
     }
-    if (finalizeError) {
-      return this.#app.renderError(request, {
-        ...state.renderOptions,
-        status: 500,
-        error: finalizeError,
-        pathname: state.pathname
-      });
+    const i18n = getI18n(state.manifest);
+    if (!state.manifest.cacheProvider) {
+      markFeatureUsed(state.manifest, FetchFeatures.cache);
+      response = await handleMiddleware(state, actionsAndPages);
+      if (i18n) {
+        response = await finalizeI18n(i18n, state, response);
+      }
+    } else {
+      const runPipeline = async () => {
+        let res = await handleMiddleware(state, actionsAndPages);
+        if (i18n) {
+          res = await finalizeI18n(i18n, state, res);
+        }
+        return res;
+      };
+      response = await handleCache(state, runPipeline);
     }
-    if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
-    // but uses the current route to handle the 404
-    response.body === null && !state.skipErrorReroute) {
-      return this.#app.renderError(request, {
-        ...state.renderOptions,
-        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,
-        pathname: state.pathname
-      });
+    logRequestFromState(state, {
+      pathname,
+      method: request.method,
+      statusCode: response.status,
+      isRewrite: state.isRewriting,
+      timeStart: state.timeStart
+    });
+  } catch (err) {
+    state.logger.error(null, err.stack || err.message || String(err));
+    return renderErrorFromState(state, request, {
+      ...state.renderOptions,
+      status: 500,
+      error: err,
+      pathname: state.pathname
+    });
+  } finally {
+    try {
+      const finalize = state.finalizeAll();
+      if (finalize) await finalize;
+    } catch (err) {
+      finalizeError = err;
+      state.logger.error(null, err.stack || err.message || String(err));
     }
-    prepareResponse(response, { addCookieHeader });
-    this.#app.pipeline.logger.flush();
-    return response;
   }
+  if (finalizeError) {
+    return renderErrorFromState(state, request, {
+      ...state.renderOptions,
+      status: 500,
+      error: finalizeError,
+      pathname: state.pathname
+    });
+  }
+  if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
+  // but uses the current route to handle the 404
+  response.body === null && !state.skipErrorReroute) {
+    return renderErrorFromState(state, request, {
+      ...state.renderOptions,
+      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,
+      pathname: state.pathname
+    });
+  }
+  prepareResponse(response, { addCookieHeader });
+  state.logger.flush();
+  return response;
 }
 export {
-  AstroHandler
+  handleRequest
 };

package/dist/core/routing/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { RouteData } from '../../types/public/internal.js';
 import type { IntegrationResolvedRoute } from '../../types/public/integrations.js';
-import type { RouteInfo } from '../app/types.js';
+import type { RouteInfo, SSRManifest } from '../app/types.js';
 import type { RoutesList } from '../../types/astro.js';
 type RedirectRouteData = RouteData & {
     redirect: string;
@@ -32,6 +32,12 @@ export declare function getCustom404Route(manifestData: RoutesList): RouteData |
  * Return a user-provided 500 route if one exists.
  */
 export declare function getCustom500Route(manifestData: RoutesList): RouteData | undefined;
+/**
+ * Computes the default HTTP status code a route renders with:
+ * `302` for i18n fallback matches, `404`/`500` for (possibly localized)
+ * error routes, `200` otherwise.
+ */
+export declare function getDefaultStatusCode(manifest: SSRManifest, routeData: RouteData, pathname: string): number;
 /**
  * Returns true if the route definition contains `.html` as a static segment part,
  * as is the case for routes like `[slug].html.astro`. Used to avoid stripping the

package/dist/core/routing/helpers.js

@@ -1,3 +1,5 @@
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { isLocalizedErrorRoute } from "../../i18n/error-routes.js";
 import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function routeIsRedirect(route) {
   return route?.type === "redirect";
@@ -25,6 +27,24 @@ function getCustom404Route(manifestData) {
 function getCustom500Route(manifestData) {
   return manifestData.routes.find((r) => isRoute500(r.route));
 }
+function getDefaultStatusCode(manifest, 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);
+  const locales = manifest.i18n?.locales;
+  if (isRoute404(route) || isLocalizedErrorRoute(route, 404, locales)) {
+    return 404;
+  }
+  if (isRoute500(route) || isLocalizedErrorRoute(route, 500, locales)) {
+    return 500;
+  }
+  return 200;
+}
 function routeHasHtmlExtension(route) {
   return route.segments.some(
     (segment) => segment.some((part) => !part.dynamic && part.content.includes(".html"))
@@ -43,6 +63,7 @@ function hasNonPrerenderedRoute(routes, options) {
 export {
   getCustom404Route,
   getCustom500Route,
+  getDefaultStatusCode,
   getFallbackRoute,
   hasNonPrerenderedRoute,
   routeHasHtmlExtension,

package/dist/core/routing/match-request.d.ts

@@ -0,0 +1,10 @@
+import type { RouteData } from '../../types/public/internal.js';
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Given a `Request`, returns the `RouteData` that matches its pathname — the
+ * appless, purely functional body of `BaseApp.match()`. By default, prerendered
+ * routes aren't returned, even if they are matched; when
+ * `allowPrerenderedRoutes` is `true`, matched prerendered routes are returned
+ * too.
+ */
+export declare function matchRequest(manifest: SSRManifest, request: Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;

package/dist/core/routing/match-request.js

@@ -0,0 +1,46 @@
+import { prependForwardSlash, stripRequestBase } from "@astrojs/internal-helpers/path";
+import { computePathnameFromDomain } from "../i18n/domain.js";
+import { AstroIntegrationLogger } from "../logger/core.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { matchAllRoutes, matchRoute } from "./route-table.js";
+function safeDecodeURI(manifest, pathname) {
+  try {
+    return decodeURI(pathname);
+  } catch (e) {
+    new AstroIntegrationLogger(getLogger(manifest).options, manifest.adapterName).debug(
+      e.toString()
+    );
+    return pathname;
+  }
+}
+function matchRequest(manifest, request, allowPrerenderedRoutes = false) {
+  const url = new URL(request.url);
+  if (manifest.assets.has(url.pathname)) return void 0;
+  let pathname = computePathnameFromDomain(
+    request,
+    url,
+    manifest.i18n,
+    manifest.base,
+    manifest.trailingSlash,
+    getLogger(manifest)
+  );
+  if (!pathname) {
+    pathname = prependForwardSlash(stripRequestBase(url.pathname, manifest.base));
+  }
+  const routeData = matchRoute(manifest, safeDecodeURI(manifest, pathname));
+  if (!routeData) return void 0;
+  if (allowPrerenderedRoutes) {
+    return routeData;
+  }
+  if (routeData.prerender) {
+    if (routeData.params.length > 0) {
+      const allMatches = matchAllRoutes(manifest, safeDecodeURI(manifest, pathname));
+      return allMatches.find((r) => !r.prerender);
+    }
+    return void 0;
+  }
+  return routeData;
+}
+export {
+  matchRequest
+};