astro 2.0.17 → 2.1.0

package/dist/content/utils.js

@@ -6,7 +6,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { z } from "zod";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { contentFileExts, CONTENT_TYPES_FILE } from "./consts.js";
+import { CONTENT_TYPES_FILE } from "./consts.js";
 const collectionConfigParser = z.object({
   schema: z.any().optional()
 });
@@ -23,14 +23,29 @@ const contentConfigParser = z.object({
 const msg = {
   collectionConfigMissing: (collection) => `${collection} does not have a config. We suggest adding one for type safety!`
 };
+function extractFrontmatterAssets(data) {
+  function findAssets(potentialAssets) {
+    return Object.values(potentialAssets).reduce((acc, curr) => {
+      if (typeof curr === "object") {
+        if (curr.__astro === true) {
+          acc.push(curr);
+        } else {
+          acc.push(...findAssets(curr));
+        }
+      }
+      return acc;
+    }, []);
+  }
+  return findAssets(data).map((asset) => asset.src);
+}
 function getEntrySlug({
   id,
   collection,
   slug,
-  data: unparsedData
+  unvalidatedSlug
 }) {
   try {
-    return z.string().default(slug).parse(unparsedData.slug);
+    return z.string().default(slug).parse(unvalidatedSlug);
   } catch {
     throw new AstroError({
       ...AstroErrorData.InvalidContentEntrySlugError,
@@ -39,7 +54,7 @@ function getEntrySlug({
   }
 }
 async function getEntryData(entry, collectionConfig) {
-  let { slug, ...data } = entry.data;
+  let { slug, ...data } = entry.unvalidatedData;
   if (collectionConfig.schema) {
     if (typeof collectionConfig.schema === "object" && !("safeParseAsync" in collectionConfig.schema)) {
       throw new AstroError({
@@ -55,7 +70,9 @@ async function getEntryData(entry, collectionConfig) {
         message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
       });
     }
-    const parsed = await collectionConfig.schema.safeParseAsync(entry.data, { errorMap });
+    const parsed = await collectionConfig.schema.safeParseAsync(entry.unvalidatedData, {
+      errorMap
+    });
     if (parsed.success) {
       data = parsed.data;
     } else {
@@ -80,6 +97,9 @@ async function getEntryData(entry, collectionConfig) {
   }
   return data;
 }
+function getContentEntryExts(settings) {
+  return settings.contentEntryTypes.map((t) => t.extensions).flat();
+}
 class NoCollectionError extends Error {
 }
 function getEntryInfo({
@@ -103,7 +123,7 @@ function getEntryInfo({
   };
   return res;
 }
-function getEntryType(entryPath, paths) {
+function getEntryType(entryPath, paths, contentFileExts) {
   const { ext, base } = path.parse(entryPath);
   const fileUrl = pathToFileURL(entryPath);
   if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) || isOnIgnoreList(base)) {
@@ -216,6 +236,7 @@ function getContentPaths({ srcDir, root }, fs = fsMod) {
   return {
     cacheDir: new URL(".astro/", root),
     contentDir: new URL("./content/", srcDir),
+    assetsDir: new URL("./assets/", srcDir),
     typesTemplate: new URL("types.d.ts", templateDir),
     virtualModTemplate: new URL("virtual-mod.mjs", templateDir),
     config: configStats
@@ -237,6 +258,8 @@ export {
   collectionConfigParser,
   contentConfigParser,
   contentObservable,
+  extractFrontmatterAssets,
+  getContentEntryExts,
   getContentPaths,
   getDotAstroTypeReference,
   getEntryData,

package/dist/content/vite-plugin-content-assets.d.ts

@@ -1,8 +1,10 @@
 import type { Plugin } from 'vite';
+import { AstroSettings } from '../@types/astro.js';
 import { BuildInternals } from '../core/build/internal.js';
 import { AstroBuildPlugin } from '../core/build/plugin.js';
 import type { StaticBuildOptions } from '../core/build/types';
-export declare function astroContentAssetPropagationPlugin({ mode }: {
+export declare function astroContentAssetPropagationPlugin({ mode, settings, }: {
     mode: string;
+    settings: AstroSettings;
 }): Plugin;
 export declare function astroConfigBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

package/dist/content/vite-plugin-content-assets.js

@@ -7,18 +7,22 @@ import { prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../core/render/dev/css.js";
 import { getScriptsForURL } from "../core/render/dev/scripts.js";
 import {
-  contentFileExts,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER
 } from "./consts.js";
-function isPropagatedAsset(viteId) {
+import { getContentEntryExts } from "./utils.js";
+function isPropagatedAsset(viteId, contentEntryExts) {
   const url = new URL(viteId, "file://");
-  return url.searchParams.has(PROPAGATED_ASSET_FLAG) && contentFileExts.some((ext) => url.pathname.endsWith(ext));
+  return url.searchParams.has(PROPAGATED_ASSET_FLAG) && contentEntryExts.some((ext) => url.pathname.endsWith(ext));
 }
-function astroContentAssetPropagationPlugin({ mode }) {
+function astroContentAssetPropagationPlugin({
+  mode,
+  settings
+}) {
   let devModuleLoader;
+  const contentEntryExts = getContentEntryExts(settings);
   return {
     name: "astro:content-asset-propagation",
     enforce: "pre",
@@ -28,7 +32,7 @@ function astroContentAssetPropagationPlugin({ mode }) {
       }
     },
     load(id) {
-      if (isPropagatedAsset(id)) {
+      if (isPropagatedAsset(id, contentEntryExts)) {
         const basePath = id.split("?")[0];
         const code = `
 					export async function getMod() {
@@ -45,7 +49,7 @@ function astroContentAssetPropagationPlugin({ mode }) {
       var _a;
       if (!(options == null ? void 0 : options.ssr))
         return;
-      if (devModuleLoader && isPropagatedAsset(id)) {
+      if (devModuleLoader && isPropagatedAsset(id, contentEntryExts)) {
         const basePath = id.split("?")[0];
         if (!((_a = devModuleLoader.getModuleById(basePath)) == null ? void 0 : _a.ssrModule)) {
           await devModuleLoader.import(basePath);

package/dist/content/vite-plugin-content-imports.js

@@ -1,32 +1,42 @@
 import * as devalue from "devalue";
+import { extname } from "node:path";
 import { pathToFileURL } from "url";
+import { normalizePath } from "vite";
 import { AstroErrorData } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/errors.js";
 import { escapeViteEnvReferences, getFileInfo } from "../vite-plugin-utils/index.js";
-import { contentFileExts, CONTENT_FLAG } from "./consts.js";
+import { CONTENT_FLAG } from "./consts.js";
 import {
+  extractFrontmatterAssets,
+  getContentEntryExts,
   getContentPaths,
   getEntryData,
   getEntryInfo,
   getEntrySlug,
   getEntryType,
-  globalContentConfigObserver,
-  parseFrontmatter
+  globalContentConfigObserver
 } from "./utils.js";
-function isContentFlagImport(viteId) {
-  const { pathname, searchParams } = new URL(viteId, "file://");
-  return searchParams.has(CONTENT_FLAG) && contentFileExts.some((ext) => pathname.endsWith(ext));
+function isContentFlagImport(viteId, contentEntryExts) {
+  const { searchParams, pathname } = new URL(viteId, "file://");
+  return searchParams.has(CONTENT_FLAG) && contentEntryExts.some((ext) => pathname.endsWith(ext));
 }
 function astroContentImportPlugin({
   fs,
   settings
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
+  const contentEntryExts = getContentEntryExts(settings);
+  const contentEntryExtToParser = /* @__PURE__ */ new Map();
+  for (const entryType of settings.contentEntryTypes) {
+    for (const ext of entryType.extensions) {
+      contentEntryExtToParser.set(ext, entryType);
+    }
+  }
   return {
     name: "astro:content-imports",
     async load(id) {
       const { fileId } = getFileInfo(id, settings.config);
-      if (isContentFlagImport(id)) {
+      if (isContentFlagImport(id, contentEntryExts)) {
         const observable = globalContentConfigObserver.get();
         if (observable.status === "init") {
           throw new AstroError({
@@ -52,31 +62,48 @@ function astroContentImportPlugin({
           });
         }
         const rawContents = await fs.promises.readFile(fileId, "utf-8");
-        const {
-          content: body,
-          data: unparsedData,
-          matter: rawData = ""
-        } = parseFrontmatter(rawContents, fileId);
-        const entryInfo = getEntryInfo({
+        const fileExt = extname(fileId);
+        if (!contentEntryExtToParser.has(fileExt)) {
+          throw new AstroError({
+            ...AstroErrorData.UnknownContentCollectionError,
+            message: `No parser found for content entry ${JSON.stringify(
+              fileId
+            )}. Did you apply an integration for this file type?`
+          });
+        }
+        const contentEntryParser = contentEntryExtToParser.get(fileExt);
+        const info = await contentEntryParser.getEntryInfo({
+          fileUrl: pathToFileURL(fileId),
+          contents: rawContents
+        });
+        const generatedInfo = getEntryInfo({
           entry: pathToFileURL(fileId),
           contentDir: contentPaths.contentDir
         });
-        if (entryInfo instanceof Error)
+        if (generatedInfo instanceof Error)
           return;
-        const _internal = { filePath: fileId, rawData };
-        const partialEntry = { data: unparsedData, body, _internal, ...entryInfo };
-        const slug = getEntrySlug(partialEntry);
-        const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[entryInfo.collection];
-        const data = collectionConfig ? await getEntryData(partialEntry, collectionConfig) : unparsedData;
+        const _internal = { filePath: fileId, rawData: info.rawData };
+        const slug = getEntrySlug({ ...generatedInfo, unvalidatedSlug: info.slug });
+        const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[generatedInfo.collection];
+        const data = collectionConfig ? await getEntryData(
+          { ...generatedInfo, _internal, unvalidatedData: info.data },
+          collectionConfig
+        ) : info.data;
+        const images = extractFrontmatterAssets(data).map(
+          (image) => `'${image}': await import('${normalizePath(image)}'),`
+        );
         const code = escapeViteEnvReferences(`
-export const id = ${JSON.stringify(entryInfo.id)};
-export const collection = ${JSON.stringify(entryInfo.collection)};
+export const id = ${JSON.stringify(generatedInfo.id)};
+export const collection = ${JSON.stringify(generatedInfo.collection)};
 export const slug = ${JSON.stringify(slug)};
-export const body = ${JSON.stringify(body)};
+export const body = ${JSON.stringify(info.body)};
+const frontmatterImages = {
+	${images.join("\n")}
+}
 export const data = ${devalue.uneval(data)};
 export const _internal = {
-	filePath: ${JSON.stringify(fileId)},
-	rawData: ${JSON.stringify(rawData)},
+	filePath: ${JSON.stringify(_internal.filePath)},
+	rawData: ${JSON.stringify(_internal.rawData)},
 };
 `);
         return { code };
@@ -84,9 +111,9 @@ export const _internal = {
     },
     configureServer(viteServer) {
       viteServer.watcher.on("all", async (event, entry) => {
-        if (["add", "unlink", "change"].includes(event) && getEntryType(entry, contentPaths) === "config") {
+        if (["add", "unlink", "change"].includes(event) && getEntryType(entry, contentPaths, contentEntryExts) === "config") {
           for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
-            if (isContentFlagImport(modUrl)) {
+            if (isContentFlagImport(modUrl, contentEntryExts)) {
               const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
               if (mod) {
                 viteServer.moduleGraph.invalidateModule(mod);
@@ -97,7 +124,7 @@ export const _internal = {
       });
     },
     async transform(code, id) {
-      if (isContentFlagImport(id)) {
+      if (isContentFlagImport(id, contentEntryExts)) {
         return { code: escapeViteEnvReferences(code) };
       }
     }

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -2,8 +2,8 @@ import fsMod from "node:fs";
 import * as path from "node:path";
 import { normalizePath } from "vite";
 import { appendForwardSlash, prependForwardSlash } from "../core/path.js";
-import { contentFileExts, VIRTUAL_MODULE_ID } from "./consts.js";
-import { getContentPaths } from "./utils.js";
+import { VIRTUAL_MODULE_ID } from "./consts.js";
+import { getContentEntryExts, getContentPaths } from "./utils.js";
 function astroContentVirtualModPlugin({
   settings
 }) {
@@ -15,8 +15,11 @@ function astroContentVirtualModPlugin({
       )
     )
   );
-  const entryGlob = `${relContentDir}**/*{${contentFileExts.join(",")}}`;
-  const virtualModContents = fsMod.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("@@ENTRY_GLOB_PATH@@", entryGlob).replace("@@RENDER_ENTRY_GLOB_PATH@@", entryGlob);
+  const contentEntryExts = getContentEntryExts(settings);
+  const assetsDir = settings.config.experimental.assets ? contentPaths.assetsDir.toString() : "undefined";
+  const extGlob = contentEntryExts.length === 1 ? contentEntryExts[0] : `{${contentEntryExts.join(",")}}`;
+  const entryGlob = `${relContentDir}**/*${extGlob}`;
+  const virtualModContents = fsMod.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("@@ASSETS_DIR@@", assetsDir).replace("@@ENTRY_GLOB_PATH@@", entryGlob).replace("@@RENDER_ENTRY_GLOB_PATH@@", entryGlob);
   const astroContentVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
   return {
     name: "astro-content-virtual-mod-plugin",

package/dist/core/add/index.js

@@ -421,7 +421,8 @@ async function updateAstroConfig({
   let output = await generate(ast);
   const comment = "// https://astro.build/config";
   const defaultExport = "export default defineConfig";
-  output = output.replace(` ${comment}`, "");
+  output = output.replace(`
+${comment}`, "");
   output = output.replace(`${defaultExport}`, `
 ${comment}
 ${defaultExport}`);

package/dist/core/app/index.js

@@ -1,26 +1,3 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _base, _baseWithoutTrailingSlash, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
 import { attachToResponse, getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
@@ -42,28 +19,26 @@ import { deserializeManifest } from "./common.js";
 const pagesVirtualModuleId = "@astrojs-pages-virtual-entry";
 const resolvedPagesVirtualModuleId = "\0" + pagesVirtualModuleId;
 class App {
+  #env;
+  #manifest;
+  #manifestData;
+  #routeDataToRouteInfo;
+  #encoder = new TextEncoder();
+  #logging = {
+    dest: consoleLogDestination,
+    level: "info"
+  };
+  #base;
+  #baseWithoutTrailingSlash;
   constructor(manifest, streaming = true) {
-    __privateAdd(this, _renderPage);
-    __privateAdd(this, _callEndpoint);
-    __privateAdd(this, _env, void 0);
-    __privateAdd(this, _manifest, void 0);
-    __privateAdd(this, _manifestData, void 0);
-    __privateAdd(this, _routeDataToRouteInfo, void 0);
-    __privateAdd(this, _encoder, new TextEncoder());
-    __privateAdd(this, _logging, {
-      dest: consoleLogDestination,
-      level: "info"
-    });
-    __privateAdd(this, _base, void 0);
-    __privateAdd(this, _baseWithoutTrailingSlash, void 0);
-    __privateSet(this, _manifest, manifest);
-    __privateSet(this, _manifestData, {
+    this.#manifest = manifest;
+    this.#manifestData = {
       routes: manifest.routes.map((route) => route.routeData)
-    });
-    __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
-    __privateSet(this, _env, createEnvironment({
+    };
+    this.#routeDataToRouteInfo = new Map(manifest.routes.map((route) => [route.routeData, route]));
+    this.#env = createEnvironment({
       adapterName: manifest.adapterName,
-      logging: __privateGet(this, _logging),
+      logging: this.#logging,
       markdown: manifest.markdown,
       mode: "production",
       renderers: manifest.renderers,
@@ -82,33 +57,33 @@ class App {
           }
         }
       },
-      routeCache: new RouteCache(__privateGet(this, _logging)),
-      site: __privateGet(this, _manifest).site,
+      routeCache: new RouteCache(this.#logging),
+      site: this.#manifest.site,
       ssr: true,
       streaming
-    }));
-    __privateSet(this, _base, __privateGet(this, _manifest).base || "/");
-    __privateSet(this, _baseWithoutTrailingSlash, removeTrailingForwardSlash(__privateGet(this, _base)));
+    });
+    this.#base = this.#manifest.base || "/";
+    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#base);
   }
   removeBase(pathname) {
-    if (pathname.startsWith(__privateGet(this, _base))) {
-      return pathname.slice(__privateGet(this, _baseWithoutTrailingSlash).length + 1);
+    if (pathname.startsWith(this.#base)) {
+      return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
     }
     return pathname;
   }
   match(request, { matchNotFound = false } = {}) {
     const url = new URL(request.url);
-    if (__privateGet(this, _manifest).assets.has(url.pathname)) {
+    if (this.#manifest.assets.has(url.pathname)) {
       return void 0;
     }
     let pathname = "/" + this.removeBase(url.pathname);
-    let routeData = matchRoute(pathname, __privateGet(this, _manifestData));
+    let routeData = matchRoute(pathname, this.#manifestData);
     if (routeData) {
       if (routeData.prerender)
         return void 0;
       return routeData;
     } else if (matchNotFound) {
-      return matchRoute("/404", __privateGet(this, _manifestData));
+      return matchRoute("/404", this.#manifestData);
     } else {
       return void 0;
     }
@@ -131,15 +106,20 @@ class App {
     if (routeData.route === "/404") {
       defaultStatus = 404;
     }
-    let mod = __privateGet(this, _manifest).pageMap.get(routeData.component);
+    let mod = this.#manifest.pageMap.get(routeData.component);
     if (routeData.type === "page") {
-      let response = await __privateMethod(this, _renderPage, renderPage_fn).call(this, request, routeData, mod, defaultStatus);
+      let response = await this.#renderPage(request, routeData, mod, defaultStatus);
       if (response.status === 500) {
-        const fiveHundredRouteData = matchRoute("/500", __privateGet(this, _manifestData));
+        const fiveHundredRouteData = matchRoute("/500", this.#manifestData);
         if (fiveHundredRouteData) {
-          mod = __privateGet(this, _manifest).pageMap.get(fiveHundredRouteData.component);
+          mod = this.#manifest.pageMap.get(fiveHundredRouteData.component);
           try {
-            let fiveHundredResponse = await __privateMethod(this, _renderPage, renderPage_fn).call(this, request, fiveHundredRouteData, mod, 500);
+            let fiveHundredResponse = await this.#renderPage(
+              request,
+              fiveHundredRouteData,
+              mod,
+              500
+            );
             return fiveHundredResponse;
           } catch {
           }
@@ -147,7 +127,7 @@ class App {
       }
       return response;
     } else if (routeData.type === "endpoint") {
-      return __privateMethod(this, _callEndpoint, callEndpoint_fn).call(this, request, routeData, mod, defaultStatus);
+      return this.#callEndpoint(request, routeData, mod, defaultStatus);
     } else {
       throw new Error(`Unsupported route type [${routeData.type}].`);
     }
@@ -155,96 +135,86 @@ class App {
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
-}
-_env = new WeakMap();
-_manifest = new WeakMap();
-_manifestData = new WeakMap();
-_routeDataToRouteInfo = new WeakMap();
-_encoder = new WeakMap();
-_logging = new WeakMap();
-_base = new WeakMap();
-_baseWithoutTrailingSlash = new WeakMap();
-_renderPage = new WeakSet();
-renderPage_fn = async function(request, routeData, mod, status = 200) {
-  const url = new URL(request.url);
-  const pathname = "/" + this.removeBase(url.pathname);
-  const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
-  const links = createLinkStylesheetElementSet(info.links);
-  let scripts = /* @__PURE__ */ new Set();
-  for (const script of info.scripts) {
-    if ("stage" in script) {
-      if (script.stage === "head-inline") {
-        scripts.add({
-          props: {},
-          children: script.children
-        });
+  async #renderPage(request, routeData, mod, status = 200) {
+    const url = new URL(request.url);
+    const pathname = "/" + this.removeBase(url.pathname);
+    const info = this.#routeDataToRouteInfo.get(routeData);
+    const links = createLinkStylesheetElementSet(info.links);
+    let scripts = /* @__PURE__ */ new Set();
+    for (const script of info.scripts) {
+      if ("stage" in script) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.children
+          });
+        }
+      } else {
+        scripts.add(createModuleScriptElement(script));
       }
-    } else {
-      scripts.add(createModuleScriptElement(script));
+    }
+    try {
+      const ctx = createRenderContext({
+        request,
+        origin: url.origin,
+        pathname,
+        propagation: this.#manifest.propagation,
+        scripts,
+        links,
+        route: routeData,
+        status
+      });
+      const response = await renderPage(mod, ctx, this.#env);
+      return response;
+    } catch (err) {
+      error(this.#logging, "ssr", err.stack || err.message || String(err));
+      return new Response(null, {
+        status: 500,
+        statusText: "Internal server error"
+      });
     }
   }
-  try {
+  async #callEndpoint(request, routeData, mod, status = 200) {
+    const url = new URL(request.url);
+    const pathname = "/" + this.removeBase(url.pathname);
+    const handler = mod;
     const ctx = createRenderContext({
       request,
       origin: url.origin,
       pathname,
-      propagation: __privateGet(this, _manifest).propagation,
-      scripts,
-      links,
       route: routeData,
       status
     });
-    const response = await renderPage(mod, ctx, __privateGet(this, _env));
-    return response;
-  } catch (err) {
-    error(__privateGet(this, _logging), "ssr", err.stack || err.message || String(err));
-    return new Response(null, {
-      status: 500,
-      statusText: "Internal server error"
-    });
-  }
-};
-_callEndpoint = new WeakSet();
-callEndpoint_fn = async function(request, routeData, mod, status = 200) {
-  const url = new URL(request.url);
-  const pathname = "/" + this.removeBase(url.pathname);
-  const handler = mod;
-  const ctx = createRenderContext({
-    request,
-    origin: url.origin,
-    pathname,
-    route: routeData,
-    status
-  });
-  const result = await callEndpoint(handler, __privateGet(this, _env), ctx, __privateGet(this, _logging));
-  if (result.type === "response") {
-    if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
-      const fourOhFourRequest = new Request(new URL("/404", request.url));
-      const fourOhFourRouteData = this.match(fourOhFourRequest);
-      if (fourOhFourRouteData) {
-        return this.render(fourOhFourRequest, fourOhFourRouteData);
+    const result = await callEndpoint(handler, this.#env, ctx, this.#logging);
+    if (result.type === "response") {
+      if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
+        const fourOhFourRequest = new Request(new URL("/404", request.url));
+        const fourOhFourRouteData = this.match(fourOhFourRequest);
+        if (fourOhFourRouteData) {
+          return this.render(fourOhFourRequest, fourOhFourRouteData);
+        }
       }
-    }
-    return result.response;
-  } else {
-    const body = result.body;
-    const headers = new Headers();
-    const mimeType = mime.getType(url.pathname);
-    if (mimeType) {
-      headers.set("Content-Type", `${mimeType};charset=utf-8`);
+      return result.response;
     } else {
-      headers.set("Content-Type", "text/plain;charset=utf-8");
+      const body = result.body;
+      const headers = new Headers();
+      const mimeType = mime.getType(url.pathname);
+      if (mimeType) {
+        headers.set("Content-Type", `${mimeType};charset=utf-8`);
+      } else {
+        headers.set("Content-Type", "text/plain;charset=utf-8");
+      }
+      const bytes = this.#encoder.encode(body);
+      headers.set("Content-Length", bytes.byteLength.toString());
+      const response = new Response(bytes, {
+        status: 200,
+        headers
+      });
+      attachToResponse(response, result.cookies);
+      return response;
     }
-    const bytes = __privateGet(this, _encoder).encode(body);
-    headers.set("Content-Length", bytes.byteLength.toString());
-    const response = new Response(bytes, {
-      status: 200,
-      headers
-    });
-    attachToResponse(response, result.cookies);
-    return response;
   }
-};
+}
 export {
   App,
   deserializeManifest,