astro 7.2.2 → 7.2.3

package/dist/core/environment/index.js

@@ -0,0 +1,12 @@
+import { productionEnvironment } from "./production.js";
+const environments = /* @__PURE__ */ new WeakMap();
+function setEnvironment(manifest, env) {
+  environments.set(manifest, env);
+}
+function getEnvironment(manifest) {
+  return environments.get(manifest) ?? productionEnvironment;
+}
+export {
+  getEnvironment,
+  setEnvironment
+};

package/dist/core/environment/production.d.ts

@@ -0,0 +1,6 @@
+import type { RenderEnvironment } from './index.js';
+/**
+ * The production / bundled environment — the default when nothing is
+ * registered. A stateless module constant derived from the manifest alone.
+ */
+export declare const productionEnvironment: RenderEnvironment;

package/dist/core/environment/production.js

@@ -0,0 +1,117 @@
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import {
+  createAssetLink,
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  let routeToProcess = route;
+  if (routeIsRedirect(route)) {
+    if (route.redirectRoute) {
+      routeToProcess = route.redirectRoute;
+    } else {
+      return RedirectSinglePageBuiltModule;
+    }
+  } else if (routeIsFallback(route)) {
+    routeToProcess = getFallbackRoute(route, manifest.routes);
+  }
+  if (manifest.pageMap) {
+    const importComponentInstance = manifest.pageMap.get(routeToProcess.component);
+    if (!importComponentInstance) {
+      throw new Error(`Unexpectedly unable to find a component instance for route ${route.route}`);
+    }
+    return await importComponentInstance();
+  } else if (manifest.pageModule) {
+    return 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."
+  );
+}
+async function getComponentByRoute(manifest, routeData) {
+  const module = await getModuleForRoute(manifest, routeData);
+  return module.page();
+}
+const productionEnvironment = {
+  name: "production",
+  runtimeMode: "production",
+  defaultStreaming: () => true,
+  async resolve(manifest, specifier) {
+    if (!(specifier in manifest.entryModules)) {
+      throw new Error(`Unable to resolve [${specifier}]`);
+    }
+    const bundlePath = manifest.entryModules[specifier];
+    if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
+      return bundlePath;
+    } else {
+      return createAssetLink(bundlePath, manifest.base, manifest.assetsPrefix);
+    }
+  },
+  async headElements(manifest, routeData) {
+    const { assetsPrefix, base } = manifest;
+    const routeInfo = manifest.routes.find((route) => route.routeData.route === routeData.route);
+    const links = /* @__PURE__ */ new Set();
+    const scripts = /* @__PURE__ */ new Set();
+    const styles = createStylesheetElementSet(routeInfo?.styles ?? [], base, assetsPrefix);
+    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, base, assetsPrefix));
+      }
+    }
+    return { links, styles, scripts };
+  },
+  // The manifest's componentMetadata fallback stays in `createResult`.
+  componentMetadata() {
+  },
+  getComponentByRoute,
+  getModuleForRoute,
+  async tryRewrite(manifest, payload, request) {
+    const { newUrl, pathname, routeData } = findRouteToRewrite({
+      payload,
+      request,
+      // RAW manifest routes, NOT the derived route table: production
+      // manifests deliberately do not carry
+      // the default 404 route (`createRoutesList` ensures it in dev only),
+      // and `findRouteToRewrite` gives an existing `/404` list entry
+      // precedence over dynamic routes that also match the path — so the
+      // ensured table would let the synthetic default-404 entry shadow a
+      // catch-all route on an explicit rewrite to `/404`. The no-match
+      // fallback already returns `DEFAULT_404_ROUTE`, so the raw list loses
+      // nothing.
+      routes: manifest.routes.map((r) => r.routeData),
+      trailingSlash: manifest.trailingSlash,
+      buildFormat: manifest.buildFormat,
+      base: manifest.base,
+      outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+    });
+    const componentInstance = await getComponentByRoute(manifest, routeData);
+    return { newUrl, pathname, componentInstance, routeData };
+  },
+  getRenderers(manifest) {
+    return manifest.renderers;
+  },
+  errorStrategy: "default",
+  injectCspMetaTagsOnErrorPages: false,
+  logRequest() {
+  }
+};
+export {
+  productionEnvironment
+};

package/dist/core/errors/build-handler.d.ts

@@ -1,17 +1,12 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 /**
- * The error handler used during static build / prerendering.
+ * The error strategy used during static build / prerendering.
  *
  * - For 500 errors, returns the original response if present, otherwise
  *   throws so the build surfaces the underlying error to the developer.
- * - For other errors (e.g. 404), delegates to `DefaultErrorHandler` with
+ * - For other errors (e.g. 404), delegates to `renderDefaultError` with
  *   `prerenderedErrorPageFetch` cleared (the build pipeline can't fetch
  *   prerendered pages the way production SSR can).
  */
-export declare class BuildErrorHandler implements ErrorHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
-}
+export declare function renderBuildError(manifest: SSRManifest, request: Request, options: RenderErrorOptions): Promise<Response>;

package/dist/core/errors/build-handler.js

@@ -1,22 +1,16 @@
-import { DefaultErrorHandler } from "./default-handler.js";
-class BuildErrorHandler {
-  #default;
-  constructor(app) {
-    this.#default = new DefaultErrorHandler(app);
-  }
-  async renderError(request, options) {
-    if (options.status === 500) {
-      if (options.response) {
-        return options.response;
-      }
-      throw options.error;
+import { renderDefaultError } from "./default-handler.js";
+async function renderBuildError(manifest, request, options) {
+  if (options.status === 500) {
+    if (options.response) {
+      return options.response;
     }
-    return this.#default.renderError(request, {
-      ...options,
-      prerenderedErrorPageFetch: void 0
-    });
+    throw options.error;
   }
+  return renderDefaultError(manifest, request, {
+    ...options,
+    prerenderedErrorPageFetch: void 0
+  });
 }
 export {
-  BuildErrorHandler
+  renderBuildError
 };

package/dist/core/errors/default-handler.d.ts

@@ -1,14 +1,9 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import { type ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 /**
- * The default error handler used in production SSR. Attempts to render the
+ * The default error strategy used in production SSR. Attempts to render the
  * matching error route (404.astro / 500.astro), falling back to a plain
  * response with the given status. Handles prerendered error pages via
  * `prerenderedErrorPageFetch`.
  */
-export declare class DefaultErrorHandler implements ErrorHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
-}
+export declare function renderDefaultError(manifest: SSRManifest, request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;

package/dist/core/errors/default-handler.js

@@ -1,125 +1,110 @@
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { getEnvironment } from "../environment/index.js";
 import { FetchState } from "../fetch/fetch-state.js";
 import { prepareResponse } from "../app/prepare-response.js";
 import { attachCookiesToResponse } from "../cookies/index.js";
 import { getCookiesFromResponse } from "../cookies/response.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
 import { matchRoute } from "../routing/match.js";
+import { getRouteTable } from "../routing/route-table.js";
 import { provideSession } from "../session/provider.js";
 import { validateHost } from "../app/validate-headers.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
 import { getOutputFilename } from "../output-filename.js";
 import { rewroteToEmptyErrorResponse } from "./handler.js";
-class DefaultErrorHandler {
-  #app;
-  #astroMiddleware;
-  #pagesHandler;
-  constructor(app) {
-    this.#app = app;
-    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
-    this.#pagesHandler = new PagesHandler(app.pipeline);
-  }
-  async renderError(request, {
+async function renderDefaultError(manifest, request, {
+  status,
+  response: originalResponse,
+  skipMiddleware = false,
+  error,
+  pathname,
+  ...resolvedRenderOptions
+}) {
+  const resolvedPathname = pathname ?? new FetchState(manifest, request).pathname;
+  const routeTable = getRouteTable(manifest);
+  const errorRoutePath = getErrorRoutePath(
+    resolvedPathname,
     status,
-    response: originalResponse,
-    skipMiddleware = false,
-    error,
-    pathname,
-    ...resolvedRenderOptions
-  }) {
-    const app = this.#app;
-    const resolvedPathname = pathname ?? new FetchState(app.pipeline, request).pathname;
-    const errorRoutePath = getErrorRoutePath(
-      resolvedPathname,
-      status,
-      app.manifestData.routes,
-      app.manifest.i18n?.locales,
-      app.manifest.trailingSlash === "always"
-    );
-    const errorRouteData = matchRoute(errorRoutePath, app.manifestData);
-    const url = new URL(request.url);
-    if (errorRouteData) {
-      if (errorRouteData.prerender) {
-        const allowedDomains = app.manifest.allowedDomains;
-        const validatedHost = validateHost(url.host, url.protocol.replace(":", ""), allowedDomains);
-        const safeOrigin = validatedHost ? url.origin : `${url.protocol}//localhost`;
-        const statusURL = new URL(
-          `${app.baseWithoutTrailingSlash}${getOutputFilename(
-            app.manifest.buildFormat,
-            errorRouteData.route,
-            errorRouteData
-          )}`,
-          safeOrigin
-        );
-        if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
-          try {
-            const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
-              statusURL.toString()
-            );
-            const override = { status, removeContentEncodingHeaders: true };
-            const newResponse = mergeResponses(response2, originalResponse, override);
-            prepareResponse(newResponse, resolvedRenderOptions);
-            return newResponse;
-          } catch {
-            const response2 = mergeResponses(new Response(null, { status }), originalResponse);
-            prepareResponse(response2, resolvedRenderOptions);
-            return response2;
-          }
+    routeTable.routes,
+    manifest.i18n?.locales,
+    manifest.trailingSlash === "always"
+  );
+  const errorRouteData = matchRoute(errorRoutePath, routeTable);
+  const url = new URL(request.url);
+  if (errorRouteData) {
+    if (errorRouteData.prerender) {
+      const allowedDomains = manifest.allowedDomains;
+      const validatedHost = validateHost(url.host, url.protocol.replace(":", ""), allowedDomains);
+      const safeOrigin = validatedHost ? url.origin : `${url.protocol}//localhost`;
+      const statusURL = new URL(
+        `${removeTrailingForwardSlash(manifest.base)}${getOutputFilename(
+          manifest.buildFormat,
+          errorRouteData.route,
+          errorRouteData
+        )}`,
+        safeOrigin
+      );
+      if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
+        try {
+          const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
+            statusURL.toString()
+          );
+          const override = { status, removeContentEncodingHeaders: true };
+          const newResponse = mergeResponses(response2, originalResponse, override);
+          prepareResponse(newResponse, resolvedRenderOptions);
+          return newResponse;
+        } catch {
+          const response2 = mergeResponses(new Response(null, { status }), originalResponse);
+          prepareResponse(response2, resolvedRenderOptions);
+          return response2;
         }
       }
-      const mod = await app.pipeline.getComponentByRoute(errorRouteData);
-      const errorState = new FetchState(app.pipeline, request);
-      errorState.skipMiddleware = skipMiddleware;
-      errorState.clientAddress = resolvedRenderOptions.clientAddress;
-      errorState.routeData = errorRouteData;
-      errorState.pathname = resolvedPathname;
-      errorState.status = status;
-      errorState.componentInstance = mod;
-      errorState.locals = resolvedRenderOptions.locals ?? {};
-      errorState.initialProps = { error };
-      try {
-        await provideSession(errorState);
-        const response2 = await this.#astroMiddleware.handle(
-          errorState,
-          this.#pagesHandler.handle.bind(this.#pagesHandler)
-        );
-        if (rewroteToEmptyErrorResponse(
-          skipMiddleware,
-          errorRouteData,
-          errorState.routeData,
-          response2
-        )) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status,
-            error,
-            response: originalResponse,
-            skipMiddleware: true,
-            pathname: resolvedPathname
-          });
-        }
-        const newResponse = mergeResponses(response2, originalResponse);
-        prepareResponse(newResponse, resolvedRenderOptions);
-        return newResponse;
-      } catch {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status,
-            error,
-            response: originalResponse,
-            skipMiddleware: true,
-            pathname: resolvedPathname
-          });
-        }
-      } finally {
-        await errorState.finalizeAll();
+    }
+    const mod = await getEnvironment(manifest).getComponentByRoute(manifest, errorRouteData);
+    const errorState = new FetchState(manifest, request);
+    errorState.skipMiddleware = skipMiddleware;
+    errorState.clientAddress = resolvedRenderOptions.clientAddress;
+    errorState.routeData = errorRouteData;
+    errorState.pathname = resolvedPathname;
+    errorState.status = status;
+    errorState.componentInstance = mod;
+    errorState.locals = resolvedRenderOptions.locals ?? {};
+    errorState.initialProps = { error };
+    try {
+      await provideSession(errorState);
+      const response2 = await handleMiddleware(errorState, handlePages);
+      if (rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, errorState.routeData, response2)) {
+        return renderDefaultError(manifest, request, {
+          ...resolvedRenderOptions,
+          status,
+          error,
+          response: originalResponse,
+          skipMiddleware: true,
+          pathname: resolvedPathname
+        });
+      }
+      const newResponse = mergeResponses(response2, originalResponse);
+      prepareResponse(newResponse, resolvedRenderOptions);
+      return newResponse;
+    } catch {
+      if (skipMiddleware === false) {
+        return renderDefaultError(manifest, request, {
+          ...resolvedRenderOptions,
+          status,
+          error,
+          response: originalResponse,
+          skipMiddleware: true,
+          pathname: resolvedPathname
+        });
       }
+    } finally {
+      await errorState.finalizeAll();
     }
-    const response = mergeResponses(new Response(null, { status }), originalResponse);
-    prepareResponse(response, resolvedRenderOptions);
-    return response;
   }
+  const response = mergeResponses(new Response(null, { status }), originalResponse);
+  prepareResponse(response, resolvedRenderOptions);
+  return response;
 }
 function mergeResponses(newResponse, originalResponse, override) {
   let newResponseHeaders = newResponse.headers;
@@ -180,5 +165,5 @@ function mergeResponses(newResponse, originalResponse, override) {
   return mergedResponse;
 }
 export {
-  DefaultErrorHandler
+  renderDefaultError
 };

package/dist/core/errors/dev-handler.d.ts

@@ -1,6 +1,5 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import { type ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 export interface DevErrorHandlerOptions {
     /**
      * Whether to inject CSP meta tags into the rendered error page response.
@@ -9,13 +8,10 @@ export interface DevErrorHandlerOptions {
     shouldInjectCspMetaTags: boolean;
 }
 /**
- * The dev-server error handler. Renders custom 404/500 routes if the user
+ * The dev-server error strategy. Renders custom 404/500 routes if the user
  * has them, otherwise throws so Vite's dev overlay is shown. Shared between
- * the Vite dev server (`AstroServerApp`) and the non-runnable dev pipeline
- * (`DevApp`); only `shouldInjectCspMetaTags` differs between them.
+ * the Vite dev server and the non-runnable dev pipeline; only
+ * `shouldInjectCspMetaTags` differs between them (carried by the
+ * environment record's `injectCspMetaTagsOnErrorPages` static).
  */
-export declare class DevErrorHandler implements ErrorHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>, options: DevErrorHandlerOptions);
-    renderError(request: Request, { skipMiddleware, error, status, response: _response, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
-}
+export declare function renderDevError(manifest: SSRManifest, request: Request, { skipMiddleware, error, status, response: _response, pathname, ...resolvedRenderOptions }: RenderErrorOptions, { shouldInjectCspMetaTags }: DevErrorHandlerOptions): Promise<Response>;

package/dist/core/errors/dev-handler.js

@@ -1,92 +1,94 @@
+import { getEnvironment } from "../environment/index.js";
 import { FetchState } from "../fetch/fetch-state.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
 import { getCustom404Route, getCustom500Route } from "../routing/helpers.js";
+import { getRouteTable } from "../routing/route-table.js";
 import { isAstroError } from "./index.js";
 import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "./errors-data.js";
 import { rewroteToEmptyErrorResponse } from "./handler.js";
-class DevErrorHandler {
-  #app;
-  #shouldInjectCspMetaTags;
-  #astroMiddleware;
-  #pagesHandler;
-  constructor(app, options) {
-    this.#app = app;
-    this.#shouldInjectCspMetaTags = options.shouldInjectCspMetaTags;
-    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
-    this.#pagesHandler = new PagesHandler(app.pipeline);
+async function renderDevError(manifest, request, {
+  skipMiddleware = false,
+  error,
+  status,
+  response: _response,
+  pathname,
+  ...resolvedRenderOptions
+}, { shouldInjectCspMetaTags }) {
+  if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+    throw error;
   }
-  async renderError(request, {
-    skipMiddleware = false,
-    error,
-    status,
-    response: _response,
-    pathname,
-    ...resolvedRenderOptions
-  }) {
-    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
-      throw error;
-    }
-    const app = this.#app;
-    const shouldInjectCspMetaTags = this.#shouldInjectCspMetaTags;
-    const resolvedPathname = pathname ?? new FetchState(app.pipeline, request).pathname;
-    const renderRoute = async (routeData) => {
-      try {
-        const preloadedComponent = await app.pipeline.getComponentByRoute(routeData);
-        const errorState = new FetchState(app.pipeline, request);
-        errorState.skipMiddleware = skipMiddleware;
-        errorState.clientAddress = resolvedRenderOptions.clientAddress;
-        errorState.shouldInjectCspMetaTags = shouldInjectCspMetaTags ? !!app.manifest.csp : false;
-        errorState.routeData = routeData;
-        errorState.pathname = resolvedPathname;
-        errorState.status = status;
-        errorState.componentInstance = preloadedComponent;
-        errorState.locals = resolvedRenderOptions.locals ?? {};
-        errorState.initialProps = { error };
-        const response = await this.#astroMiddleware.handle(
-          errorState,
-          this.#pagesHandler.handle.bind(this.#pagesHandler)
-        );
-        if (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
-          return this.renderError(request, {
+  const resolvedPathname = pathname ?? new FetchState(manifest, request).pathname;
+  const renderRoute = async (routeData) => {
+    try {
+      const preloadedComponent = await getEnvironment(manifest).getComponentByRoute(
+        manifest,
+        routeData
+      );
+      const errorState = new FetchState(manifest, request);
+      errorState.skipMiddleware = skipMiddleware;
+      errorState.clientAddress = resolvedRenderOptions.clientAddress;
+      errorState.shouldInjectCspMetaTags = shouldInjectCspMetaTags ? !!manifest.csp : false;
+      errorState.routeData = routeData;
+      errorState.pathname = resolvedPathname;
+      errorState.status = status;
+      errorState.componentInstance = preloadedComponent;
+      errorState.locals = resolvedRenderOptions.locals ?? {};
+      errorState.initialProps = { error };
+      const response = await handleMiddleware(errorState, handlePages);
+      if (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
+        return renderDevError(
+          manifest,
+          request,
+          {
             ...resolvedRenderOptions,
             status,
             error,
             skipMiddleware: true,
             pathname: resolvedPathname
-          });
-        }
-        if (error) {
-          app.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
+          },
+          { shouldInjectCspMetaTags }
+        );
+      }
+      if (error) {
+        getLogger(manifest).error(
+          "router",
+          error.stack || error.message
+        );
+      }
+      return response;
+    } catch (_err) {
+      if (skipMiddleware === false) {
+        return renderDevError(
+          manifest,
+          request,
+          {
             ...resolvedRenderOptions,
             status: 500,
             skipMiddleware: true,
             error: _err,
             pathname: resolvedPathname
-          });
-        }
-        throw _err;
-      }
-    };
-    if (status === 404) {
-      const custom404 = getCustom404Route(app.manifestData);
-      if (custom404) {
-        return renderRoute(custom404);
+          },
+          { shouldInjectCspMetaTags }
+        );
       }
+      throw _err;
     }
-    const custom500 = getCustom500Route(app.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
+  };
+  if (status === 404) {
+    const custom404 = getCustom404Route(getRouteTable(manifest));
+    if (custom404) {
+      return renderRoute(custom404);
     }
   }
+  const custom500 = getCustom500Route(getRouteTable(manifest));
+  if (!custom500) {
+    throw error;
+  } else {
+    return renderRoute(custom500);
+  }
 }
 export {
-  DevErrorHandler
+  renderDevError
 };