Initial commit: New MoreminiMore website with fresh design

node_modules/astro/dist/vite-plugin-app/app.d.ts

@@ -0,0 +1,49 @@
+import type http from 'node:http';
+import { BaseApp, type RenderErrorOptions } from '../core/app/entrypoints/index.js';
+import type { AstroLogger } from '../core/logger/core.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { CreateRenderContext, RenderContext } from '../core/render-context.js';
+import type { AstroSettings, RoutesList } from '../types/astro.js';
+import type { RouteData, SSRManifest } from '../types/public/index.js';
+import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
+import { RunnablePipeline } from './pipeline.js';
+import type { DevMatch, LogRequestPayload } from '../core/app/base.js';
+export declare class AstroServerApp extends BaseApp<RunnablePipeline> {
+    settings: AstroSettings;
+    logger: AstroLogger;
+    loader: ModuleLoader;
+    manifestData: RoutesList;
+    currentRenderContext: RenderContext | undefined;
+    constructor(manifest: SSRManifest, streaming: boolean | undefined, logger: AstroLogger, manifestData: RoutesList, loader: ModuleLoader, settings: AstroSettings, getDebugInfo: () => Promise<string>);
+    isDev(): boolean;
+    /**
+     * Updates the routes list when files change during development.
+     * Called via HMR when new pages are added/removed.
+     */
+    updateRoutes(newRoutesList: RoutesList): void;
+    /**
+     * Clears the route cache so that getStaticPaths() is re-evaluated.
+     * Called via HMR when content collection data changes.
+     */
+    clearRouteCache(): void;
+    /**
+     * Clears the cached middleware so it is re-resolved on the next request.
+     * Called via HMR when middleware files change.
+     */
+    clearMiddleware(): void;
+    devMatch(pathname: string): Promise<DevMatch | undefined>;
+    static create(manifest: SSRManifest, routesList: RoutesList, logger: AstroLogger, loader: ModuleLoader, settings: AstroSettings, getDebugInfo: () => Promise<string>): Promise<AstroServerApp>;
+    createPipeline(_streaming: boolean, manifest: SSRManifest, settings: AstroSettings, logger: AstroLogger, loader: ModuleLoader, manifestData: RoutesList, getDebugInfo: () => Promise<string>): RunnablePipeline;
+    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
+    handleRequest({ controller, incomingRequest, incomingResponse, isHttps, }: HandleRequest): Promise<void>;
+    match(request: Request, _allowPrerenderedRoutes: boolean): RouteData | undefined;
+    renderError(request: Request, { skipMiddleware, error, status, response: _response, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+    logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
+}
+type HandleRequest = {
+    controller: DevServerController;
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+    isHttps: boolean;
+};
+export {};

node_modules/astro/dist/vite-plugin-app/app.js

@@ -0,0 +1,252 @@
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { BaseApp } from "../core/app/entrypoints/index.js";
+import { getFirstForwardedValue, validateForwardedHeaders } from "../core/app/validate-headers.js";
+import { shouldAppendForwardSlash } from "../core/build/util.js";
+import { clientLocalsSymbol } from "../core/constants.js";
+import {
+  MiddlewareNoDataOrNextCalled,
+  MiddlewareNotAResponse
+} from "../core/errors/errors-data.js";
+import { createSafeError, isAstroError } from "../core/errors/index.js";
+import { createRequest } from "../core/request.js";
+import { recordServerError } from "../vite-plugin-astro-server/error.js";
+import { runWithErrorHandling } from "../vite-plugin-astro-server/index.js";
+import { handle500Response, writeSSRResult } from "../vite-plugin-astro-server/response.js";
+import { RunnablePipeline } from "./pipeline.js";
+import { getCustom404Route, getCustom500Route } from "../core/routing/helpers.js";
+import { ensure404Route } from "../core/routing/astro-designed-error-pages.js";
+import { matchRoute } from "../core/routing/dev.js";
+import { req } from "../core/messages/runtime.js";
+class AstroServerApp extends BaseApp {
+  settings;
+  logger;
+  loader;
+  manifestData;
+  currentRenderContext = void 0;
+  constructor(manifest, streaming = true, logger, manifestData, loader, settings, getDebugInfo) {
+    super(manifest, streaming, settings, logger, loader, manifestData, getDebugInfo);
+    this.settings = settings;
+    this.logger = logger;
+    this.loader = loader;
+    this.manifestData = manifestData;
+  }
+  isDev() {
+    return true;
+  }
+  /**
+   * Updates the routes list when files change during development.
+   * Called via HMR when new pages are added/removed.
+   */
+  updateRoutes(newRoutesList) {
+    this.manifestData = newRoutesList;
+    this.pipeline.setManifestData(newRoutesList);
+    ensure404Route(this.manifestData);
+  }
+  /**
+   * Clears the route cache so that getStaticPaths() is re-evaluated.
+   * Called via HMR when content collection data changes.
+   */
+  clearRouteCache() {
+    this.pipeline.clearRouteCache();
+  }
+  /**
+   * Clears the cached middleware so it is re-resolved on the next request.
+   * Called via HMR when middleware files change.
+   */
+  clearMiddleware() {
+    this.pipeline.clearMiddleware();
+  }
+  async devMatch(pathname) {
+    const matchedRoute = await matchRoute(
+      pathname,
+      this.manifestData,
+      this.pipeline,
+      this.manifest
+    );
+    if (!matchedRoute) {
+      return void 0;
+    }
+    return {
+      routeData: matchedRoute.route,
+      resolvedPathname: matchedRoute.resolvedPathname
+    };
+  }
+  static async create(manifest, routesList, logger, loader, settings, getDebugInfo) {
+    return new AstroServerApp(manifest, true, logger, routesList, loader, settings, getDebugInfo);
+  }
+  createPipeline(_streaming, manifest, settings, logger, loader, manifestData, getDebugInfo) {
+    const pipeline = RunnablePipeline.create(manifestData, {
+      loader,
+      logger,
+      manifest,
+      settings,
+      getDebugInfo
+    });
+    return pipeline;
+  }
+  async createRenderContext(payload) {
+    this.currentRenderContext = await super.createRenderContext(payload);
+    return this.currentRenderContext;
+  }
+  async handleRequest({
+    controller,
+    incomingRequest,
+    incomingResponse,
+    isHttps
+  }) {
+    const validated = validateForwardedHeaders(
+      getFirstForwardedValue(incomingRequest.headers["x-forwarded-proto"]),
+      getFirstForwardedValue(incomingRequest.headers["x-forwarded-host"]),
+      getFirstForwardedValue(incomingRequest.headers["x-forwarded-port"]),
+      this.manifest.allowedDomains
+    );
+    const protocol = validated.protocol ?? (isHttps ? "https" : "http");
+    const host = validated.host ?? incomingRequest.headers[":authority"] ?? incomingRequest.headers.host;
+    const origin = `${protocol}://${host}`;
+    const url = new URL(origin + incomingRequest.url);
+    let pathname;
+    if (this.manifest.trailingSlash === "never" && !incomingRequest.url) {
+      pathname = "";
+    } else {
+      pathname = decodeURI(url.pathname);
+    }
+    if (this.manifest.trailingSlash === "never" && pathname === "/" && this.manifest.base !== "/") {
+      pathname = "";
+    }
+    url.pathname = removeTrailingForwardSlash(this.manifest.base) + url.pathname;
+    if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
+      url.pathname = url.pathname.slice(0, -1);
+    }
+    let body = void 0;
+    if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+      let bytes = [];
+      await new Promise((resolve) => {
+        incomingRequest.on("data", (part) => {
+          bytes.push(part);
+        });
+        incomingRequest.on("end", resolve);
+      });
+      body = Buffer.concat(bytes);
+    }
+    const self = this;
+    await runWithErrorHandling({
+      controller,
+      pathname,
+      async run() {
+        const matchedRoute = await self.devMatch(pathname);
+        if (!matchedRoute) {
+          throw new Error("No route matched, and default 404 route was not found.");
+        }
+        const request = createRequest({
+          url,
+          headers: incomingRequest.headers,
+          method: incomingRequest.method,
+          body,
+          logger: self.logger,
+          isPrerendered: matchedRoute.routeData.prerender,
+          routePattern: matchedRoute.routeData.component
+        });
+        const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
+        for (const [name, value] of Object.entries(self.settings.config.server.headers ?? {})) {
+          if (value) incomingResponse.setHeader(name, value);
+        }
+        const clientAddress = incomingRequest.socket.remoteAddress;
+        const response = await self.render(request, {
+          locals,
+          routeData: matchedRoute.routeData,
+          clientAddress
+        });
+        await writeSSRResult(request, response, incomingResponse);
+      },
+      onError(_err) {
+        const error = createSafeError(_err);
+        if (self.loader) {
+          const { errorWithMetadata } = recordServerError(
+            self.loader,
+            self.manifest,
+            self.logger,
+            error
+          );
+          handle500Response(self.loader, incomingResponse, errorWithMetadata);
+        }
+        return error;
+      }
+    });
+  }
+  match(request, _allowPrerenderedRoutes) {
+    return super.match(request, true);
+  }
+  async renderError(request, {
+    skipMiddleware = false,
+    error,
+    status,
+    response: _response,
+    ...resolvedRenderOptions
+  }) {
+    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+      throw error;
+    }
+    const renderRoute = async (routeData) => {
+      try {
+        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
+        const renderContext = await this.createRenderContext({
+          locals: resolvedRenderOptions.locals,
+          pipeline: this.pipeline,
+          pathname: this.getPathnameFromRequest(request),
+          skipMiddleware,
+          request,
+          routeData,
+          clientAddress: resolvedRenderOptions.clientAddress,
+          status,
+          shouldInjectCspMetaTags: !!this.manifest.csp
+        });
+        renderContext.props.error = error;
+        const response = await renderContext.render(preloadedComponent);
+        if (error) {
+          this.logger.error("router", error.stack || error.message);
+        }
+        return response;
+      } catch (_err) {
+        if (skipMiddleware === false) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status: 500,
+            skipMiddleware: true,
+            error: _err
+          });
+        }
+        throw _err;
+      }
+    };
+    if (status === 404) {
+      const custom404 = getCustom404Route(this.manifestData);
+      if (custom404) {
+        return renderRoute(custom404);
+      }
+    }
+    const custom500 = getCustom500Route(this.manifestData);
+    if (!custom500) {
+      throw error;
+    } else {
+      return renderRoute(custom500);
+    }
+  }
+  logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
+    if (pathname === "/favicon.ico") {
+      return;
+    }
+    this.logger.info(
+      null,
+      req({
+        url: pathname,
+        method,
+        statusCode,
+        isRewrite,
+        reqTime
+      })
+    );
+  }
+}
+export {
+  AstroServerApp
+};

node_modules/astro/dist/vite-plugin-app/createAstroServerApp.d.ts

@@ -0,0 +1,8 @@
+import type http from 'node:http';
+import { AstroLogger } from '../core/logger/core.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
+export default function createAstroServerApp(controller: DevServerController, settings: AstroSettings, loader: ModuleLoader, logger?: AstroLogger): Promise<{
+    handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse): void;
+}>;

node_modules/astro/dist/vite-plugin-app/createAstroServerApp.js

@@ -0,0 +1,79 @@
+import { manifest } from "virtual:astro:manifest";
+import { routes } from "virtual:astro:routes";
+import { getPackageManager } from "../cli/info/core/get-package-manager.js";
+import { DevDebugInfoProvider } from "../cli/info/infra/dev-debug-info-provider.js";
+import { ProcessNodeVersionProvider } from "../cli/info/infra/process-node-version-provider.js";
+import { ProcessPackageManagerUserAgentProvider } from "../cli/info/infra/process-package-manager-user-agent-provider.js";
+import { StyledDebugInfoFormatter } from "../cli/info/infra/styled-debug-info-formatter.js";
+import { BuildTimeAstroVersionProvider } from "../cli/infra/build-time-astro-version-provider.js";
+import { PassthroughTextStyler } from "../cli/infra/passthrough-text-styler.js";
+import { ProcessOperatingSystemProvider } from "../cli/infra/process-operating-system-provider.js";
+import { TinyexecCommandExecutor } from "../cli/infra/tinyexec-command-executor.js";
+import { AstroLogger } from "../core/logger/core.js";
+import { nodeLogDestination } from "../core/logger/node.js";
+import { AstroServerApp } from "./app.js";
+async function createAstroServerApp(controller, settings, loader, logger) {
+  const actualLogger = logger ?? new AstroLogger({
+    destination: nodeLogDestination,
+    level: settings.logLevel
+  });
+  const routesList = { routes: routes.map((r) => r.routeData) };
+  const debugInfoProvider = new DevDebugInfoProvider({
+    config: settings.config,
+    astroVersionProvider: new BuildTimeAstroVersionProvider(),
+    operatingSystemProvider: new ProcessOperatingSystemProvider(),
+    packageManager: await getPackageManager({
+      packageManagerUserAgentProvider: new ProcessPackageManagerUserAgentProvider(),
+      commandExecutor: new TinyexecCommandExecutor()
+    }),
+    nodeVersionProvider: new ProcessNodeVersionProvider()
+  });
+  const debugInfoFormatter = new StyledDebugInfoFormatter({
+    textStyler: new PassthroughTextStyler()
+  });
+  const debugInfo = debugInfoFormatter.format(await debugInfoProvider.get());
+  const app = await AstroServerApp.create(
+    manifest,
+    routesList,
+    actualLogger,
+    loader,
+    settings,
+    async () => debugInfo
+  );
+  if (import.meta.hot) {
+    import.meta.hot.on("astro:routes-updated", async () => {
+      try {
+        const { routes: newRoutes } = await import("virtual:astro:routes");
+        const newRoutesList = {
+          routes: newRoutes.map((r) => r.routeData)
+        };
+        app.updateRoutes(newRoutesList);
+        actualLogger.debug("router", "Routes updated via HMR");
+      } catch (e) {
+        actualLogger.error("router", `Failed to update routes via HMR:
+ ${e}`);
+      }
+    });
+    import.meta.hot.on("astro:content-changed", () => {
+      app.clearRouteCache();
+      actualLogger.debug("router", "Route cache cleared due to content change");
+    });
+    import.meta.hot.on("astro:middleware-updated", () => {
+      app.clearMiddleware();
+      actualLogger.debug("router", "Middleware cache cleared due to file change");
+    });
+  }
+  return {
+    handler(incomingRequest, incomingResponse) {
+      app.handleRequest({
+        controller,
+        incomingRequest,
+        incomingResponse,
+        isHttps: loader?.isHttps() ?? false
+      });
+    }
+  };
+}
+export {
+  createAstroServerApp as default
+};

node_modules/astro/dist/vite-plugin-app/index.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+export declare const ASTRO_DEV_SERVER_APP_ID = "astro:server-app";
+export declare function vitePluginApp(): vite.Plugin[];

node_modules/astro/dist/vite-plugin-app/index.js

@@ -0,0 +1,50 @@
+const ASTRO_APP_ID = "virtual:astro:app";
+const RESOLVED_ASTRO_APP_ID = "\0" + ASTRO_APP_ID;
+const ASTRO_DEV_SERVER_APP_ID = "astro:server-app";
+function vitePluginApp() {
+  let command;
+  return [
+    {
+      name: "astro:app",
+      configResolved(config) {
+        command = config.command;
+      },
+      resolveId: {
+        filter: {
+          id: new RegExp(`^${ASTRO_APP_ID}$`)
+        },
+        handler() {
+          return RESOLVED_ASTRO_APP_ID;
+        }
+      },
+      load: {
+        filter: {
+          id: new RegExp(`^${RESOLVED_ASTRO_APP_ID}$`)
+        },
+        handler() {
+          const entrypoint = command === "serve" ? "astro/app/entrypoint/dev" : "astro/app/entrypoint/prod";
+          const code = `export { createApp } from '${entrypoint}';`;
+          return {
+            code
+          };
+        }
+      }
+    },
+    {
+      name: "astro:server-app",
+      resolveId: {
+        filter: {
+          id: new RegExp(`^${ASTRO_DEV_SERVER_APP_ID}$`)
+        },
+        handler() {
+          const url = new URL("./createAstroServerApp.js", import.meta.url);
+          return this.resolve(url.toString());
+        }
+      }
+    }
+  ];
+}
+export {
+  ASTRO_DEV_SERVER_APP_ID,
+  vitePluginApp
+};

node_modules/astro/dist/vite-plugin-app/pipeline.d.ts

@@ -0,0 +1,24 @@
+import { type HeadElements, Pipeline, type TryRewriteResult } from '../core/base-pipeline.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroSettings, ComponentInstance, RoutesList } from '../types/astro.js';
+import type { RewritePayload, RouteData, SSRLoadedRenderer } from '../types/public/index.js';
+/**
+ * This Pipeline is used when the Vite SSR environment is runnable.
+ */
+export declare class RunnablePipeline extends Pipeline {
+    getName(): string;
+    renderers: SSRLoadedRenderer[];
+    routesList: RoutesList | undefined;
+    readonly loader: ModuleLoader;
+    readonly settings: AstroSettings;
+    readonly getDebugInfo: () => Promise<string>;
+    private constructor();
+    static create(manifestData: RoutesList, { loader, logger, manifest, settings, getDebugInfo, }: Pick<RunnablePipeline, 'loader' | 'logger' | 'manifest' | 'settings' | 'getDebugInfo'>): RunnablePipeline;
+    headElements(routeData: RouteData): Promise<HeadElements>;
+    componentMetadata(routeData: RouteData): Promise<Map<string, import("../types/public/internal.js").SSRComponentMetadata>>;
+    preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
+    clearRouteCache(): void;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
+    setManifestData(manifestData: RoutesList): void;
+}

node_modules/astro/dist/vite-plugin-app/pipeline.js

@@ -0,0 +1,193 @@
+import { fileURLToPath } from "node:url";
+import { Pipeline } from "../core/base-pipeline.js";
+import { ASTRO_VERSION } from "../core/constants.js";
+import { enhanceViteSSRError } from "../core/errors/dev/index.js";
+import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { RedirectComponentInstance } from "../core/redirects/index.js";
+import { loadRenderer } from "../core/render/index.js";
+import { routeIsRedirect } from "../core/routing/helpers.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+import { isPage } from "../core/util.js";
+import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
+import { createResolve } from "../vite-plugin-astro-server/resolve.js";
+import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+import { newNodePool } from "../runtime/server/render/queue/pool.js";
+import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
+import { queueRenderingEnabled } from "../core/app/manifest.js";
+class RunnablePipeline extends Pipeline {
+  getName() {
+    return "RunnablePipeline";
+  }
+  // renderers are loaded on every request,
+  // so it needs to be mutable here unlike in other environments
+  renderers = new Array();
+  routesList;
+  loader;
+  settings;
+  getDebugInfo;
+  constructor(loader, logger, manifest, settings, getDebugInfo, defaultRoutes) {
+    const resolve = createResolve(loader, manifest.rootDir);
+    const streaming = true;
+    super(
+      logger,
+      manifest,
+      "development",
+      [],
+      resolve,
+      streaming,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      defaultRoutes
+    );
+    this.loader = loader;
+    this.settings = settings;
+    this.getDebugInfo = getDebugInfo;
+  }
+  static create(manifestData, {
+    loader,
+    logger,
+    manifest,
+    settings,
+    getDebugInfo
+  }) {
+    const pipeline = new RunnablePipeline(loader, logger, manifest, settings, getDebugInfo);
+    pipeline.routesList = manifestData;
+    if (queueRenderingEnabled(manifest.experimentalQueuedRendering)) {
+      pipeline.nodePool = newNodePool(manifest.experimentalQueuedRendering);
+      if (manifest.experimentalQueuedRendering.contentCache) {
+        pipeline.htmlStringCache = new HTMLStringCache(1e3);
+      }
+    }
+    return pipeline;
+  }
+  async headElements(routeData) {
+    const { manifest, runtimeMode, settings } = this;
+    const filePath = new URL(`${routeData.component}`, manifest.rootDir);
+    const scripts = /* @__PURE__ */ new Set();
+    if (settings) {
+      if (isPage(filePath, settings) && runtimeMode === "development") {
+        scripts.add({
+          props: { type: "module", src: "/@vite/client" },
+          children: ""
+        });
+        if (this.manifest.devToolbar.enabled) {
+          scripts.add({
+            props: {
+              type: "module",
+              src: "/@id/astro/runtime/client/dev-toolbar/entrypoint.js"
+            },
+            children: ""
+          });
+          const additionalMetadata = {
+            root: fileURLToPath(settings.config.root),
+            version: ASTRO_VERSION,
+            latestAstroVersion: settings.latestAstroVersion,
+            // TODO: Currently the debug info is always fetched, which slows things down.
+            // We should look into not loading it if the dev toolbar is disabled. And when
+            // enabled, it would nice to request the debug info through import.meta.hot
+            // when the button is click to defer execution as much as possible
+            debugInfo: await this.getDebugInfo(),
+            placement: settings.config.devToolbar.placement
+          };
+          const children = `window.__astro_dev_toolbar__ = ${JSON.stringify(additionalMetadata)}`;
+          scripts.add({ props: {}, children });
+        }
+      }
+      for (const script of settings.scripts) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.content
+          });
+        } else if (script.stage === "page" && isPage(filePath, settings)) {
+          scripts.add({
+            props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
+            children: ""
+          });
+        }
+      }
+    }
+    const { devCSSMap } = await import("virtual:astro:dev-css-all");
+    const importer = devCSSMap.get(routeData.component);
+    let css = /* @__PURE__ */ new Set();
+    if (importer) {
+      const cssModule = await importer();
+      css = cssModule.css;
+    } else {
+      this.logger.warn(
+        "assets",
+        `Unable to find CSS for ${routeData.component}. This is likely a bug in Astro.`
+      );
+    }
+    const links = /* @__PURE__ */ new Set();
+    const styles = /* @__PURE__ */ new Set();
+    for (const { id, url: src, content } of css) {
+      scripts.add({ props: { type: "module", src }, children: "" });
+      styles.add({ props: { "data-vite-dev-id": id }, children: content });
+    }
+    return { scripts, styles, links };
+  }
+  componentMetadata(routeData) {
+    const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
+    return getComponentMetadata(filePath, this.loader);
+  }
+  async preload(routeData, filePath) {
+    if (routeIsRedirect(routeData)) {
+      return RedirectComponentInstance;
+    }
+    const { loader } = this;
+    for (const route of this.defaultRoutes) {
+      if (route.matchesComponent(filePath)) {
+        return route.instance;
+      }
+    }
+    if (this.settings) {
+      const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
+      const renderers_ = await Promise.all(renderers__);
+      this.renderers = renderers_.filter((r) => Boolean(r));
+    }
+    try {
+      return await loader.import(filePath.toString());
+    } catch (error) {
+      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+        throw error;
+      }
+      throw enhanceViteSSRError({ error, filePath, loader });
+    }
+  }
+  clearRouteCache() {
+    this.routeCache.clearAll();
+  }
+  async getComponentByRoute(routeData) {
+    const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
+    return await this.preload(routeData, filePath);
+  }
+  async tryRewrite(payload, request) {
+    if (!this.routesList) {
+      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
+    }
+    const { routeData, pathname, newUrl } = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.routesList?.routes,
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat,
+      base: this.manifest.base,
+      outDir: this.manifest.outDir
+    });
+    const componentInstance = await this.getComponentByRoute(routeData);
+    return { newUrl, pathname, componentInstance, routeData };
+  }
+  setManifestData(manifestData) {
+    this.routesList = manifestData;
+  }
+}
+export {
+  RunnablePipeline
+};