astro 4.7.1 → 4.8.0

package/dist/runtime/server/shorthash.js

@@ -32,8 +32,7 @@ const dictionary = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX
 const binary = dictionary.length;
 function bitwise(str) {
   let hash = 0;
-  if (str.length === 0)
-    return hash;
+  if (str.length === 0) return hash;
   for (let i = 0; i < str.length; i++) {
     const ch = str.charCodeAt(i);
     hash = (hash << 5) - hash + ch;

package/dist/runtime/server/transition.js

@@ -15,12 +15,9 @@ function createTransitionScope(result, hash) {
   return `astro-${hash}-${num}`;
 }
 const getAnimations = (name) => {
-  if (name === "fade")
-    return fade();
-  if (name === "slide")
-    return slide();
-  if (typeof name === "object")
-    return name;
+  if (name === "fade") return fade();
+  if (name === "slide") return slide();
+  if (typeof name === "object") return name;
 };
 const addPairs = (animations, stylesheet) => {
   for (const [direction, images] of Object.entries(animations)) {
@@ -46,8 +43,7 @@ function renderTransition(result, hash, animationName, transitionName) {
   if (typeof (transitionName ?? "") !== "string") {
     throw new Error(`Invalid transition name {${transitionName}}`);
   }
-  if (!animationName)
-    animationName = "fade";
+  if (!animationName) animationName = "fade";
   const scope = createTransitionScope(result, hash);
   const name = transitionName ? cssesc(reEncode(transitionName), { isIdentifier: true }) : scope;
   const sheet = new ViewTransitionStyleSheet(scope, name);

package/dist/runtime/server/util.js

@@ -6,8 +6,7 @@ async function* streamAsyncIterator(stream) {
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done)
-        return;
+      if (done) return;
       yield value;
     }
   } finally {

package/dist/transitions/events.d.ts

@@ -16,7 +16,7 @@ declare class BeforeEvent extends Event {
     readonly sourceElement: Element | undefined;
     readonly info: any;
     newDocument: Document;
-    signal: AbortSignal;
+    readonly signal: AbortSignal;
     constructor(type: string, eventInitDict: EventInit | undefined, from: URL, to: URL, direction: Direction | string, navigationType: NavigationTypeString, sourceElement: Element | undefined, info: any, newDocument: Document, signal: AbortSignal);
 }
 export declare const isTransitionBeforePreparationEvent: (value: any) => value is TransitionBeforePreparationEvent;
@@ -30,8 +30,8 @@ export declare class TransitionBeforeSwapEvent extends BeforeEvent {
     readonly direction: Direction | string;
     readonly viewTransition: ViewTransition;
     swap: () => void;
-    constructor(afterPreparation: BeforeEvent, viewTransition: ViewTransition, swap: (event: TransitionBeforeSwapEvent) => void);
+    constructor(afterPreparation: BeforeEvent, viewTransition: ViewTransition);
 }
 export declare function doPreparation(from: URL, to: URL, direction: Direction | string, navigationType: NavigationTypeString, sourceElement: Element | undefined, info: any, signal: AbortSignal, formData: FormData | undefined, defaultLoader: (event: TransitionBeforePreparationEvent) => Promise<void>): Promise<TransitionBeforePreparationEvent>;
-export declare function doSwap(afterPreparation: BeforeEvent, viewTransition: ViewTransition, defaultSwap: (event: TransitionBeforeSwapEvent) => void): TransitionBeforeSwapEvent;
+export declare function doSwap(afterPreparation: BeforeEvent, viewTransition: ViewTransition): TransitionBeforeSwapEvent;
 export {};

package/dist/transitions/events.js

@@ -1,4 +1,5 @@
 import { updateScrollPosition } from "./router.js";
+import { swap } from "./swap-functions.js";
 const TRANSITION_BEFORE_PREPARATION = "astro:before-preparation";
 const TRANSITION_AFTER_PREPARATION = "astro:after-preparation";
 const TRANSITION_BEFORE_SWAP = "astro:before-swap";
@@ -67,7 +68,7 @@ class TransitionBeforeSwapEvent extends BeforeEvent {
   direction;
   viewTransition;
   swap;
-  constructor(afterPreparation, viewTransition, swap) {
+  constructor(afterPreparation, viewTransition) {
     super(
       TRANSITION_BEFORE_SWAP,
       void 0,
@@ -82,7 +83,7 @@ class TransitionBeforeSwapEvent extends BeforeEvent {
     );
     this.direction = afterPreparation.direction;
     this.viewTransition = viewTransition;
-    this.swap = swap.bind(this, this);
+    this.swap = () => swap(this.newDocument);
     Object.defineProperties(this, {
       direction: { enumerable: true },
       viewTransition: { enumerable: true },
@@ -114,8 +115,8 @@ async function doPreparation(from, to, direction, navigationType, sourceElement,
   }
   return event;
 }
-function doSwap(afterPreparation, viewTransition, defaultSwap) {
-  const event = new TransitionBeforeSwapEvent(afterPreparation, viewTransition, defaultSwap);
+function doSwap(afterPreparation, viewTransition) {
+  const event = new TransitionBeforeSwapEvent(afterPreparation, viewTransition);
   document.dispatchEvent(event);
   event.swap();
   return event;

package/dist/transitions/router.js

@@ -1,4 +1,12 @@
 import { TRANSITION_AFTER_SWAP, doPreparation, doSwap } from "./events.js";
+import {
+  deselectScripts,
+  restoreFocus,
+  saveFocus,
+  swapBodyElement,
+  swapHeadElements,
+  swapRootAttributes
+} from "./swap-functions.js";
 const inBrowser = import.meta.env.SSR === false;
 const pushState = inBrowser && history.pushState.bind(history);
 const replaceState = inBrowser && history.replaceState.bind(history);
@@ -76,11 +84,9 @@ function getFallback() {
 function runScripts() {
   let wait = Promise.resolve();
   for (const script of Array.from(document.scripts)) {
-    if (script.dataset.astroExec === "")
-      continue;
+    if (script.dataset.astroExec === "") continue;
     const type = script.getAttribute("type");
-    if (type && type !== "module" && type !== "text/javascript")
-      continue;
+    if (type && type !== "module" && type !== "text/javascript") continue;
     const newScript = document.createElement("script");
     newScript.innerHTML = script.innerHTML;
     for (const attr of script.attributes) {
@@ -173,97 +179,10 @@ function preloadStyleLinks(newDocument) {
   return links;
 }
 async function updateDOM(preparationEvent, options, currentTransition, historyState, fallback) {
-  const persistedHeadElement = (el, newDoc) => {
-    const id = el.getAttribute(PERSIST_ATTR);
-    const newEl = id && newDoc.head.querySelector(`[${PERSIST_ATTR}="${id}"]`);
-    if (newEl) {
-      return newEl;
-    }
-    if (el.matches("link[rel=stylesheet]")) {
-      const href = el.getAttribute("href");
-      return newDoc.head.querySelector(`link[rel=stylesheet][href="${href}"]`);
-    }
-    return null;
-  };
-  const saveFocus = () => {
-    const activeElement = document.activeElement;
-    if (activeElement?.closest(`[${PERSIST_ATTR}]`)) {
-      if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
-        const start = activeElement.selectionStart;
-        const end = activeElement.selectionEnd;
-        return { activeElement, start, end };
-      }
-      return { activeElement };
-    } else {
-      return { activeElement: null };
-    }
-  };
-  const restoreFocus = ({ activeElement, start, end }) => {
-    if (activeElement) {
-      activeElement.focus();
-      if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
-        if (typeof start === "number")
-          activeElement.selectionStart = start;
-        if (typeof end === "number")
-          activeElement.selectionEnd = end;
-      }
-    }
-  };
-  const shouldCopyProps = (el) => {
-    const persistProps = el.dataset.astroTransitionPersistProps;
-    return persistProps == null || persistProps === "false";
-  };
-  const defaultSwap = (beforeSwapEvent) => {
-    const html = document.documentElement;
-    const astroAttributes = [...html.attributes].filter(
-      ({ name }) => (html.removeAttribute(name), name.startsWith("data-astro-"))
-    );
-    [...beforeSwapEvent.newDocument.documentElement.attributes, ...astroAttributes].forEach(
-      ({ name, value }) => html.setAttribute(name, value)
-    );
-    for (const s1 of document.scripts) {
-      for (const s2 of beforeSwapEvent.newDocument.scripts) {
-        if (
-          // Check if the script should be rerun regardless of it being the same
-          !s2.hasAttribute("data-astro-rerun") && // Inline
-          (!s1.src && s1.textContent === s2.textContent || // External
-          s1.src && s1.type === s2.type && s1.src === s2.src)
-        ) {
-          s2.dataset.astroExec = "";
-          break;
-        }
-      }
-    }
-    for (const el of Array.from(document.head.children)) {
-      const newEl = persistedHeadElement(el, beforeSwapEvent.newDocument);
-      if (newEl) {
-        newEl.remove();
-      } else {
-        el.remove();
-      }
-    }
-    document.head.append(...beforeSwapEvent.newDocument.head.children);
-    const oldBody = document.body;
-    const savedFocus = saveFocus();
-    document.body.replaceWith(beforeSwapEvent.newDocument.body);
-    for (const el of oldBody.querySelectorAll(`[${PERSIST_ATTR}]`)) {
-      const id = el.getAttribute(PERSIST_ATTR);
-      const newEl = document.querySelector(`[${PERSIST_ATTR}="${id}"]`);
-      if (newEl) {
-        newEl.replaceWith(el);
-        if (newEl.localName === "astro-island" && shouldCopyProps(el)) {
-          el.setAttribute("ssr", "");
-          el.setAttribute("props", newEl.getAttribute("props"));
-        }
-      }
-    }
-    restoreFocus(savedFocus);
-  };
   async function animate(phase) {
     function isInfinite(animation) {
       const effect = animation.effect;
-      if (!effect || !(effect instanceof KeyframeEffect) || !effect.target)
-        return false;
+      if (!effect || !(effect instanceof KeyframeEffect) || !effect.target) return false;
       const style = window.getComputedStyle(effect.target, effect.pseudoElement);
       return style.animationIterationCount === "infinite";
     }
@@ -282,7 +201,7 @@ async function updateDOM(preparationEvent, options, currentTransition, historySt
     }
   }
   const pageTitleForBrowserHistory = document.title;
-  const swapEvent = doSwap(preparationEvent, currentTransition.viewTransition, defaultSwap);
+  const swapEvent = doSwap(preparationEvent, currentTransition.viewTransition);
   moveToLocation(swapEvent.to, swapEvent.from, options, pageTitleForBrowserHistory, historyState);
   triggerEvent(TRANSITION_AFTER_SWAP);
   if (fallback === "animate") {
@@ -302,8 +221,7 @@ function abortAndRecreateMostRecentNavigation() {
 async function transition(direction, from, to, options, historyState) {
   const currentNavigation = abortAndRecreateMostRecentNavigation();
   if (!transitionEnabledOnThisPage() || location.origin !== to.origin) {
-    if (currentNavigation === mostRecentNavigation)
-      mostRecentNavigation = void 0;
+    if (currentNavigation === mostRecentNavigation) mostRecentNavigation = void 0;
     location.href = to.href;
     return;
   }
@@ -314,8 +232,7 @@ async function transition(direction, from, to, options, historyState) {
   if (samePage(from, to)) {
     if (direction !== "back" && to.hash || direction === "back" && from.hash) {
       moveToLocation(to, from, options, document.title, historyState);
-      if (currentNavigation === mostRecentNavigation)
-        mostRecentNavigation = void 0;
+      if (currentNavigation === mostRecentNavigation) mostRecentNavigation = void 0;
       return;
     }
   }
@@ -331,8 +248,7 @@ async function transition(direction, from, to, options, historyState) {
     defaultLoader
   );
   if (prepEvent.defaultPrevented || prepEvent.signal.aborted) {
-    if (currentNavigation === mostRecentNavigation)
-      mostRecentNavigation = void 0;
+    if (currentNavigation === mostRecentNavigation) mostRecentNavigation = void 0;
     if (!prepEvent.signal.aborted) {
       location.href = to.href;
     }
@@ -387,8 +303,7 @@ async function transition(direction, from, to, options, historyState) {
   }
   const currentTransition = await abortAndRecreateMostRecentTransition();
   if (prepEvent.signal.aborted) {
-    if (currentNavigation === mostRecentNavigation)
-      mostRecentNavigation = void 0;
+    if (currentNavigation === mostRecentNavigation) mostRecentNavigation = void 0;
     return;
   }
   document.documentElement.setAttribute(DIRECTION_ATTR, prepEvent.direction);
@@ -423,10 +338,8 @@ async function transition(direction, from, to, options, historyState) {
   });
   currentTransition.viewTransition.finished.finally(() => {
     currentTransition.viewTransition = void 0;
-    if (currentTransition === mostRecentTransition)
-      mostRecentTransition = void 0;
-    if (currentNavigation === mostRecentNavigation)
-      mostRecentNavigation = void 0;
+    if (currentTransition === mostRecentTransition) mostRecentTransition = void 0;
+    if (currentNavigation === mostRecentNavigation) mostRecentNavigation = void 0;
     document.documentElement.removeAttribute(DIRECTION_ATTR);
     document.documentElement.removeAttribute(OLD_NEW_ATTR);
   });
@@ -476,8 +389,7 @@ if (inBrowser) {
     originalLocation = new URL(location.href);
     addEventListener("popstate", onPopState);
     addEventListener("load", onPageLoad);
-    if ("onscrollend" in window)
-      addEventListener("scrollend", onScrollEnd);
+    if ("onscrollend" in window) addEventListener("scrollend", onScrollEnd);
     else {
       let intervalId, lastY, lastX, lastIndex;
       const scrollInterval = () => {
@@ -498,8 +410,7 @@ if (inBrowser) {
       addEventListener(
         "scroll",
         () => {
-          if (intervalId !== void 0)
-            return;
+          if (intervalId !== void 0) return;
           lastIndex = history.state.index, lastY = scrollY, lastX = scrollX;
           intervalId = window.setInterval(scrollInterval, 50);
         },
@@ -543,10 +454,8 @@ async function prepareForClientOnlyComponents(newDocument, toLocation, signal) {
       }
       return new Promise(async (r) => {
         for (let count = 0; count <= 20; ++count) {
-          if (signal.aborted)
-            break;
-          if (!loadingPage.contentDocument.body.querySelector("astro-island[ssr]"))
-            break;
+          if (signal.aborted) break;
+          if (!loadingPage.contentDocument.body.querySelector("astro-island[ssr]")) break;
           await new Promise((r2) => setTimeout(r2, 50));
         }
         r();

package/dist/transitions/swap-functions.d.ts

@@ -0,0 +1,12 @@
+export type SavedFocus = {
+    activeElement: HTMLElement | null;
+    start?: number | null;
+    end?: number | null;
+};
+export declare function deselectScripts(doc: Document): void;
+export declare function swapRootAttributes(doc: Document): void;
+export declare function swapHeadElements(doc: Document): void;
+export declare function swapBodyElement(newElement: Element, oldElement: Element): void;
+export declare const saveFocus: () => (() => void);
+export declare const restoreFocus: ({ activeElement, start, end }: SavedFocus) => void;
+export declare const swap: (doc: Document) => void;

package/dist/transitions/swap-functions.js

@@ -0,0 +1,105 @@
+const PERSIST_ATTR = "data-astro-transition-persist";
+function deselectScripts(doc) {
+  for (const s1 of document.scripts) {
+    for (const s2 of doc.scripts) {
+      if (
+        // Check if the script should be rerun regardless of it being the same
+        !s2.hasAttribute("data-astro-rerun") && // Inline
+        (!s1.src && s1.textContent === s2.textContent || // External
+        s1.src && s1.type === s2.type && s1.src === s2.src)
+      ) {
+        s2.dataset.astroExec = "";
+        break;
+      }
+    }
+  }
+}
+function swapRootAttributes(doc) {
+  const html = document.documentElement;
+  const astroAttributes = [...html.attributes].filter(
+    ({ name }) => (html.removeAttribute(name), name.startsWith("data-astro-"))
+  );
+  [...doc.documentElement.attributes, ...astroAttributes].forEach(
+    ({ name, value }) => html.setAttribute(name, value)
+  );
+}
+function swapHeadElements(doc) {
+  for (const el of Array.from(document.head.children)) {
+    const newEl = persistedHeadElement(el, doc);
+    if (newEl) {
+      newEl.remove();
+    } else {
+      el.remove();
+    }
+  }
+  document.head.append(...doc.head.children);
+}
+function swapBodyElement(newElement, oldElement) {
+  oldElement.replaceWith(newElement);
+  for (const el of oldElement.querySelectorAll(`[${PERSIST_ATTR}]`)) {
+    const id = el.getAttribute(PERSIST_ATTR);
+    const newEl = newElement.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+    if (newEl) {
+      newEl.replaceWith(el);
+      if (newEl.localName === "astro-island" && shouldCopyProps(el)) {
+        el.setAttribute("ssr", "");
+        el.setAttribute("props", newEl.getAttribute("props"));
+      }
+    }
+  }
+}
+const saveFocus = () => {
+  const activeElement = document.activeElement;
+  if (activeElement?.closest(`[${PERSIST_ATTR}]`)) {
+    if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
+      const start = activeElement.selectionStart;
+      const end = activeElement.selectionEnd;
+      return () => restoreFocus({ activeElement, start, end });
+    }
+    return () => restoreFocus({ activeElement });
+  } else {
+    return () => restoreFocus({ activeElement: null });
+  }
+};
+const restoreFocus = ({ activeElement, start, end }) => {
+  if (activeElement) {
+    activeElement.focus();
+    if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
+      if (typeof start === "number") activeElement.selectionStart = start;
+      if (typeof end === "number") activeElement.selectionEnd = end;
+    }
+  }
+};
+const persistedHeadElement = (el, newDoc) => {
+  const id = el.getAttribute(PERSIST_ATTR);
+  const newEl = id && newDoc.head.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+  if (newEl) {
+    return newEl;
+  }
+  if (el.matches("link[rel=stylesheet]")) {
+    const href = el.getAttribute("href");
+    return newDoc.head.querySelector(`link[rel=stylesheet][href="${href}"]`);
+  }
+  return null;
+};
+const shouldCopyProps = (el) => {
+  const persistProps = el.dataset.astroTransitionPersistProps;
+  return persistProps == null || persistProps === "false";
+};
+const swap = (doc) => {
+  deselectScripts(doc);
+  swapRootAttributes(doc);
+  swapHeadElements(doc);
+  const restoreFocusFunction = saveFocus();
+  swapBodyElement(doc.body, document.body);
+  restoreFocusFunction();
+};
+export {
+  deselectScripts,
+  restoreFocus,
+  saveFocus,
+  swap,
+  swapBodyElement,
+  swapHeadElements,
+  swapRootAttributes
+};

package/dist/vite-plugin-astro/compile.js

@@ -71,8 +71,7 @@ async function enhanceCompileError({
   const scannedFrontmatter = frontmatterRE.exec(source);
   if (scannedFrontmatter) {
     const frontmatter = scannedFrontmatter[1].replace(/\breturn\b/g, "throw");
-    if (lineText && !frontmatter.includes(lineText))
-      throw err;
+    if (lineText && !frontmatter.includes(lineText)) throw err;
     try {
       await transformWithEsbuild(frontmatter, id, {
         loader: "ts",

package/dist/vite-plugin-astro/hmr.js

@@ -7,8 +7,7 @@ async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
     }
   }
   const oldCode = astroFileToCompileMetadata.get(ctx.file)?.originalCode;
-  if (oldCode == null)
-    return;
+  if (oldCode == null) return;
   const newCode = await ctx.read();
   if (isStyleOnlyChanged(oldCode, newCode)) {
     logger.debug("watch", "style-only change");
@@ -19,26 +18,22 @@ async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
 const scriptRE = /<script(?:\s.*?)?>.*?<\/script>/gs;
 const styleRE = /<style(?:\s.*?)?>.*?<\/style>/gs;
 function isStyleOnlyChanged(oldCode, newCode) {
-  if (oldCode === newCode)
-    return false;
+  if (oldCode === newCode) return false;
   let oldFrontmatter = "";
   let newFrontmatter = "";
   oldCode = oldCode.replace(frontmatterRE, (m) => (oldFrontmatter = m, ""));
   newCode = newCode.replace(frontmatterRE, (m) => (newFrontmatter = m, ""));
-  if (oldFrontmatter !== newFrontmatter)
-    return false;
+  if (oldFrontmatter !== newFrontmatter) return false;
   const oldScripts = [];
   const newScripts = [];
   oldCode = oldCode.replace(scriptRE, (m) => (oldScripts.push(m), ""));
   newCode = newCode.replace(scriptRE, (m) => (newScripts.push(m), ""));
-  if (!isArrayEqual(oldScripts, newScripts))
-    return false;
+  if (!isArrayEqual(oldScripts, newScripts)) return false;
   const oldStyles = [];
   const newStyles = [];
   oldCode = oldCode.replace(styleRE, (m) => (oldStyles.push(m), ""));
   newCode = newCode.replace(styleRE, (m) => (newStyles.push(m), ""));
-  if (oldCode !== newCode)
-    return false;
+  if (oldCode !== newCode) return false;
   return oldStyles.length === newStyles.length && !isArrayEqual(oldStyles, newStyles);
 }
 function isArrayEqual(a, b) {

package/dist/vite-plugin-astro/index.js

@@ -57,8 +57,7 @@ function astro({ settings, logger }) {
       if (!compileMetadata) {
         if (server) {
           const code = await loadId(server.pluginContainer, filename);
-          if (code != null)
-            await compile(code, filename);
+          if (code != null) await compile(code, filename);
         } else if (config.experimental.contentCollectionCache) {
           await this.load({
             id: filename,
@@ -191,8 +190,7 @@ File: ${id}`
   return [prePlugin, normalPlugin];
 }
 function appendSourceMap(content, map) {
-  if (!map)
-    return content;
+  if (!map) return content;
   return `${content}
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(
     map

package/dist/vite-plugin-astro-server/pipeline.d.ts

@@ -1,4 +1,4 @@
-import type { AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
+import type { AstroSettings, ComponentInstance, ManifestData, RewritePayload, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
 import type { HeadElements } from '../core/base-pipeline.js';
 import type { Logger } from '../core/logger/core.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
@@ -10,10 +10,15 @@ export declare class DevPipeline extends Pipeline {
     readonly settings: AstroSettings;
     readonly config: import("../@types/astro.js").AstroConfig;
     renderers: SSRLoadedRenderer[];
+    manifestData: ManifestData | undefined;
+    componentInterner: WeakMap<RouteData, ComponentInstance>;
     private constructor();
-    static create({ loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
+    static create(manifestData: ManifestData, { loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
     headElements(routeData: RouteData): Promise<HeadElements>;
     componentMetadata(routeData: RouteData): Promise<Map<string, import("../@types/astro.js").SSRComponentMetadata>>;
-    preload(filePath: URL): Promise<ComponentInstance>;
+    preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
     clearRouteCache(): void;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    tryRewrite(payload: RewritePayload): Promise<[RouteData, ComponentInstance]>;
+    setManifestData(manifestData: ManifestData): void;
 }

package/dist/vite-plugin-astro-server/pipeline.js

@@ -1,11 +1,11 @@
-import url from "node:url";
+import { fileURLToPath } from "node:url";
 import { getInfoOutput } from "../cli/info/index.js";
 import { ASTRO_VERSION, DEFAULT_404_COMPONENT } from "../core/constants.js";
 import { enhanceViteSSRError } from "../core/errors/dev/index.js";
-import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { RouteNotFound } from "../core/errors/errors-data.js";
+import { AggregateError, AstroError, CSSError, MarkdownError } from "../core/errors/index.js";
 import { Pipeline, loadRenderer } from "../core/render/index.js";
-import { isPage, resolveIdToUrl, viteID } from "../core/util.js";
-import { isServerLikeOutput } from "../prerender/utils.js";
+import { isPage, isServerLikeOutput, resolveIdToUrl, viteID } from "../core/util.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
 import { getStylesForURL } from "./css.js";
 import { getComponentMetadata } from "./metadata.js";
@@ -28,13 +28,17 @@ class DevPipeline extends Pipeline {
   // renderers are loaded on every request,
   // so it needs to be mutable here unlike in other environments
   renderers = new Array();
-  static create({
+  manifestData;
+  componentInterner = /* @__PURE__ */ new WeakMap();
+  static create(manifestData, {
     loader,
     logger,
     manifest,
     settings
   }) {
-    return new DevPipeline(loader, logger, manifest, settings);
+    const pipeline = new DevPipeline(loader, logger, manifest, settings);
+    pipeline.manifestData = manifestData;
+    return pipeline;
   }
   async headElements(routeData) {
     const {
@@ -43,7 +47,7 @@ class DevPipeline extends Pipeline {
       mode,
       settings
     } = this;
-    const filePath = new URL(`./${routeData.component}`, root);
+    const filePath = new URL(`${routeData.component}`, root);
     const { scripts } = settings.config.experimental.directRenderScript ? { scripts: /* @__PURE__ */ new Set() } : await getScriptsForURL(filePath, settings.config.root, loader);
     if (isPage(filePath, settings) && mode === "development") {
       scripts.add({
@@ -54,7 +58,7 @@ class DevPipeline extends Pipeline {
         const src = await resolveIdToUrl(loader, "astro/runtime/client/dev-toolbar/entrypoint.js");
         scripts.add({ props: { type: "module", src }, children: "" });
         const additionalMetadata = {
-          root: url.fileURLToPath(settings.config.root),
+          root: fileURLToPath(settings.config.root),
           version: ASTRO_VERSION,
           latestAstroVersion: settings.latestAstroVersion,
           debugInfo: await getInfoOutput({ userConfig: settings.config, print: false })
@@ -93,10 +97,10 @@ class DevPipeline extends Pipeline {
       config: { root },
       loader
     } = this;
-    const filePath = new URL(`./${routeData.component}`, root);
+    const filePath = new URL(`${routeData.component}`, root);
     return getComponentMetadata(filePath, loader);
   }
-  async preload(filePath) {
+  async preload(routeData, filePath) {
     const { loader } = this;
     if (filePath.href === new URL(DEFAULT_404_COMPONENT, this.config.root).href) {
       return { default: default404Page };
@@ -105,7 +109,9 @@ class DevPipeline extends Pipeline {
     const renderers_ = await Promise.all(renderers__);
     this.renderers = renderers_.filter((r) => Boolean(r));
     try {
-      return await loader.import(viteID(filePath));
+      const componentInstance = await loader.import(viteID(filePath));
+      this.componentInterner.set(routeData, componentInstance);
+      return componentInstance;
     } catch (error) {
       if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
         throw error;
@@ -115,6 +121,48 @@ class DevPipeline extends Pipeline {
   }
   clearRouteCache() {
     this.routeCache.clearAll();
+    this.componentInterner = /* @__PURE__ */ new WeakMap();
+  }
+  async getComponentByRoute(routeData) {
+    const component = this.componentInterner.get(routeData);
+    if (component) {
+      return component;
+    } else {
+      const filePath = new URL(`${routeData.component}`, this.config.root);
+      return await this.preload(routeData, filePath);
+    }
+  }
+  async tryRewrite(payload) {
+    let foundRoute;
+    if (!this.manifestData) {
+      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
+    }
+    for (const route of this.manifestData.routes) {
+      if (payload instanceof URL) {
+        if (route.pattern.test(payload.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (payload instanceof Request) {
+        const url = new URL(payload.url);
+        if (route.pattern.test(url.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (route.pattern.test(decodeURI(payload))) {
+        foundRoute = route;
+        break;
+      }
+    }
+    if (foundRoute) {
+      const componentInstance = await this.getComponentByRoute(foundRoute);
+      return [foundRoute, componentInstance];
+    } else {
+      throw new AstroError(RouteNotFound);
+    }
+  }
+  setManifestData(manifestData) {
+    this.manifestData = manifestData;
   }
 }
 export {