cloudcommerce 0.26.3 → 0.26.4

package/packages/storefront/dist/server/chunks/{astro.440a2e08.mjs → astro.708269c6.mjs}

@@ -1,4 +1,12 @@
-import { clsx } from 'clsx';
+import { compile } from 'path-to-regexp';
+import { serialize, parse } from 'cookie';
+import { joinPaths, slash, prependForwardSlash, removeTrailingForwardSlash, collapseDuplicateSlashes } from '@astrojs/internal-helpers/path';
+import { yellow, dim, bold, cyan, red, reset } from 'kleur/colors';
+import 'node:fs';
+import 'node:http';
+import { TLSSocket } from 'node:tls';
+import mime from 'mime';
+import 'string-width';
 import { escape } from 'html-escaper';
 
 const ClientAddressNotAvailable = {
@@ -52,11 +60,11 @@ const NoClientOnlyHint = {
   message: (componentName) => `Unable to render \`${componentName}\`. When using the \`client:only\` hydration strategy, Astro needs a hint to use the correct renderer.`,
   hint: (probableRenderers) => `Did you mean to pass \`client:only="${probableRenderers}"\`? See https://docs.astro.build/en/reference/directives-reference/#clientonly for more information on client:only`
 };
-const InvalidGetStaticPathsEntry = {
-  name: "InvalidGetStaticPathsEntry",
-  title: "Invalid entry inside getStaticPath's return value",
-  message: (entryType) => `Invalid entry returned by getStaticPaths. Expected an object, got \`${entryType}\``,
-  hint: "If you're using a `.map` call, you might be looking for `.flatMap()` instead. See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths."
+const InvalidGetStaticPathParam = {
+  name: "InvalidGetStaticPathParam",
+  title: "Invalid value returned by a `getStaticPaths` path.",
+  message: (paramType) => `Invalid params given to \`getStaticPaths\` path. Expected an \`object\`, got \`${paramType}\``,
+  hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths."
 };
 const InvalidGetStaticPathsReturn = {
   name: "InvalidGetStaticPathsReturn",
@@ -108,48 +116,12 @@ const PageNumberParamNotFound = {
   message: (paramName) => `[paginate()] page number param \`${paramName}\` not found in your filepath.`,
   hint: "Rename your file to `[page].astro` or `[...page].astro`."
 };
-const ImageMissingAlt = {
-  name: "ImageMissingAlt",
-  title: "Missing alt property.",
-  message: "The alt property is required.",
-  hint: "The `alt` property is important for the purpose of accessibility, without it users using screen readers or other assistive technologies won't be able to understand what your image is supposed to represent. See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-alt for more information."
-};
-const InvalidImageService = {
-  name: "InvalidImageService",
-  title: "Error while loading image service.",
-  message: "There was an error loading the configured image service. Please see the stack trace for more information."
-};
-const MissingImageDimension = {
-  name: "MissingImageDimension",
-  title: "Missing image dimensions",
-  message: (missingDimension, imageURL) => `Missing ${missingDimension === "both" ? "width and height attributes" : `${missingDimension} attribute`} for ${imageURL}. When using remote images, both dimensions are always required in order to avoid CLS.`,
-  hint: "If your image is inside your `src` folder, you probably meant to import it instead. See [the Imports guide for more information](https://docs.astro.build/en/guides/imports/#other-assets)."
-};
-const UnsupportedImageFormat = {
-  name: "UnsupportedImageFormat",
-  title: "Unsupported image format",
-  message: (format, imagePath, supportedFormats) => `Received unsupported format \`${format}\` from \`${imagePath}\`. Currently only ${supportedFormats.join(
-    ", "
-  )} are supported by our image services.`,
-  hint: "Using an `img` tag directly instead of the `Image` component might be what you're looking for."
-};
 const PrerenderDynamicEndpointPathCollide = {
   name: "PrerenderDynamicEndpointPathCollide",
   title: "Prerendered dynamic endpoint has path collision.",
   message: (pathname) => `Could not render \`${pathname}\` with an \`undefined\` param as the generated path will collide during prerendering. Prevent passing \`undefined\` as \`params\` for the endpoint's \`getStaticPaths()\` function, or add an additional extension to the endpoint's filename.`,
   hint: (filename) => `Rename \`${filename}\` to \`${filename.replace(/\.(js|ts)/, (m) => `.json` + m)}\``
 };
-const ExpectedImage = {
-  name: "ExpectedImage",
-  title: "Expected src to be an image.",
-  message: (options) => `Expected \`src\` property to be either an ESM imported image or a string with the path of a remote image. Received \`${options}\`.`,
-  hint: "This error can often happen because of a wrong path. Make sure the path to your image is correct."
-};
-const ExpectedImageOptions = {
-  name: "ExpectedImageOptions",
-  title: "Expected image options.",
-  message: (options) => `Expected getImage() parameter to be an object. Received \`${options}\`.`
-};
 const ResponseSentError = {
   name: "ResponseSentError",
   title: "Unable to set response.",
@@ -171,11 +143,6 @@ const LocalsNotAnObject = {
   message: "`locals` can only be assigned to an object. Other values like numbers, strings, etc. are not accepted.",
   hint: "If you tried to remove some information from the `locals` object, try to use `delete` or set the property to `undefined`."
 };
-const LocalImageUsedWrongly = {
-  name: "LocalImageUsedWrongly",
-  title: "ESM imported images must be passed as-is.",
-  message: (imageFilePath) => `\`Image\`'s and \`getImage\`'s \`src\` parameter must be an imported image or an URL, it cannot be a filepath. Received \`${imageFilePath}\`.`
-};
 const AstroGlobUsedOutside = {
   name: "AstroGlobUsedOutside",
   title: "Astro.glob() used outside of an Astro file.",
@@ -187,12 +154,6 @@ const AstroGlobNoMatch = {
   title: "Astro.glob() did not match any files.",
   message: (globStr) => `\`Astro.glob(${globStr})\` did not return any matching files. Check the pattern for typos.`
 };
-const MissingSharp = {
-  name: "MissingSharp",
-  title: "Could not find Sharp.",
-  message: "Could not find Sharp. Please install Sharp (`sharp`) manually into your project.",
-  hint: "See Sharp's installation instructions for more information: https://sharp.pixelplumbing.com/install. If you are not relying on `astro:assets` to optimize, transform, or process any images, you can configure a passthrough image service instead of installing Sharp. See https://docs.astro.build/en/reference/errors/missing-sharp for more information."
-};
 
 function normalizeLF(code) {
   return code.replace(/\r\n|\r(?!\n)|\n/g, "\n");
@@ -230,13 +191,9 @@ function codeFrame(src, loc) {
 }
 
 class AstroError extends Error {
-  loc;
-  title;
-  hint;
-  frame;
-  type = "AstroError";
   constructor(props, ...params) {
     super(...params);
+    this.type = "AstroError";
     const { name, title, message, stack, location, hint, frame } = props;
     this.title = title;
     this.name = name;
@@ -266,22 +223,6 @@ class AstroError extends Error {
     return err.type === "AstroError";
   }
 }
-class AstroUserError extends Error {
-  type = "AstroUserError";
-  /**
-   * A message that explains to the user how they can fix the error.
-   */
-  hint;
-  name = "AstroUserError";
-  constructor(message, hint) {
-    super();
-    this.message = message;
-    this.hint = hint;
-  }
-  static is(err) {
-    return err.type === "AstroUserError";
-  }
-}
 
 function validateArgs(args) {
   if (args.length !== 3)
@@ -291,7 +232,8 @@ function validateArgs(args) {
   return true;
 }
 function baseCreateComponent(cb, moduleId, propagation) {
-  const name = moduleId?.split("/").pop()?.replace(".astro", "") ?? "";
+  var _a;
+  const name = ((_a = moduleId == null ? void 0 : moduleId.split("/").pop()) == null ? void 0 : _a.replace(".astro", "")) ?? "";
   const fn = (...args) => {
     if (!validateArgs(args)) {
       throw new AstroError({
@@ -319,7 +261,7 @@ function createComponent(arg1, moduleId, propagation) {
   }
 }
 
-const ASTRO_VERSION = "3.0.5";
+const ASTRO_VERSION = "2.10.15";
 
 function createAstroGlobFn() {
   const globHandler = (importMetaGlobResult) => {
@@ -348,36 +290,24 @@ function createAstro(site) {
   };
 }
 
-function getHandlerFromModule(mod, method, logger) {
-  const lowerCaseMethod = method.toLowerCase();
-  if (mod[lowerCaseMethod]) {
-    logger.warn(
-      "astro",
-      `Lower case endpoint names are deprecated and will not be supported in Astro 4.0. Rename the endpoint ${lowerCaseMethod} to ${method}.`
-    );
-  }
+function getHandlerFromModule(mod, method) {
   if (mod[method]) {
     return mod[method];
   }
-  if (mod[lowerCaseMethod]) {
-    return mod[lowerCaseMethod];
-  }
   if (method === "delete" && mod["del"]) {
     return mod["del"];
   }
   if (mod["all"]) {
     return mod["all"];
   }
-  if (mod["ALL"]) {
-    return mod["ALL"];
-  }
   return void 0;
 }
-async function renderEndpoint(mod, context, ssr, logger) {
-  const { request } = context;
-  const chosenMethod = request.method?.toUpperCase();
-  const handler = getHandlerFromModule(mod, chosenMethod, logger);
-  if (!ssr && ssr === false && chosenMethod && chosenMethod !== "GET" && chosenMethod !== "get") {
+async function renderEndpoint(mod, context, ssr) {
+  var _a;
+  const { request, params } = context;
+  const chosenMethod = (_a = request.method) == null ? void 0 : _a.toLowerCase();
+  const handler = getHandlerFromModule(mod, chosenMethod);
+  if (!ssr && ssr === false && chosenMethod && chosenMethod !== "get") {
     console.warn(`
 ${chosenMethod} requests are not available when building a static site. Update your config to \`output: 'server'\` or \`output: 'hybrid'\` with an \`export const prerender = false\` to handle ${chosenMethod} requests.`);
   }
@@ -390,10 +320,30 @@ ${chosenMethod} requests are not available when building a static site. Update y
     });
     return response;
   }
+  if (handler.length > 1) {
+    console.warn(`
+API routes with 2 arguments have been deprecated. Instead they take a single argument in the form of:
+
+export function get({ params, request }) {
+	//...
+}
+
+Update your code to remove this warning.`);
+  }
   const proxy = new Proxy(context, {
     get(target, prop) {
       if (prop in target) {
         return Reflect.get(target, prop);
+      } else if (prop in params) {
+        console.warn(`
+API routes no longer pass params as the first argument. Instead an object containing a params property is provided in the form of:
+
+export function get({ params }) {
+	// ...
+}
+
+Update your code to remove this warning.`);
+        return Reflect.get(params, prop);
       } else {
         return void 0;
       }
@@ -402,6 +352,28 @@ ${chosenMethod} requests are not available when building a static site. Update y
   return handler.call(mod, proxy, request);
 }
 
+function serializeListValue(value) {
+  const hash = {};
+  push(value);
+  return Object.keys(hash).join(" ");
+  function push(item) {
+    if (item && typeof item.forEach === "function")
+      item.forEach(push);
+    else if (item === Object(item))
+      Object.keys(item).forEach((name) => {
+        if (item[name])
+          push(name);
+      });
+    else {
+      item = item === false || item == null ? "" : String(item).trim();
+      if (item) {
+        item.split(/\s+/).forEach((name) => {
+          hash[name] = true;
+        });
+      }
+    }
+  }
+}
 function isPromise(value) {
   return !!value && typeof value === "object" && typeof value.then === "function";
 }
@@ -486,11 +458,6 @@ function unescapeHTML(str) {
   return markHTMLString(str);
 }
 
-const AstroJSX = "astro:jsx";
-function isVNode(vnode) {
-  return vnode && typeof vnode === "object" && vnode[AstroJSX];
-}
-
 const RenderInstructionSymbol = Symbol.for("astro:render");
 function createRenderInstruction(instruction) {
   return Object.defineProperty(instruction, RenderInstructionSymbol, {
@@ -647,6 +614,10 @@ function extractDirectives(inputProps, clientDirectives) {
           break;
         }
       }
+    } else if (key === "class:list") {
+      if (value) {
+        extracted.props[key.slice(0, -5)] = serializeListValue(value);
+      }
     } else {
       extracted.props[key] = value;
     }
@@ -778,7 +749,7 @@ function isHeadAndContent(obj) {
   return typeof obj === "object" && !!obj[headAndContentSym];
 }
 
-var astro_island_prebuilt_default = `(()=>{var b=Object.defineProperty;var f=(a,s,i)=>s in a?b(a,s,{enumerable:!0,configurable:!0,writable:!0,value:i}):a[s]=i;var d=(a,s,i)=>(f(a,typeof s!="symbol"?s+"":s,i),i);var u;{let a={0:t=>m(t),1:t=>i(t),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(i(t)),5:t=>new Set(i(t)),6:t=>BigInt(t),7:t=>new URL(t),8:t=>new Uint8Array(t),9:t=>new Uint16Array(t),10:t=>new Uint32Array(t)},s=t=>{let[e,r]=t;return e in a?a[e](r):void 0},i=t=>t.map(s),m=t=>typeof t!="object"||t===null?t:Object.fromEntries(Object.entries(t).map(([e,r])=>[e,s(r)]));customElements.get("astro-island")||customElements.define("astro-island",(u=class extends HTMLElement{constructor(){super(...arguments);d(this,"Component");d(this,"hydrator");d(this,"hydrate",async()=>{var l;if(!this.hydrator||!this.isConnected)return;let e=(l=this.parentElement)==null?void 0:l.closest("astro-island[ssr]");if(e){e.addEventListener("astro:hydrate",this.hydrate,{once:!0});return}let r=this.querySelectorAll("astro-slot"),c={},h=this.querySelectorAll("template[data-astro-template]");for(let n of h){let o=n.closest(this.tagName);o!=null&&o.isSameNode(this)&&(c[n.getAttribute("data-astro-template")||"default"]=n.innerHTML,n.remove())}for(let n of r){let o=n.closest(this.tagName);o!=null&&o.isSameNode(this)&&(c[n.getAttribute("name")||"default"]=n.innerHTML)}let p;try{p=this.hasAttribute("props")?m(JSON.parse(this.getAttribute("props"))):{}}catch(n){let o=this.getAttribute("component-url")||"<unknown>",y=this.getAttribute("component-export");throw y&&(o+=\` (export \${y})\`),console.error(\`[hydrate] Error parsing props for component \${o}\`,this.getAttribute("props"),n),n}await this.hydrator(this)(this.Component,p,c,{client:this.getAttribute("client")}),this.removeAttribute("ssr"),this.dispatchEvent(new CustomEvent("astro:hydrate"))});d(this,"unmount",()=>{this.isConnected||this.dispatchEvent(new CustomEvent("astro:unmount"))})}disconnectedCallback(){document.removeEventListener("astro:after-swap",this.unmount),document.addEventListener("astro:after-swap",this.unmount,{once:!0})}connectedCallback(){!this.hasAttribute("await-children")||this.firstChild?this.childrenConnectedCallback():new MutationObserver((e,r)=>{r.disconnect(),setTimeout(()=>this.childrenConnectedCallback(),0)}).observe(this,{childList:!0})}async childrenConnectedCallback(){let e=this.getAttribute("before-hydration-url");e&&await import(e),this.start()}start(){let e=JSON.parse(this.getAttribute("opts")),r=this.getAttribute("client");if(Astro[r]===void 0){window.addEventListener(\`astro:\${r}\`,()=>this.start(),{once:!0});return}Astro[r](async()=>{let c=this.getAttribute("renderer-url"),[h,{default:p}]=await Promise.all([import(this.getAttribute("component-url")),c?import(c):()=>()=>{}]),l=this.getAttribute("component-export")||"default";if(!l.includes("."))this.Component=h[l];else{this.Component=h;for(let n of l.split("."))this.Component=this.Component[n]}return this.hydrator=p,this.hydrate},e,this)}attributeChangedCallback(){this.hydrate()}},d(u,"observedAttributes",["props"]),u))}})();`;
+var astro_island_prebuilt_default = `(()=>{var d;{let p={0:t=>u(t),1:t=>l(t),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(l(t)),5:t=>new Set(l(t)),6:t=>BigInt(t),7:t=>new URL(t),8:t=>new Uint8Array(t),9:t=>new Uint16Array(t),10:t=>new Uint32Array(t)},h=t=>{let[e,n]=t;return e in p?p[e](n):void 0},l=t=>t.map(h),u=t=>typeof t!="object"||t===null?t:Object.fromEntries(Object.entries(t).map(([e,n])=>[e,h(n)]));customElements.get("astro-island")||customElements.define("astro-island",(d=class extends HTMLElement{constructor(){super(...arguments);this.hydrate=async()=>{var i;if(!this.hydrator||!this.isConnected)return;let e=(i=this.parentElement)==null?void 0:i.closest("astro-island[ssr]");if(e){e.addEventListener("astro:hydrate",this.hydrate,{once:!0});return}let n=this.querySelectorAll("astro-slot"),o={},a=this.querySelectorAll("template[data-astro-template]");for(let r of a){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(o[r.getAttribute("data-astro-template")||"default"]=r.innerHTML,r.remove())}for(let r of n){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(o[r.getAttribute("name")||"default"]=r.innerHTML)}let c;try{c=this.hasAttribute("props")?u(JSON.parse(this.getAttribute("props"))):{}}catch(r){let s=this.getAttribute("component-url")||"<unknown>",y=this.getAttribute("component-export");throw y&&(s+=\` (export \${y})\`),console.error(\`[hydrate] Error parsing props for component \${s}\`,this.getAttribute("props"),r),r}await this.hydrator(this)(this.Component,c,o,{client:this.getAttribute("client")}),this.removeAttribute("ssr"),this.dispatchEvent(new CustomEvent("astro:hydrate"))}}connectedCallback(){!this.hasAttribute("await-children")||this.firstChild?this.childrenConnectedCallback():new MutationObserver((e,n)=>{n.disconnect(),setTimeout(()=>this.childrenConnectedCallback(),0)}).observe(this,{childList:!0})}async childrenConnectedCallback(){let e=this.getAttribute("before-hydration-url");e&&await import(e),this.start()}start(){let e=JSON.parse(this.getAttribute("opts")),n=this.getAttribute("client");if(Astro[n]===void 0){window.addEventListener(\`astro:\${n}\`,()=>this.start(),{once:!0});return}Astro[n](async()=>{let o=this.getAttribute("renderer-url"),[a,{default:c}]=await Promise.all([import(this.getAttribute("component-url")),o?import(o):()=>()=>{}]),i=this.getAttribute("component-export")||"default";if(!i.includes("."))this.Component=a[i];else{this.Component=a;for(let r of i.split("."))this.Component=this.Component[r]}return this.hydrator=c,this.hydrate},e,this)}attributeChangedCallback(){this.hydrate()}},d.observedAttributes=["props"],d))}})();`;
 
 const ISLAND_STYLES = `<style>astro-island,astro-slot,astro-static-slot{display:contents}</style>`;
 function determineIfNeedsHydrationScript(result) {
@@ -830,12 +801,15 @@ const kebab = (k) => k.toLowerCase() === k ? k : k.replace(/[A-Z]/g, (match) =>
 const toStyleString = (obj) => Object.entries(obj).map(([k, v]) => {
   if (k[0] !== "-" && k[1] !== "-")
     return `${kebab(k)}:${v}`;
+  if (kebab(k) !== k)
+    return `${kebab(k)}:var(${k});${k}:${v}`;
   return `${k}:${v}`;
 }).join(";");
 function defineScriptVars(vars) {
+  var _a;
   let output = "";
   for (const [key, value] of Object.entries(vars)) {
-    output += `const ${toIdent(key)} = ${JSON.stringify(value)?.replace(
+    output += `const ${toIdent(key)} = ${(_a = JSON.stringify(value)) == null ? void 0 : _a.replace(
       /<\/script>/g,
       "\\x3C/script>"
     )};
@@ -866,7 +840,7 @@ Make sure to use the static attribute syntax (\`${key}={value}\`) instead of the
     return "";
   }
   if (key === "class:list") {
-    const listValue = toAttributeString(clsx(value), shouldEscape);
+    const listValue = toAttributeString(serializeListValue(value), shouldEscape);
     if (listValue === "") {
       return "";
     }
@@ -961,8 +935,6 @@ function* maybeRenderHead() {
 
 const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
-  instructions;
-  [slotString];
   constructor(content, instructions) {
     super(content);
     this.instructions = instructions;
@@ -1130,15 +1102,11 @@ async function renderChild(destination, child) {
   }
 }
 
+var _a$1;
 const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
 class AstroComponentInstance {
-  [astroComponentInstanceSym] = true;
-  result;
-  props;
-  slotValues;
-  factory;
-  returnValue;
   constructor(result, props, slots, factory) {
+    this[_a$1] = true;
     this.result = result;
     this.props = props;
     this.factory = factory;
@@ -1169,6 +1137,7 @@ class AstroComponentInstance {
     }
   }
 }
+_a$1 = astroComponentInstanceSym;
 function validateComponentProps(props, displayName) {
   if (props != null) {
     for (const prop of Object.keys(props)) {
@@ -1192,13 +1161,11 @@ function isAstroComponentInstance(obj) {
   return typeof obj === "object" && !!obj[astroComponentInstanceSym];
 }
 
+var _a;
 const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
 class RenderTemplateResult {
-  [renderTemplateResultSym] = true;
-  htmlParts;
-  expressions;
-  error;
   constructor(htmlParts, expressions) {
+    this[_a] = true;
     this.htmlParts = htmlParts;
     this.error = void 0;
     this.expressions = expressions.map((expression) => {
@@ -1231,6 +1198,7 @@ class RenderTemplateResult {
     }
   }
 }
+_a = renderTemplateResultSym;
 function isRenderTemplateResult(obj) {
   return typeof obj === "object" && !!obj[renderTemplateResultSym];
 }
@@ -1308,7 +1276,7 @@ async function renderToReadableStream(result, componentFactory, props, children,
         } catch (e) {
           if (AstroError.is(e) && !e.loc) {
             e.setLocation({
-              file: route?.component
+              file: route == null ? void 0 : route.component
             });
           }
           setTimeout(() => controller.error(e), 0);
@@ -1324,9 +1292,9 @@ async function callComponentAsTemplateResultOrResponse(result, componentFactory,
   } else if (!isRenderTemplateResult(factoryResult)) {
     throw new AstroError({
       ...OnlyResponseCanBeReturned,
-      message: OnlyResponseCanBeReturned.message(route?.route, typeof factoryResult),
+      message: OnlyResponseCanBeReturned.message(route == null ? void 0 : route.route, typeof factoryResult),
       location: {
-        file: route?.component
+        file: route == null ? void 0 : route.component
       }
     });
   }
@@ -1356,7 +1324,7 @@ async function renderHTMLElement(result, constructor, props, slots) {
     attrHTML += ` ${attr}="${toAttributeString(await props[attr])}"`;
   }
   return markHTMLString(
-    `<${name}${attrHTML}>${await renderSlotToString(result, slots?.default)}</${name}>`
+    `<${name}${attrHTML}>${await renderSlotToString(result, slots == null ? void 0 : slots.default)}</${name}>`
   );
 }
 function getHTMLElementName(constructor) {
@@ -1370,7 +1338,7 @@ function getHTMLElementName(constructor) {
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
 const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]);
 function guessRenderers(componentUrl) {
-  const extname = componentUrl?.split(".").pop();
+  const extname = componentUrl == null ? void 0 : componentUrl.split(".").pop();
   switch (extname) {
     case "svelte":
       return ["@astrojs/svelte"];
@@ -1403,6 +1371,7 @@ function removeStaticAstroSlot(html, supportsAstroStaticSlot) {
   return html.replace(exp, "");
 }
 async function renderFrameworkComponent(result, displayName, Component, _props, slots = {}) {
+  var _a, _b, _c;
   if (!Component && !_props["client:only"]) {
     throw new Error(
       `Unable to render ${displayName} because it is ${Component}!
@@ -1478,7 +1447,7 @@ Did you forget to import the component or is it possible there is a typo?`
       renderer = validRenderers[0];
     }
     if (!renderer) {
-      const extname = metadata.componentUrl?.split(".").pop();
+      const extname = (_a = metadata.componentUrl) == null ? void 0 : _a.split(".").pop();
       renderer = renderers.filter(
         ({ name }) => name === `@astrojs/${extname}` || name === extname
       )[0];
@@ -1503,7 +1472,7 @@ Did you forget to import the component or is it possible there is a typo?`
           ...NoMatchingRenderer,
           message: NoMatchingRenderer.message(
             metadata.displayName,
-            metadata?.componentUrl?.split(".").pop(),
+            (_b = metadata == null ? void 0 : metadata.componentUrl) == null ? void 0 : _b.split(".").pop(),
             plural,
             validRenderers.length
           ),
@@ -1536,7 +1505,7 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
     }
   } else {
     if (metadata.hydrate === "only") {
-      html = await renderSlotToString(result, slots?.fallback);
+      html = await renderSlotToString(result, slots == null ? void 0 : slots.fallback);
     } else {
       ({ html, attrs } = await renderer.ssr.renderToStaticMarkup.call(
         { result },
@@ -1578,17 +1547,18 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
   if (!hydration) {
     return {
       render(destination) {
+        var _a2;
         if (slotInstructions) {
           for (const instruction of slotInstructions) {
             destination.write(instruction);
           }
         }
-        if (isPage || renderer?.name === "astro:jsx") {
+        if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") {
           destination.write(html);
         } else if (html && html.length > 0) {
           destination.write(
             markHTMLString(
-              removeStaticAstroSlot(html, renderer?.ssr?.supportsAstroStaticSlot ?? false)
+              removeStaticAstroSlot(html, ((_a2 = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _a2.supportsAstroStaticSlot) ?? false)
             )
           );
         }
@@ -1611,7 +1581,7 @@ ${serializeProps(
   if (html) {
     if (Object.keys(children).length > 0) {
       for (const key of Object.keys(children)) {
-        let tagName = renderer?.ssr?.supportsAstroStaticSlot ? !!metadata.hydrate ? "astro-slot" : "astro-static-slot" : "astro-slot";
+        let tagName = ((_c = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _c.supportsAstroStaticSlot) ? !!metadata.hydrate ? "astro-slot" : "astro-static-slot" : "astro-slot";
         let expectedHTML = key === "default" ? `<${tagName}>` : `<${tagName} name="${key}">`;
         if (!html.includes(expectedHTML)) {
           unrenderedSlots.push(key);
@@ -1647,7 +1617,7 @@ function sanitizeElementName(tag) {
   return tag.trim().split(unsafe)[0].trim();
 }
 async function renderFragmentComponent(result, slots = {}) {
-  const children = await renderSlotToString(result, slots?.default);
+  const children = await renderSlotToString(result, slots == null ? void 0 : slots.default);
   return {
     render(destination) {
       if (children == null)
@@ -1681,7 +1651,6 @@ async function renderComponent(result, displayName, Component, props, slots = {}
   if (isFragmentComponent(Component)) {
     return await renderFragmentComponent(result, slots);
   }
-  props = normalizeProps(props);
   if (isHTMLComponent(Component)) {
     return await renderHTMLComponent(result, Component, props, slots);
   }
@@ -1690,17 +1659,6 @@ async function renderComponent(result, displayName, Component, props, slots = {}
   }
   return await renderFrameworkComponent(result, displayName, Component, props, slots);
 }
-function normalizeProps(props) {
-  if (props["class:list"] !== void 0) {
-    const value = props["class:list"];
-    delete props["class:list"];
-    props["class"] = clsx(props["class"], value);
-    if (props["class"] === "") {
-      delete props["class"];
-    }
-  }
-  return props;
-}
 async function renderComponentToString(result, displayName, Component, props, slots = {}, isPage = false, route) {
   let str = "";
   let renderedFirstPageChunk = false;
@@ -1730,7 +1688,7 @@ async function renderComponentToString(result, displayName, Component, props, sl
   } catch (e) {
     if (AstroError.is(e) && !e.loc) {
       e.setLocation({
-        file: route?.component
+        file: route == null ? void 0 : route.component
       });
     }
     throw e;
@@ -1738,7 +1696,7 @@ async function renderComponentToString(result, displayName, Component, props, sl
   return str;
 }
 function nonAstroPageNeedsHeadInjection(pageComponent) {
-  return !!pageComponent?.[needsHeadRenderingSymbol];
+  return !!(pageComponent == null ? void 0 : pageComponent[needsHeadRenderingSymbol]);
 }
 
 const ClientOnlyPlaceholder = "astro-client-only";
@@ -1747,7 +1705,6 @@ class Skip {
     this.vnode = vnode;
     this.count = 0;
   }
-  count;
   increment() {
     this.count++;
   }
@@ -1757,8 +1714,8 @@ class Skip {
   isCompleted() {
     return this.count > 2;
   }
-  static symbol = Symbol("astro:jsx:skip");
 }
+Skip.symbol = Symbol("astro:jsx:skip");
 let originalConsoleError;
 let consoleFilterRefs = 0;
 async function renderJSX(result, vnode) {
@@ -1851,7 +1808,7 @@ Did you forget to import the component or is it possible there is a typo?`);
           try {
             const output2 = await vnode.type(vnode.props ?? {});
             let renderResult;
-            if (output2?.[AstroJSX]) {
+            if (output2 == null ? void 0 : output2[AstroJSX]) {
               renderResult = await renderJSXVNode(result, output2, skip);
               return renderResult;
             } else if (!output2) {
@@ -1953,9 +1910,76 @@ function filteredConsoleError(msg, ...rest) {
   originalConsoleError(msg, ...rest);
 }
 
-async function renderPage(result, componentFactory, props, children, streaming, route) {
+const isNodeJS = typeof process === "object" && Object.prototype.toString.call(process) === "[object process]";
+let StreamingCompatibleResponse;
+function createResponseClass() {
+  StreamingCompatibleResponse = class extends Response {
+    #isStream;
+    #body;
+    constructor(body, init) {
+      let isStream = body instanceof ReadableStream;
+      super(isStream ? null : body, init);
+      this.#isStream = isStream;
+      this.#body = body;
+    }
+    get body() {
+      return this.#body;
+    }
+    async text() {
+      if (this.#isStream && isNodeJS) {
+        let decoder = new TextDecoder();
+        let body = this.#body;
+        let out = "";
+        for await (let chunk of streamAsyncIterator(body)) {
+          out += decoder.decode(chunk);
+        }
+        return out;
+      }
+      return super.text();
+    }
+    async arrayBuffer() {
+      if (this.#isStream && isNodeJS) {
+        let body = this.#body;
+        let chunks = [];
+        let len = 0;
+        for await (let chunk of streamAsyncIterator(body)) {
+          chunks.push(chunk);
+          len += chunk.length;
+        }
+        let ab = new Uint8Array(len);
+        let offset = 0;
+        for (const chunk of chunks) {
+          ab.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return ab;
+      }
+      return super.arrayBuffer();
+    }
+    clone() {
+      return new StreamingCompatibleResponse(this.#body, {
+        status: this.status,
+        statusText: this.statusText,
+        headers: this.headers
+      });
+    }
+  };
+  return StreamingCompatibleResponse;
+}
+const createResponse = isNodeJS ? (body, init) => {
+  if (typeof body === "string" || ArrayBuffer.isView(body)) {
+    return new Response(body, init);
+  }
+  if (typeof StreamingCompatibleResponse === "undefined") {
+    return new (createResponseClass())(body, init);
+  }
+  return new StreamingCompatibleResponse(body, init);
+} : (body, init) => new Response(body, init);
+
+async function renderPage$1(result, componentFactory, props, children, streaming, route) {
+  var _a, _b;
   if (!isAstroComponentFactory(componentFactory)) {
-    result._metadata.headInTree = result.componentMetadata.get(componentFactory.moduleId)?.containsHead ?? false;
+    result._metadata.headInTree = ((_a = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _a.containsHead) ?? false;
     const pageProps = { ...props ?? {}, "server:root": true };
     const str = await renderComponentToString(
       result,
@@ -1974,7 +1998,7 @@ async function renderPage(result, componentFactory, props, children, streaming,
       ])
     });
   }
-  result._metadata.headInTree = result.componentMetadata.get(componentFactory.moduleId)?.containsHead ?? false;
+  result._metadata.headInTree = ((_b = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _b.containsHead) ?? false;
   let body;
   if (streaming) {
     body = await renderToReadableStream(result, componentFactory, props, children, true, route);
@@ -1989,7 +2013,7 @@ async function renderPage(result, componentFactory, props, children, streaming,
     body = encoder.encode(body);
     headers.set("Content-Length", body.byteLength.toString());
   }
-  const response = new Response(body, { ...init, headers });
+  const response = createResponse(body, { ...init, headers });
   return response;
 }
 
@@ -2010,4 +2034,1690 @@ function spreadAttributes(values = {}, _name, { class: scopedClassName } = {}) {
   return markHTMLString(output);
 }
 
-export { AstroError as A, MiddlewareNotAResponse as B, ClientAddressNotAvailable as C, ASTRO_VERSION as D, ExpectedImage as E, Fragment as F, GetStaticPathsRequired as G, renderEndpoint as H, InvalidImageService as I, MissingSharp as J, LocalImageUsedWrongly as L, MissingImageDimension as M, NoMatchingStaticPathFound as N, PageNumberParamNotFound as P, ReservedSlotName as R, StaticClientAddressNotAvailable as S, UnsupportedImageFormat as U, ExpectedImageOptions as a, createComponent as b, createAstro as c, ImageMissingAlt as d, addAttribute as e, renderComponent as f, renderSlotToString as g, renderAllHeadContent as h, renderSlot as i, InvalidGetStaticPathsReturn as j, InvalidGetStaticPathsEntry as k, GetStaticPathsExpectedParams as l, maybeRenderHead as m, GetStaticPathsInvalidRouteParam as n, GetStaticPathsRemovedRSSHelper as o, PrerenderDynamicEndpointPathCollide as p, LocalsNotAnObject as q, renderTemplate as r, spreadAttributes as s, renderJSX as t, unescapeHTML as u, chunkToString as v, ResponseSentError as w, renderPage as x, AstroUserError as y, MiddlewareNoDataOrNextCalled as z };
+const AstroJSX = "astro:jsx";
+const Empty = Symbol("empty");
+const toSlotName = (slotAttr) => slotAttr;
+function isVNode(vnode) {
+  return vnode && typeof vnode === "object" && vnode[AstroJSX];
+}
+function transformSlots(vnode) {
+  if (typeof vnode.type === "string")
+    return vnode;
+  const slots = {};
+  if (isVNode(vnode.props.children)) {
+    const child = vnode.props.children;
+    if (!isVNode(child))
+      return;
+    if (!("slot" in child.props))
+      return;
+    const name = toSlotName(child.props.slot);
+    slots[name] = [child];
+    slots[name]["$$slot"] = true;
+    delete child.props.slot;
+    delete vnode.props.children;
+  }
+  if (Array.isArray(vnode.props.children)) {
+    vnode.props.children = vnode.props.children.map((child) => {
+      if (!isVNode(child))
+        return child;
+      if (!("slot" in child.props))
+        return child;
+      const name = toSlotName(child.props.slot);
+      if (Array.isArray(slots[name])) {
+        slots[name].push(child);
+      } else {
+        slots[name] = [child];
+        slots[name]["$$slot"] = true;
+      }
+      delete child.props.slot;
+      return Empty;
+    }).filter((v) => v !== Empty);
+  }
+  Object.assign(vnode.props, slots);
+}
+function markRawChildren(child) {
+  if (typeof child === "string")
+    return markHTMLString(child);
+  if (Array.isArray(child))
+    return child.map((c) => markRawChildren(c));
+  return child;
+}
+function transformSetDirectives(vnode) {
+  if (!("set:html" in vnode.props || "set:text" in vnode.props))
+    return;
+  if ("set:html" in vnode.props) {
+    const children = markRawChildren(vnode.props["set:html"]);
+    delete vnode.props["set:html"];
+    Object.assign(vnode.props, { children });
+    return;
+  }
+  if ("set:text" in vnode.props) {
+    const children = vnode.props["set:text"];
+    delete vnode.props["set:text"];
+    Object.assign(vnode.props, { children });
+    return;
+  }
+}
+function createVNode(type, props) {
+  const vnode = {
+    [Renderer]: "astro:jsx",
+    [AstroJSX]: true,
+    type,
+    props: props ?? {}
+  };
+  transformSetDirectives(vnode);
+  transformSlots(vnode);
+  return vnode;
+}
+
+const slotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase());
+async function check(Component, props, { default: children = null, ...slotted } = {}) {
+  if (typeof Component !== "function")
+    return false;
+  const slots = {};
+  for (const [key, value] of Object.entries(slotted)) {
+    const name = slotName(key);
+    slots[name] = value;
+  }
+  try {
+    const result = await Component({ ...props, ...slots, children });
+    return result[AstroJSX];
+  } catch (e) {
+    const error = e;
+    if (Component[Symbol.for("mdx-component")]) {
+      throw createFormattedError({
+        message: error.message,
+        title: error.name,
+        hint: `This issue often occurs when your MDX component encounters runtime errors.`,
+        name: error.name,
+        stack: error.stack
+      });
+    }
+  }
+  return false;
+}
+async function renderToStaticMarkup(Component, props = {}, { default: children = null, ...slotted } = {}) {
+  const slots = {};
+  for (const [key, value] of Object.entries(slotted)) {
+    const name = slotName(key);
+    slots[name] = value;
+  }
+  const { result } = this;
+  const html = await renderJSX(result, createVNode(Component, { ...props, ...slots, children }));
+  return { html };
+}
+function createFormattedError({ message, name, stack, hint }) {
+  const error = new Error(message);
+  error.name = name;
+  error.stack = stack;
+  error.hint = hint;
+  return error;
+}
+var server_default = {
+  check,
+  renderToStaticMarkup
+};
+
+function getRouteGenerator(segments, addTrailingSlash) {
+  const template = segments.map((segment) => {
+    return "/" + segment.map((part) => {
+      if (part.spread) {
+        return `:${part.content.slice(3)}(.*)?`;
+      } else if (part.dynamic) {
+        return `:${part.content}`;
+      } else {
+        return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+    }).join("");
+  }).join("");
+  let trailing = "";
+  if (addTrailingSlash === "always" && segments.length) {
+    trailing = "/";
+  }
+  const toPath = compile(template + trailing);
+  return toPath;
+}
+
+function deserializeRouteData(rawRouteData) {
+  return {
+    route: rawRouteData.route,
+    type: rawRouteData.type,
+    pattern: new RegExp(rawRouteData.pattern),
+    params: rawRouteData.params,
+    component: rawRouteData.component,
+    generate: getRouteGenerator(rawRouteData.segments, rawRouteData._meta.trailingSlash),
+    pathname: rawRouteData.pathname || void 0,
+    segments: rawRouteData.segments,
+    prerender: rawRouteData.prerender,
+    redirect: rawRouteData.redirect,
+    redirectRoute: rawRouteData.redirectRoute ? deserializeRouteData(rawRouteData.redirectRoute) : void 0
+  };
+}
+
+function deserializeManifest(serializedManifest) {
+  const routes = [];
+  for (const serializedRoute of serializedManifest.routes) {
+    routes.push({
+      ...serializedRoute,
+      routeData: deserializeRouteData(serializedRoute.routeData)
+    });
+    const route = serializedRoute;
+    route.routeData = deserializeRouteData(serializedRoute.routeData);
+  }
+  const assets = new Set(serializedManifest.assets);
+  const componentMetadata = new Map(serializedManifest.componentMetadata);
+  const clientDirectives = new Map(serializedManifest.clientDirectives);
+  return {
+    ...serializedManifest,
+    assets,
+    componentMetadata,
+    clientDirectives,
+    routes
+  };
+}
+
+const DELETED_EXPIRATION = /* @__PURE__ */ new Date(0);
+const DELETED_VALUE = "deleted";
+const responseSentSymbol$2 = Symbol.for("astro.responseSent");
+class AstroCookie {
+  constructor(value) {
+    this.value = value;
+  }
+  json() {
+    if (this.value === void 0) {
+      throw new Error(`Cannot convert undefined to an object.`);
+    }
+    return JSON.parse(this.value);
+  }
+  number() {
+    return Number(this.value);
+  }
+  boolean() {
+    if (this.value === "false")
+      return false;
+    if (this.value === "0")
+      return false;
+    return Boolean(this.value);
+  }
+}
+class AstroCookies {
+  #request;
+  #requestValues;
+  #outgoing;
+  constructor(request) {
+    this.#request = request;
+    this.#requestValues = null;
+    this.#outgoing = null;
+  }
+  /**
+   * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
+   * in a Set-Cookie header added to the response.
+   * @param key The cookie to delete
+   * @param options Options related to this deletion, such as the path of the cookie.
+   */
+  delete(key, options) {
+    const serializeOptions = {
+      expires: DELETED_EXPIRATION
+    };
+    if (options == null ? void 0 : options.domain) {
+      serializeOptions.domain = options.domain;
+    }
+    if (options == null ? void 0 : options.path) {
+      serializeOptions.path = options.path;
+    }
+    this.#ensureOutgoingMap().set(key, [
+      DELETED_VALUE,
+      serialize(key, DELETED_VALUE, serializeOptions),
+      false
+    ]);
+  }
+  /**
+   * Astro.cookies.get(key) is used to get a cookie value. The cookie value is read from the
+   * request. If you have set a cookie via Astro.cookies.set(key, value), the value will be taken
+   * from that set call, overriding any values already part of the request.
+   * @param key The cookie to get.
+   * @returns An object containing the cookie value as well as convenience methods for converting its value.
+   */
+  get(key) {
+    var _a;
+    if ((_a = this.#outgoing) == null ? void 0 : _a.has(key)) {
+      let [serializedValue, , isSetValue] = this.#outgoing.get(key);
+      if (isSetValue) {
+        return new AstroCookie(serializedValue);
+      } else {
+        return new AstroCookie(void 0);
+      }
+    }
+    const values = this.#ensureParsed();
+    const value = values[key];
+    return new AstroCookie(value);
+  }
+  /**
+   * Astro.cookies.has(key) returns a boolean indicating whether this cookie is either
+   * part of the initial request or set via Astro.cookies.set(key)
+   * @param key The cookie to check for.
+   * @returns
+   */
+  has(key) {
+    var _a;
+    if ((_a = this.#outgoing) == null ? void 0 : _a.has(key)) {
+      let [, , isSetValue] = this.#outgoing.get(key);
+      return isSetValue;
+    }
+    const values = this.#ensureParsed();
+    return !!values[key];
+  }
+  /**
+   * Astro.cookies.set(key, value) is used to set a cookie's value. If provided
+   * an object it will be stringified via JSON.stringify(value). Additionally you
+   * can provide options customizing how this cookie will be set, such as setting httpOnly
+   * in order to prevent the cookie from being read in client-side JavaScript.
+   * @param key The name of the cookie to set.
+   * @param value A value, either a string or other primitive or an object.
+   * @param options Options for the cookie, such as the path and security settings.
+   */
+  set(key, value, options) {
+    let serializedValue;
+    if (typeof value === "string") {
+      serializedValue = value;
+    } else {
+      let toStringValue = value.toString();
+      if (toStringValue === Object.prototype.toString.call(value)) {
+        serializedValue = JSON.stringify(value);
+      } else {
+        serializedValue = toStringValue;
+      }
+    }
+    const serializeOptions = {};
+    if (options) {
+      Object.assign(serializeOptions, options);
+    }
+    this.#ensureOutgoingMap().set(key, [
+      serializedValue,
+      serialize(key, serializedValue, serializeOptions),
+      true
+    ]);
+    if (this.#request[responseSentSymbol$2]) {
+      throw new AstroError({
+        ...ResponseSentError
+      });
+    }
+  }
+  /**
+   * Astro.cookies.header() returns an iterator for the cookies that have previously
+   * been set by either Astro.cookies.set() or Astro.cookies.delete().
+   * This method is primarily used by adapters to set the header on outgoing responses.
+   * @returns
+   */
+  *headers() {
+    if (this.#outgoing == null)
+      return;
+    for (const [, value] of this.#outgoing) {
+      yield value[1];
+    }
+  }
+  #ensureParsed() {
+    if (!this.#requestValues) {
+      this.#parse();
+    }
+    if (!this.#requestValues) {
+      this.#requestValues = {};
+    }
+    return this.#requestValues;
+  }
+  #ensureOutgoingMap() {
+    if (!this.#outgoing) {
+      this.#outgoing = /* @__PURE__ */ new Map();
+    }
+    return this.#outgoing;
+  }
+  #parse() {
+    const raw = this.#request.headers.get("cookie");
+    if (!raw) {
+      return;
+    }
+    this.#requestValues = parse(raw);
+  }
+}
+
+const astroCookiesSymbol = Symbol.for("astro.cookies");
+function attachToResponse(response, cookies) {
+  Reflect.set(response, astroCookiesSymbol, cookies);
+}
+function getFromResponse(response) {
+  let cookies = Reflect.get(response, astroCookiesSymbol);
+  if (cookies != null) {
+    return cookies;
+  } else {
+    return void 0;
+  }
+}
+function* getSetCookiesFromResponse(response) {
+  const cookies = getFromResponse(response);
+  if (!cookies) {
+    return [];
+  }
+  for (const headerValue of cookies.headers()) {
+    yield headerValue;
+  }
+  return [];
+}
+
+const dateTimeFormat = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+function log(opts, level, type, message) {
+  const logLevel = opts.level;
+  const dest = opts.dest;
+  const event = {
+    type,
+    level,
+    message
+  };
+  if (levels[logLevel] > levels[level]) {
+    return;
+  }
+  dest.write(event);
+}
+function warn(opts, type, message) {
+  return log(opts, "warn", type, message);
+}
+function error(opts, type, message) {
+  return log(opts, "error", type, message);
+}
+function debug(...args) {
+  if ("_astroGlobalDebug" in globalThis) {
+    globalThis._astroGlobalDebug(...args);
+  }
+}
+if (typeof process !== "undefined") {
+  let proc = process;
+  if ("argv" in proc && Array.isArray(proc.argv)) {
+    if (proc.argv.includes("--verbose")) ; else if (proc.argv.includes("--silent")) ; else ;
+  }
+}
+
+let lastMessage;
+let lastMessageCount = 1;
+const consoleLogDestination = {
+  write(event) {
+    let dest = console.error;
+    if (levels[event.level] < levels["error"]) {
+      dest = console.log;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = event.message;
+    if (message === lastMessage) {
+      lastMessageCount++;
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    const outMessage = getPrefix() + message;
+    dest(outMessage);
+    return true;
+  }
+};
+
+const RedirectComponentInstance = {
+  default() {
+    return new Response(null, {
+      status: 301
+    });
+  }
+};
+const RedirectSinglePageBuiltModule = {
+  page: () => Promise.resolve(RedirectComponentInstance),
+  onRequest: (ctx, next) => next(),
+  renderers: []
+};
+
+function routeIsRedirect(route) {
+  return (route == null ? void 0 : route.type) === "redirect";
+}
+function redirectRouteGenerate(redirectRoute, data) {
+  const routeData = redirectRoute.redirectRoute;
+  const route = redirectRoute.redirect;
+  if (typeof routeData !== "undefined") {
+    return (routeData == null ? void 0 : routeData.generate(data)) || (routeData == null ? void 0 : routeData.pathname) || "/";
+  } else if (typeof route === "string") {
+    return route;
+  } else if (typeof route === "undefined") {
+    return "/";
+  }
+  return route.destination;
+}
+function redirectRouteStatus(redirectRoute, method = "GET") {
+  const routeData = redirectRoute.redirectRoute;
+  if (typeof (routeData == null ? void 0 : routeData.redirect) === "object") {
+    return routeData.redirect.status;
+  } else if (method !== "GET") {
+    return 308;
+  }
+  return 301;
+}
+
+async function callMiddleware(logging, onRequest, apiContext, responseFunction) {
+  let nextCalled = false;
+  let responseFunctionPromise = void 0;
+  const next = async () => {
+    nextCalled = true;
+    responseFunctionPromise = responseFunction();
+    return responseFunctionPromise;
+  };
+  let middlewarePromise = onRequest(apiContext, next);
+  return await Promise.resolve(middlewarePromise).then(async (value) => {
+    if (isEndpointOutput(value)) {
+      warn(
+        logging,
+        "middleware",
+        `Using simple endpoints can cause unexpected issues in the chain of middleware functions.
+It's strongly suggested to use full ${bold("Response")} objects.`
+      );
+    }
+    if (nextCalled) {
+      if (typeof value !== "undefined") {
+        if (value instanceof Response === false) {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
+        return value;
+      } else {
+        if (responseFunctionPromise) {
+          return responseFunctionPromise;
+        } else {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
+      }
+    } else if (typeof value === "undefined") {
+      throw new AstroError(MiddlewareNoDataOrNextCalled);
+    } else if (value instanceof Response === false) {
+      throw new AstroError(MiddlewareNotAResponse);
+    } else {
+      return value;
+    }
+  });
+}
+function isEndpointOutput(endpointResult) {
+  return !(endpointResult instanceof Response) && typeof endpointResult === "object" && typeof endpointResult.body === "string";
+}
+
+const clientAddressSymbol$2 = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol$2 = Symbol.for("astro.locals");
+function createAPIContext({
+  request,
+  params,
+  site,
+  props,
+  adapterName
+}) {
+  const context = {
+    cookies: new AstroCookies(request),
+    request,
+    params,
+    site: site ? new URL(site) : void 0,
+    generator: `Astro v${ASTRO_VERSION}`,
+    props,
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    url: new URL(request.url),
+    get clientAddress() {
+      if (!(clientAddressSymbol$2 in request)) {
+        if (adapterName) {
+          throw new AstroError({
+            ...ClientAddressNotAvailable,
+            message: ClientAddressNotAvailable.message(adapterName)
+          });
+        } else {
+          throw new AstroError(StaticClientAddressNotAvailable);
+        }
+      }
+      return Reflect.get(request, clientAddressSymbol$2);
+    }
+  };
+  Object.defineProperty(context, "locals", {
+    enumerable: true,
+    get() {
+      return Reflect.get(request, clientLocalsSymbol$2);
+    },
+    set(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol$2, val);
+      }
+    }
+  });
+  return context;
+}
+async function callEndpoint(mod, env, ctx, onRequest) {
+  var _a;
+  const context = createAPIContext({
+    request: ctx.request,
+    params: ctx.params,
+    props: ctx.props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  let response;
+  if (onRequest) {
+    response = await callMiddleware(
+      env.logging,
+      onRequest,
+      context,
+      async () => {
+        return await renderEndpoint(mod, context, env.ssr);
+      }
+    );
+  } else {
+    response = await renderEndpoint(mod, context, env.ssr);
+  }
+  if (response instanceof Response) {
+    attachToResponse(response, context.cookies);
+    return {
+      type: "response",
+      response
+    };
+  }
+  if (env.ssr && !((_a = ctx.route) == null ? void 0 : _a.prerender)) {
+    if (response.hasOwnProperty("headers")) {
+      warn(
+        env.logging,
+        "ssr",
+        "Setting headers is not supported when returning an object. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
+      );
+    }
+    if (response.encoding) {
+      warn(
+        env.logging,
+        "ssr",
+        "`encoding` is ignored in SSR. To return a charset other than UTF-8, please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
+      );
+    }
+  }
+  return {
+    ...response,
+    type: "simple",
+    cookies: context.cookies
+  };
+}
+
+const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
+const responseSentSymbol$1 = Symbol.for("astro.responseSent");
+function getFunctionExpression(slot) {
+  var _a;
+  if (!slot)
+    return;
+  if (((_a = slot.expressions) == null ? void 0 : _a.length) !== 1)
+    return;
+  return slot.expressions[0];
+}
+class Slots {
+  #result;
+  #slots;
+  #loggingOpts;
+  constructor(result, slots, logging) {
+    this.#result = result;
+    this.#slots = slots;
+    this.#loggingOpts = logging;
+    if (slots) {
+      for (const key of Object.keys(slots)) {
+        if (this[key] !== void 0) {
+          throw new AstroError({
+            ...ReservedSlotName,
+            message: ReservedSlotName.message(key)
+          });
+        }
+        Object.defineProperty(this, key, {
+          get() {
+            return true;
+          },
+          enumerable: true
+        });
+      }
+    }
+  }
+  has(name) {
+    if (!this.#slots)
+      return false;
+    return Boolean(this.#slots[name]);
+  }
+  async render(name, args = []) {
+    if (!this.#slots || !this.has(name))
+      return;
+    const result = this.#result;
+    if (!Array.isArray(args)) {
+      warn(
+        this.#loggingOpts,
+        "Astro.slots.render",
+        `Expected second parameter to be an array, received a ${typeof args}. If you're trying to pass an array as a single argument and getting unexpected results, make sure you're passing your array as a item of an array. Ex: Astro.slots.render('default', [["Hello", "World"]])`
+      );
+    } else if (args.length > 0) {
+      const slotValue = this.#slots[name];
+      const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
+      const expression = getFunctionExpression(component);
+      if (expression) {
+        const slot = async () => typeof expression === "function" ? expression(...args) : expression;
+        return await renderSlotToString(result, slot).then((res) => {
+          return res != null ? String(res) : res;
+        });
+      }
+      if (typeof component === "function") {
+        return await renderJSX(result, component(...args)).then(
+          (res) => res != null ? String(res) : res
+        );
+      }
+    }
+    const content = await renderSlotToString(result, this.#slots[name]);
+    const outHTML = chunkToString(result, content);
+    return outHTML;
+  }
+}
+let renderMarkdown = null;
+function createResult(args) {
+  const { markdown, params, request, resolve, locals } = args;
+  const url = new URL(request.url);
+  const headers = new Headers();
+  headers.set("Content-Type", "text/html");
+  const response = {
+    status: args.status,
+    statusText: "OK",
+    headers
+  };
+  Object.defineProperty(response, "headers", {
+    value: response.headers,
+    enumerable: true,
+    writable: false
+  });
+  let cookies = args.cookies;
+  const result = {
+    styles: args.styles ?? /* @__PURE__ */ new Set(),
+    scripts: args.scripts ?? /* @__PURE__ */ new Set(),
+    links: args.links ?? /* @__PURE__ */ new Set(),
+    componentMetadata: args.componentMetadata ?? /* @__PURE__ */ new Map(),
+    renderers: args.renderers,
+    clientDirectives: args.clientDirectives,
+    compressHTML: args.compressHTML,
+    pathname: args.pathname,
+    cookies,
+    /** This function returns the `Astro` faux-global */
+    createAstro(astroGlobal, props, slots) {
+      const astroSlots = new Slots(result, slots, args.logging);
+      const Astro = {
+        // @ts-expect-error
+        __proto__: astroGlobal,
+        get clientAddress() {
+          if (!(clientAddressSymbol$1 in request)) {
+            if (args.adapterName) {
+              throw new AstroError({
+                ...ClientAddressNotAvailable,
+                message: ClientAddressNotAvailable.message(args.adapterName)
+              });
+            } else {
+              throw new AstroError(StaticClientAddressNotAvailable);
+            }
+          }
+          return Reflect.get(request, clientAddressSymbol$1);
+        },
+        get cookies() {
+          if (cookies) {
+            return cookies;
+          }
+          cookies = new AstroCookies(request);
+          result.cookies = cookies;
+          return cookies;
+        },
+        params,
+        props,
+        locals,
+        request,
+        url,
+        redirect(path, status) {
+          if (request[responseSentSymbol$1]) {
+            throw new AstroError({
+              ...ResponseSentError
+            });
+          }
+          return new Response(null, {
+            status: status || 302,
+            headers: {
+              Location: path
+            }
+          });
+        },
+        response,
+        slots: astroSlots
+      };
+      Object.defineProperty(Astro, "__renderMarkdown", {
+        // Ensure this API is not exposed to users
+        enumerable: false,
+        writable: false,
+        // TODO: Remove this hole "Deno" logic once our plugin gets Deno support
+        value: async function(content, opts) {
+          if (typeof Deno !== "undefined") {
+            throw new Error("Markdown is not supported in Deno SSR");
+          }
+          if (!renderMarkdown) {
+            let astroRemark = "@astrojs/";
+            astroRemark += "markdown-remark";
+            renderMarkdown = (await import(astroRemark)).renderMarkdown;
+          }
+          const { code } = await renderMarkdown(content, { ...markdown, ...opts ?? {} });
+          return code;
+        }
+      });
+      return Astro;
+    },
+    resolve,
+    response,
+    _metadata: {
+      hasHydrationScript: false,
+      hasRenderedHead: false,
+      hasDirectives: /* @__PURE__ */ new Set(),
+      headInTree: false,
+      extraHead: [],
+      propagators: /* @__PURE__ */ new Map()
+    }
+  };
+  return result;
+}
+
+async function renderPage({ mod, renderContext, env, cookies }) {
+  if (routeIsRedirect(renderContext.route)) {
+    return new Response(null, {
+      status: redirectRouteStatus(renderContext.route, renderContext.request.method),
+      headers: {
+        location: redirectRouteGenerate(renderContext.route, renderContext.params)
+      }
+    });
+  }
+  const Component = mod.default;
+  if (!Component)
+    throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
+  const result = createResult({
+    adapterName: env.adapterName,
+    links: renderContext.links,
+    styles: renderContext.styles,
+    logging: env.logging,
+    markdown: env.markdown,
+    params: renderContext.params,
+    pathname: renderContext.pathname,
+    componentMetadata: renderContext.componentMetadata,
+    resolve: env.resolve,
+    renderers: env.renderers,
+    clientDirectives: env.clientDirectives,
+    compressHTML: env.compressHTML,
+    request: renderContext.request,
+    site: env.site,
+    scripts: renderContext.scripts,
+    ssr: env.ssr,
+    status: renderContext.status ?? 200,
+    cookies,
+    locals: renderContext.locals ?? {}
+  });
+  if (typeof mod.components === "object") {
+    Object.assign(renderContext.props, { components: mod.components });
+  }
+  let response = await renderPage$1(
+    result,
+    Component,
+    renderContext.props,
+    null,
+    env.streaming,
+    renderContext.route
+  );
+  if (result.cookies) {
+    attachToResponse(response, result.cookies);
+  }
+  return response;
+}
+async function tryRenderRoute(routeType, renderContext, env, mod, onRequest) {
+  const apiContext = createAPIContext({
+    request: renderContext.request,
+    params: renderContext.params,
+    props: renderContext.props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  switch (routeType) {
+    case "page":
+    case "redirect": {
+      if (onRequest) {
+        return await callMiddleware(
+          env.logging,
+          onRequest,
+          apiContext,
+          () => {
+            return renderPage({
+              mod,
+              renderContext,
+              env,
+              cookies: apiContext.cookies
+            });
+          }
+        );
+      } else {
+        return await renderPage({
+          mod,
+          renderContext,
+          env,
+          cookies: apiContext.cookies
+        });
+      }
+    }
+    case "endpoint": {
+      const result = await callEndpoint(
+        mod,
+        env,
+        renderContext,
+        onRequest
+      );
+      return result;
+    }
+    default:
+      throw new Error(`Couldn't find route of type [${routeType}]`);
+  }
+}
+function isResponse(result, routeType) {
+  return result instanceof Response && (routeType === "page" || routeType === "redirect");
+}
+
+const VALID_PARAM_TYPES = ["string", "number", "undefined"];
+function validateGetStaticPathsParameter([key, value], route) {
+  if (!VALID_PARAM_TYPES.includes(typeof value)) {
+    throw new AstroError({
+      ...GetStaticPathsInvalidRouteParam,
+      message: GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
+      location: {
+        file: route
+      }
+    });
+  }
+}
+function validateDynamicRouteModule(mod, {
+  ssr,
+  route
+}) {
+  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
+    throw new AstroError({
+      ...GetStaticPathsRequired,
+      location: { file: route.component }
+    });
+  }
+}
+function validateGetStaticPathsResult(result, logging, route) {
+  if (!Array.isArray(result)) {
+    throw new AstroError({
+      ...InvalidGetStaticPathsReturn,
+      message: InvalidGetStaticPathsReturn.message(typeof result),
+      location: {
+        file: route.component
+      }
+    });
+  }
+  result.forEach((pathObject) => {
+    if (pathObject.params === void 0 || pathObject.params === null || pathObject.params && Object.keys(pathObject.params).length === 0) {
+      throw new AstroError({
+        ...GetStaticPathsExpectedParams,
+        location: {
+          file: route.component
+        }
+      });
+    }
+    if (typeof pathObject.params !== "object") {
+      throw new AstroError({
+        ...InvalidGetStaticPathParam,
+        message: InvalidGetStaticPathParam.message(typeof pathObject.params),
+        location: {
+          file: route.component
+        }
+      });
+    }
+    for (const [key, val] of Object.entries(pathObject.params)) {
+      if (!(typeof val === "undefined" || typeof val === "string" || typeof val === "number")) {
+        warn(
+          logging,
+          "getStaticPaths",
+          `invalid path param: ${key}. A string, number or undefined value was expected, but got \`${JSON.stringify(
+            val
+          )}\`.`
+        );
+      }
+      if (typeof val === "string" && val === "") {
+        warn(
+          logging,
+          "getStaticPaths",
+          `invalid path param: ${key}. \`undefined\` expected for an optional param, but got empty string.`
+        );
+      }
+    }
+  });
+}
+
+function getParams(array) {
+  const fn = (match) => {
+    const params = {};
+    array.forEach((key, i) => {
+      if (key.startsWith("...")) {
+        params[key.slice(3)] = match[i + 1] ? decodeURIComponent(match[i + 1]) : void 0;
+      } else {
+        params[key] = decodeURIComponent(match[i + 1]);
+      }
+    });
+    return params;
+  };
+  return fn;
+}
+function stringifyParams(params, route) {
+  const validatedParams = Object.entries(params).reduce((acc, next) => {
+    validateGetStaticPathsParameter(next, route.component);
+    const [key, value] = next;
+    acc[key] = value == null ? void 0 : value.toString();
+    return acc;
+  }, {});
+  return JSON.stringify(route.generate(validatedParams));
+}
+
+function generatePaginateFunction(routeMatch) {
+  return function paginateUtility(data, args = {}) {
+    let { pageSize: _pageSize, params: _params, props: _props } = args;
+    const pageSize = _pageSize || 10;
+    const paramName = "page";
+    const additionalParams = _params || {};
+    const additionalProps = _props || {};
+    let includesFirstPageNumber;
+    if (routeMatch.params.includes(`...${paramName}`)) {
+      includesFirstPageNumber = false;
+    } else if (routeMatch.params.includes(`${paramName}`)) {
+      includesFirstPageNumber = true;
+    } else {
+      throw new AstroError({
+        ...PageNumberParamNotFound,
+        message: PageNumberParamNotFound.message(paramName)
+      });
+    }
+    const lastPage = Math.max(1, Math.ceil(data.length / pageSize));
+    const result = [...Array(lastPage).keys()].map((num) => {
+      const pageNum = num + 1;
+      const start = pageSize === Infinity ? 0 : (pageNum - 1) * pageSize;
+      const end = Math.min(start + pageSize, data.length);
+      const params = {
+        ...additionalParams,
+        [paramName]: includesFirstPageNumber || pageNum > 1 ? String(pageNum) : void 0
+      };
+      const current = correctIndexRoute(routeMatch.generate({ ...params }));
+      const next = pageNum === lastPage ? void 0 : correctIndexRoute(routeMatch.generate({ ...params, page: String(pageNum + 1) }));
+      const prev = pageNum === 1 ? void 0 : correctIndexRoute(
+        routeMatch.generate({
+          ...params,
+          page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
+        })
+      );
+      return {
+        params,
+        props: {
+          ...additionalProps,
+          page: {
+            data: data.slice(start, end),
+            start,
+            end: end - 1,
+            size: pageSize,
+            total: data.length,
+            currentPage: pageNum,
+            lastPage,
+            url: { current, next, prev }
+          }
+        }
+      };
+    });
+    return result;
+  };
+}
+function correctIndexRoute(route) {
+  if (route === "") {
+    return "/";
+  }
+  return route;
+}
+
+async function callGetStaticPaths({
+  mod,
+  route,
+  routeCache,
+  isValidate,
+  logging,
+  ssr
+}) {
+  const cached = routeCache.get(route);
+  if (cached == null ? void 0 : cached.staticPaths)
+    return cached.staticPaths;
+  validateDynamicRouteModule(mod, { ssr, route });
+  if (ssr && !route.prerender) {
+    const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
+    routeCache.set(route, { ...cached, staticPaths: entry });
+    return entry;
+  }
+  if (!mod.getStaticPaths) {
+    throw new Error("Unexpected Error.");
+  }
+  let staticPaths = [];
+  staticPaths = await mod.getStaticPaths({
+    paginate: generatePaginateFunction(route),
+    rss() {
+      throw new AstroError(GetStaticPathsRemovedRSSHelper);
+    }
+  });
+  if (Array.isArray(staticPaths)) {
+    staticPaths = staticPaths.flat();
+  }
+  if (isValidate) {
+    validateGetStaticPathsResult(staticPaths, logging, route);
+  }
+  const keyedStaticPaths = staticPaths;
+  keyedStaticPaths.keyed = /* @__PURE__ */ new Map();
+  for (const sp of keyedStaticPaths) {
+    const paramsKey = stringifyParams(sp.params, route);
+    keyedStaticPaths.keyed.set(paramsKey, sp);
+  }
+  routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
+  return keyedStaticPaths;
+}
+class RouteCache {
+  constructor(logging, mode = "production") {
+    this.cache = {};
+    this.logging = logging;
+    this.mode = mode;
+  }
+  /** Clear the cache. */
+  clearAll() {
+    this.cache = {};
+  }
+  set(route, entry) {
+    var _a;
+    if (this.mode === "production" && ((_a = this.cache[route.component]) == null ? void 0 : _a.staticPaths)) {
+      warn(
+        this.logging,
+        "routeCache",
+        `Internal Warning: route cache overwritten. (${route.component})`
+      );
+    }
+    this.cache[route.component] = entry;
+  }
+  get(route) {
+    return this.cache[route.component];
+  }
+}
+function findPathItemByKey(staticPaths, params, route) {
+  const paramsKey = stringifyParams(params, route);
+  const matchedStaticPath = staticPaths.keyed.get(paramsKey);
+  if (matchedStaticPath) {
+    return matchedStaticPath;
+  }
+  debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
+}
+
+async function getParamsAndProps(opts) {
+  const { logging, mod, route, routeCache, pathname, ssr } = opts;
+  if (!route || route.pathname) {
+    return [{}, {}];
+  }
+  const params = getRouteParams(route, pathname) ?? {};
+  validatePrerenderEndpointCollision(route, mod, params);
+  const staticPaths = await callGetStaticPaths({
+    mod,
+    route,
+    routeCache,
+    isValidate: true,
+    logging,
+    ssr
+  });
+  const matchedStaticPath = findPathItemByKey(staticPaths, params, route);
+  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
+    throw new AstroError({
+      ...NoMatchingStaticPathFound,
+      message: NoMatchingStaticPathFound.message(pathname),
+      hint: NoMatchingStaticPathFound.hint([route.component])
+    });
+  }
+  const props = (matchedStaticPath == null ? void 0 : matchedStaticPath.props) ? { ...matchedStaticPath.props } : {};
+  return [params, props];
+}
+function getRouteParams(route, pathname) {
+  if (route.params.length) {
+    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
+    if (paramsMatch) {
+      return getParams(route.params)(paramsMatch);
+    }
+  }
+}
+function validatePrerenderEndpointCollision(route, mod, params) {
+  if (route.type === "endpoint" && mod.getStaticPaths) {
+    const lastSegment = route.segments[route.segments.length - 1];
+    const paramValues = Object.values(params);
+    const lastParam = paramValues[paramValues.length - 1];
+    if (lastSegment.length === 1 && lastSegment[0].dynamic && lastParam === void 0) {
+      throw new AstroError({
+        ...PrerenderDynamicEndpointPathCollide,
+        message: PrerenderDynamicEndpointPathCollide.message(route.route),
+        hint: PrerenderDynamicEndpointPathCollide.hint(route.component),
+        location: {
+          file: route.component
+        }
+      });
+    }
+  }
+}
+
+const clientLocalsSymbol$1 = Symbol.for("astro.locals");
+async function createRenderContext(options) {
+  const request = options.request;
+  const pathname = options.pathname ?? new URL(request.url).pathname;
+  const [params, props] = await getParamsAndProps({
+    mod: options.mod,
+    route: options.route,
+    routeCache: options.env.routeCache,
+    pathname,
+    logging: options.env.logging,
+    ssr: options.env.ssr
+  });
+  const context = {
+    ...options,
+    pathname,
+    params,
+    props
+  };
+  Object.defineProperty(context, "locals", {
+    enumerable: true,
+    get() {
+      return Reflect.get(request, clientLocalsSymbol$1);
+    },
+    set(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol$1, val);
+      }
+    }
+  });
+  return context;
+}
+
+function createEnvironment(options) {
+  return options;
+}
+
+function createAssetLink(href, base, assetsPrefix) {
+  if (assetsPrefix) {
+    return joinPaths(assetsPrefix, slash(href));
+  } else if (base) {
+    return prependForwardSlash(joinPaths(base, slash(href)));
+  } else {
+    return href;
+  }
+}
+function createStylesheetElement(stylesheet, base, assetsPrefix) {
+  if (stylesheet.type === "inline") {
+    return {
+      props: {
+        type: "text/css"
+      },
+      children: stylesheet.content
+    };
+  } else {
+    return {
+      props: {
+        rel: "stylesheet",
+        href: createAssetLink(stylesheet.src, base, assetsPrefix)
+      },
+      children: ""
+    };
+  }
+}
+function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
+  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
+}
+function createModuleScriptElement(script, base, assetsPrefix) {
+  if (script.type === "external") {
+    return createModuleScriptElementWithSrc(script.value, base, assetsPrefix);
+  } else {
+    return {
+      props: {
+        type: "module"
+      },
+      children: script.value
+    };
+  }
+}
+function createModuleScriptElementWithSrc(src, base, assetsPrefix) {
+  return {
+    props: {
+      type: "module",
+      src: createAssetLink(src, base, assetsPrefix)
+    },
+    children: ""
+  };
+}
+
+function matchRoute(pathname, manifest) {
+  return manifest.routes.find((route) => route.pattern.test(decodeURI(pathname)));
+}
+
+const clientLocalsSymbol = Symbol.for("astro.locals");
+const responseSentSymbol = Symbol.for("astro.responseSent");
+const STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
+class App {
+  /**
+   * The current environment of the application
+   */
+  #env;
+  #manifest;
+  #manifestData;
+  #routeDataToRouteInfo;
+  #encoder = new TextEncoder();
+  #logging = {
+    dest: consoleLogDestination,
+    level: "info"
+  };
+  #baseWithoutTrailingSlash;
+  constructor(manifest, streaming = true) {
+    this.#manifest = manifest;
+    this.#manifestData = {
+      routes: manifest.routes.map((route) => route.routeData)
+    };
+    this.#routeDataToRouteInfo = new Map(manifest.routes.map((route) => [route.routeData, route]));
+    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
+    this.#env = this.#createEnvironment(streaming);
+  }
+  set setManifest(newManifest) {
+    this.#manifest = newManifest;
+  }
+  /**
+   * Creates an environment by reading the stored manifest
+   *
+   * @param streaming
+   * @private
+   */
+  #createEnvironment(streaming = false) {
+    return createEnvironment({
+      adapterName: this.#manifest.adapterName,
+      logging: this.#logging,
+      markdown: this.#manifest.markdown,
+      mode: "production",
+      compressHTML: this.#manifest.compressHTML,
+      renderers: this.#manifest.renderers,
+      clientDirectives: this.#manifest.clientDirectives,
+      resolve: async (specifier) => {
+        if (!(specifier in this.#manifest.entryModules)) {
+          throw new Error(`Unable to resolve [${specifier}]`);
+        }
+        const bundlePath = this.#manifest.entryModules[specifier];
+        switch (true) {
+          case bundlePath.startsWith("data:"):
+          case bundlePath.length === 0: {
+            return bundlePath;
+          }
+          default: {
+            return createAssetLink(bundlePath, this.#manifest.base, this.#manifest.assetsPrefix);
+          }
+        }
+      },
+      routeCache: new RouteCache(this.#logging),
+      site: this.#manifest.site,
+      ssr: true,
+      streaming
+    });
+  }
+  set setManifestData(newManifestData) {
+    this.#manifestData = newManifestData;
+  }
+  removeBase(pathname) {
+    if (pathname.startsWith(this.#manifest.base)) {
+      return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
+    }
+    return pathname;
+  }
+  // Disable no-unused-vars to avoid breaking signature change
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(request, _opts = {}) {
+    const url = new URL(request.url);
+    if (this.#manifest.assets.has(url.pathname))
+      return void 0;
+    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+    const routeData = matchRoute(pathname, this.#manifestData);
+    if (!routeData || routeData.prerender)
+      return void 0;
+    return routeData;
+  }
+  async render(request, routeData, locals) {
+    if (request.url !== collapseDuplicateSlashes(request.url)) {
+      request = new Request(collapseDuplicateSlashes(request.url), request);
+    }
+    if (!routeData) {
+      routeData = this.match(request);
+    }
+    if (!routeData) {
+      return this.#renderError(request, { status: 404 });
+    }
+    Reflect.set(request, clientLocalsSymbol, locals ?? {});
+    const defaultStatus = this.#getDefaultStatusCode(routeData.route);
+    const mod = await this.#getModuleForRoute(routeData);
+    const pageModule = await mod.page();
+    const url = new URL(request.url);
+    const renderContext = await this.#createRenderContext(
+      url,
+      request,
+      routeData,
+      mod,
+      defaultStatus
+    );
+    let response;
+    try {
+      response = await tryRenderRoute(
+        routeData.type,
+        renderContext,
+        this.#env,
+        pageModule,
+        mod.onRequest
+      );
+    } catch (err) {
+      error(this.#logging, "ssr", err.stack || err.message || String(err));
+      return this.#renderError(request, { status: 500 });
+    }
+    if (isResponse(response, routeData.type)) {
+      if (STATUS_CODES.has(response.status)) {
+        return this.#renderError(request, {
+          response,
+          status: response.status
+        });
+      }
+      Reflect.set(response, responseSentSymbol, true);
+      return response;
+    } else {
+      if (response.type === "response") {
+        if (response.response.headers.get("X-Astro-Response") === "Not-Found") {
+          return this.#renderError(request, {
+            response: response.response,
+            status: 404
+          });
+        }
+        return response.response;
+      } else {
+        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 = response.encoding !== "binary" ? this.#encoder.encode(response.body) : response.body;
+        headers.set("Content-Length", bytes.byteLength.toString());
+        const newResponse = new Response(bytes, {
+          status: 200,
+          headers
+        });
+        attachToResponse(newResponse, response.cookies);
+        return newResponse;
+      }
+    }
+  }
+  setCookieHeaders(response) {
+    return getSetCookiesFromResponse(response);
+  }
+  /**
+   * Creates the render context of the current route
+   */
+  async #createRenderContext(url, request, routeData, page, status = 200) {
+    if (routeData.type === "endpoint") {
+      const pathname = "/" + this.removeBase(url.pathname);
+      const mod = await page.page();
+      const handler = mod;
+      return await createRenderContext({
+        request,
+        pathname,
+        route: routeData,
+        status,
+        env: this.#env,
+        mod: handler
+      });
+    } else {
+      const pathname = prependForwardSlash(this.removeBase(url.pathname));
+      const info = this.#routeDataToRouteInfo.get(routeData);
+      const links = /* @__PURE__ */ new Set();
+      const styles = createStylesheetElementSet(info.styles);
+      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));
+        }
+      }
+      const mod = await page.page();
+      return await createRenderContext({
+        request,
+        pathname,
+        componentMetadata: this.#manifest.componentMetadata,
+        scripts,
+        styles,
+        links,
+        route: routeData,
+        status,
+        mod,
+        env: this.#env
+      });
+    }
+  }
+  /**
+   * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
+   * This also handles pre-rendered /404 or /500 routes
+   */
+  async #renderError(request, { status, response: originalResponse }) {
+    const errorRouteData = matchRoute("/" + status, this.#manifestData);
+    const url = new URL(request.url);
+    if (errorRouteData) {
+      if (errorRouteData.prerender) {
+        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
+        const statusURL = new URL(
+          `${this.#baseWithoutTrailingSlash}/${status}${maybeDotHtml}`,
+          url
+        );
+        const response2 = await fetch(statusURL.toString());
+        const override = { status };
+        return this.#mergeResponses(response2, originalResponse, override);
+      }
+      const mod = await this.#getModuleForRoute(errorRouteData);
+      try {
+        const newRenderContext = await this.#createRenderContext(
+          url,
+          request,
+          errorRouteData,
+          mod,
+          status
+        );
+        const page = await mod.page();
+        const response2 = await tryRenderRoute(
+          "page",
+          // this is hardcoded to ensure proper behavior for missing endpoints
+          newRenderContext,
+          this.#env,
+          page
+        );
+        return this.#mergeResponses(response2, originalResponse);
+      } catch {
+      }
+    }
+    const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
+    Reflect.set(response, responseSentSymbol, true);
+    return response;
+  }
+  #mergeResponses(newResponse, oldResponse, override) {
+    if (!oldResponse) {
+      if (override !== void 0) {
+        return new Response(newResponse.body, {
+          status: override.status,
+          statusText: newResponse.statusText,
+          headers: newResponse.headers
+        });
+      }
+      return newResponse;
+    }
+    const { statusText, headers } = oldResponse;
+    const status = (override == null ? void 0 : override.status) ? override.status : oldResponse.status === 200 ? newResponse.status : oldResponse.status;
+    return new Response(newResponse.body, {
+      status,
+      statusText: status === 200 ? newResponse.statusText : statusText,
+      headers: new Headers(Array.from(headers))
+    });
+  }
+  #getDefaultStatusCode(route) {
+    route = removeTrailingForwardSlash(route);
+    if (route.endsWith("/404"))
+      return 404;
+    if (route.endsWith("/500"))
+      return 500;
+    return 200;
+  }
+  async #getModuleForRoute(route) {
+    if (route.type === "redirect") {
+      return RedirectSinglePageBuiltModule;
+    } else {
+      if (this.#manifest.pageMap) {
+        const importComponentInstance = this.#manifest.pageMap.get(route.component);
+        if (!importComponentInstance) {
+          throw new Error(
+            `Unexpectedly unable to find a component instance for route ${route.route}`
+          );
+        }
+        const pageModule = await importComponentInstance();
+        return pageModule;
+      } else if (this.#manifest.pageModule) {
+        const importComponentInstance = this.#manifest.pageModule;
+        return importComponentInstance;
+      } else {
+        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."
+        );
+      }
+    }
+  }
+}
+
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+function createRequestFromNodeRequest(req, options) {
+  var _a;
+  const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+  const hostname = req.headers.host || req.headers[":authority"];
+  const url = `${protocol}://${hostname}${req.url}`;
+  const headers = makeRequestHeaders(req);
+  const method = req.method || "GET";
+  let bodyProps = {};
+  const bodyAllowed = method !== "HEAD" && method !== "GET" && !(options == null ? void 0 : options.emptyBody);
+  if (bodyAllowed) {
+    bodyProps = makeRequestBody(req);
+  }
+  const request = new Request(url, {
+    method,
+    headers,
+    ...bodyProps
+  });
+  if ((_a = req.socket) == null ? void 0 : _a.remoteAddress) {
+    Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+  }
+  return request;
+}
+function makeRequestHeaders(req) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(name, item);
+      }
+    } else {
+      headers.append(name, value);
+    }
+  }
+  return headers;
+}
+function makeRequestBody(req) {
+  if (req.body !== void 0) {
+    if (typeof req.body === "string" && req.body.length > 0) {
+      return { body: Buffer.from(req.body) };
+    }
+    if (typeof req.body === "object" && req.body !== null && Object.keys(req.body).length > 0) {
+      return { body: Buffer.from(JSON.stringify(req.body)) };
+    }
+    if (typeof req.body === "object" && req.body !== null && typeof req.body[Symbol.asyncIterator] !== "undefined") {
+      return asyncIterableToBodyProps(req.body);
+    }
+  }
+  return asyncIterableToBodyProps(req);
+}
+function asyncIterableToBodyProps(iterable) {
+  return {
+    // Node uses undici for the Request implementation. Undici accepts
+    // a non-standard async iterable for the body.
+    // @ts-expect-error
+    body: iterable,
+    // The duplex property is required when using a ReadableStream or async
+    // iterable for the body. The type definitions do not include the duplex
+    // property because they are not up-to-date.
+    // @ts-expect-error
+    duplex: "half"
+  };
+}
+class NodeApp extends App {
+  match(req, opts = {}) {
+    if (!(req instanceof Request)) {
+      req = createRequestFromNodeRequest(req, {
+        emptyBody: true
+      });
+    }
+    return super.match(req, opts);
+  }
+  render(req, routeData, locals) {
+    if (!(req instanceof Request)) {
+      req = createRequestFromNodeRequest(req);
+    }
+    return super.render(req, routeData, locals);
+  }
+}
+
+export { Fragment as F, NodeApp as N, createComponent as a, addAttribute as b, createAstro as c, renderComponent as d, renderSlotToString as e, renderAllHeadContent as f, renderSlot as g, deserializeManifest as h, server_default as i, maybeRenderHead as m, renderTemplate as r, spreadAttributes as s, unescapeHTML as u };