cloudcommerce 0.2.2 → 0.2.3

package/packages/storefront/dist/server/chunks/astro.89bd9221.mjs

@@ -0,0 +1,3378 @@
+import { compile } from 'path-to-regexp';
+import 'fs';
+import { TLSSocket } from 'tls';
+import mime from 'mime';
+import { serialize, parse } from 'cookie';
+import { yellow, dim, bold, cyan, red, reset } from 'kleur/colors';
+import 'string-width';
+import slashify from 'slash';
+import { escape } from 'html-escaper';
+
+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
+  };
+}
+
+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);
+  return {
+    ...serializedManifest,
+    assets,
+    routes
+  };
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (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$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$3(obj, member, "access private method");
+  return method;
+};
+var _request, _requestValues, _outgoing, _ensureParsed, ensureParsed_fn, _ensureOutgoingMap, ensureOutgoingMap_fn, _parse, parse_fn;
+const DELETED_EXPIRATION = new Date(0);
+const DELETED_VALUE = "deleted";
+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 {
+  constructor(request) {
+    __privateAdd$3(this, _ensureParsed);
+    __privateAdd$3(this, _ensureOutgoingMap);
+    __privateAdd$3(this, _parse);
+    __privateAdd$3(this, _request, void 0);
+    __privateAdd$3(this, _requestValues, void 0);
+    __privateAdd$3(this, _outgoing, void 0);
+    __privateSet$3(this, _request, request);
+    __privateSet$3(this, _requestValues, null);
+    __privateSet$3(this, _outgoing, null);
+  }
+  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;
+    }
+    __privateMethod$1(this, _ensureOutgoingMap, ensureOutgoingMap_fn).call(this).set(key, [
+      DELETED_VALUE,
+      serialize(key, DELETED_VALUE, serializeOptions),
+      false
+    ]);
+  }
+  get(key) {
+    if (__privateGet$3(this, _outgoing) !== null && __privateGet$3(this, _outgoing).has(key)) {
+      let [serializedValue, , isSetValue] = __privateGet$3(this, _outgoing).get(key);
+      if (isSetValue) {
+        return new AstroCookie(serializedValue);
+      } else {
+        return new AstroCookie(void 0);
+      }
+    }
+    const values = __privateMethod$1(this, _ensureParsed, ensureParsed_fn).call(this);
+    const value = values[key];
+    return new AstroCookie(value);
+  }
+  has(key) {
+    if (__privateGet$3(this, _outgoing) !== null && __privateGet$3(this, _outgoing).has(key)) {
+      let [, , isSetValue] = __privateGet$3(this, _outgoing).get(key);
+      return isSetValue;
+    }
+    const values = __privateMethod$1(this, _ensureParsed, ensureParsed_fn).call(this);
+    return !!values[key];
+  }
+  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);
+    }
+    __privateMethod$1(this, _ensureOutgoingMap, ensureOutgoingMap_fn).call(this).set(key, [
+      serializedValue,
+      serialize(key, serializedValue, serializeOptions),
+      true
+    ]);
+  }
+  *headers() {
+    if (__privateGet$3(this, _outgoing) == null)
+      return;
+    for (const [, value] of __privateGet$3(this, _outgoing)) {
+      yield value[1];
+    }
+  }
+}
+_request = new WeakMap();
+_requestValues = new WeakMap();
+_outgoing = new WeakMap();
+_ensureParsed = new WeakSet();
+ensureParsed_fn = function() {
+  if (!__privateGet$3(this, _requestValues)) {
+    __privateMethod$1(this, _parse, parse_fn).call(this);
+  }
+  if (!__privateGet$3(this, _requestValues)) {
+    __privateSet$3(this, _requestValues, {});
+  }
+  return __privateGet$3(this, _requestValues);
+};
+_ensureOutgoingMap = new WeakSet();
+ensureOutgoingMap_fn = function() {
+  if (!__privateGet$3(this, _outgoing)) {
+    __privateSet$3(this, _outgoing, /* @__PURE__ */ new Map());
+  }
+  return __privateGet$3(this, _outgoing);
+};
+_parse = new WeakSet();
+parse_fn = function() {
+  const raw = __privateGet$3(this, _request).headers.get("cookie");
+  if (!raw) {
+    return;
+  }
+  __privateSet$3(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;
+  }
+}
+
+function baseCreateComponent(cb, moduleId) {
+  cb.isAstroComponentFactory = true;
+  cb.moduleId = moduleId;
+  return cb;
+}
+function createComponentWithOptions(opts) {
+  const cb = baseCreateComponent(opts.factory, opts.moduleId);
+  cb.propagation = opts.propagation;
+  return cb;
+}
+function createComponent(arg1, moduleId) {
+  if (typeof arg1 === "function") {
+    return baseCreateComponent(arg1, moduleId);
+  } else {
+    return createComponentWithOptions(arg1);
+  }
+}
+
+const ASTRO_VERSION = "2.0.2";
+
+function createAstroGlobFn() {
+  const globHandler = (importMetaGlobResult, globValue) => {
+    let allEntries = [...Object.values(importMetaGlobResult)];
+    if (allEntries.length === 0) {
+      throw new Error(`Astro.glob(${JSON.stringify(globValue())}) - no matches found.`);
+    }
+    return Promise.all(allEntries.map((fn) => fn()));
+  };
+  return globHandler;
+}
+function createAstro(site) {
+  return {
+    site: site ? new URL(site) : void 0,
+    generator: `Astro v${ASTRO_VERSION}`,
+    glob: createAstroGlobFn()
+  };
+}
+
+function getHandlerFromModule(mod, method) {
+  if (mod[method]) {
+    return mod[method];
+  }
+  if (method === "delete" && mod["del"]) {
+    return mod["del"];
+  }
+  if (mod["all"]) {
+    return mod["all"];
+  }
+  return void 0;
+}
+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' to handle ${chosenMethod} requests.`);
+  }
+  if (!handler || typeof handler !== "function") {
+    let response = new Response(null, {
+      status: 404,
+      headers: {
+        "X-Astro-Response": "Not-Found"
+      }
+    });
+    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;
+      }
+    }
+  });
+  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";
+}
+async function* streamAsyncIterator(stream) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+const escapeHTML = escape;
+class HTMLBytes extends Uint8Array {
+}
+Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
+  get() {
+    return "HTMLBytes";
+  }
+});
+class HTMLString extends String {
+  get [Symbol.toStringTag]() {
+    return "HTMLString";
+  }
+}
+const markHTMLString = (value) => {
+  if (value instanceof HTMLString) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new HTMLString(value);
+  }
+  return value;
+};
+function isHTMLString(value) {
+  return Object.prototype.toString.call(value) === "[object HTMLString]";
+}
+function markHTMLBytes(bytes) {
+  return new HTMLBytes(bytes);
+}
+function hasGetReader(obj) {
+  return typeof obj.getReader === "function";
+}
+async function* unescapeChunksAsync(iterable) {
+  if (hasGetReader(iterable)) {
+    for await (const chunk of streamAsyncIterator(iterable)) {
+      yield unescapeHTML(chunk);
+    }
+  } else {
+    for await (const chunk of iterable) {
+      yield unescapeHTML(chunk);
+    }
+  }
+}
+function* unescapeChunks(iterable) {
+  for (const chunk of iterable) {
+    yield unescapeHTML(chunk);
+  }
+}
+function unescapeHTML(str) {
+  if (!!str && typeof str === "object") {
+    if (str instanceof Uint8Array) {
+      return markHTMLBytes(str);
+    } else if (str instanceof Response && str.body) {
+      const body = str.body;
+      return unescapeChunksAsync(body);
+    } else if (typeof str.then === "function") {
+      return Promise.resolve(str).then((value) => {
+        return unescapeHTML(value);
+      });
+    } else if (Symbol.iterator in str) {
+      return unescapeChunks(str);
+    } else if (Symbol.asyncIterator in str || hasGetReader(str)) {
+      return unescapeChunksAsync(str);
+    }
+  }
+  return markHTMLString(str);
+}
+
+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;
+}
+
+var idle_prebuilt_default = `(self.Astro=self.Astro||{}).idle=t=>{const e=async()=>{await(await t())()};"requestIdleCallback"in window?window.requestIdleCallback(e):setTimeout(e,200)},window.dispatchEvent(new Event("astro:idle"));`;
+
+var load_prebuilt_default = `(self.Astro=self.Astro||{}).load=a=>{(async()=>await(await a())())()},window.dispatchEvent(new Event("astro:load"));`;
+
+var media_prebuilt_default = `(self.Astro=self.Astro||{}).media=(s,a)=>{const t=async()=>{await(await s())()};if(a.value){const e=matchMedia(a.value);e.matches?t():e.addEventListener("change",t,{once:!0})}},window.dispatchEvent(new Event("astro:media"));`;
+
+var only_prebuilt_default = `(self.Astro=self.Astro||{}).only=t=>{(async()=>await(await t())())()},window.dispatchEvent(new Event("astro:only"));`;
+
+var visible_prebuilt_default = `(self.Astro=self.Astro||{}).visible=(s,c,n)=>{const r=async()=>{await(await s())()};let i=new IntersectionObserver(e=>{for(const t of e)if(!!t.isIntersecting){i.disconnect(),r();break}});for(let e=0;e<n.children.length;e++){const t=n.children[e];i.observe(t)}},window.dispatchEvent(new Event("astro:visible"));`;
+
+var astro_island_prebuilt_default = `var l;{const c={0:t=>t,1:t=>JSON.parse(t,o),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(JSON.parse(t,o)),5:t=>new Set(JSON.parse(t,o)),6:t=>BigInt(t),7:t=>new URL(t),8:t=>new Uint8Array(JSON.parse(t)),9:t=>new Uint16Array(JSON.parse(t)),10:t=>new Uint32Array(JSON.parse(t))},o=(t,s)=>{if(t===""||!Array.isArray(s))return s;const[e,n]=s;return e in c?c[e](n):void 0};customElements.get("astro-island")||customElements.define("astro-island",(l=class extends HTMLElement{constructor(){super(...arguments);this.hydrate=()=>{if(!this.hydrator||this.parentElement&&this.parentElement.closest("astro-island[ssr]"))return;const s=this.querySelectorAll("astro-slot"),e={},n=this.querySelectorAll("template[data-astro-template]");for(const r of n){const i=r.closest(this.tagName);!i||!i.isSameNode(this)||(e[r.getAttribute("data-astro-template")||"default"]=r.innerHTML,r.remove())}for(const r of s){const i=r.closest(this.tagName);!i||!i.isSameNode(this)||(e[r.getAttribute("name")||"default"]=r.innerHTML)}const a=this.hasAttribute("props")?JSON.parse(this.getAttribute("props"),o):{};this.hydrator(this)(this.Component,a,e,{client:this.getAttribute("client")}),this.removeAttribute("ssr"),window.removeEventListener("astro:hydrate",this.hydrate),window.dispatchEvent(new CustomEvent("astro:hydrate"))}}connectedCallback(){!this.hasAttribute("await-children")||this.firstChild?this.childrenConnectedCallback():new MutationObserver((s,e)=>{e.disconnect(),this.childrenConnectedCallback()}).observe(this,{childList:!0})}async childrenConnectedCallback(){window.addEventListener("astro:hydrate",this.hydrate);let s=this.getAttribute("before-hydration-url");s&&await import(s),this.start()}start(){const s=JSON.parse(this.getAttribute("opts")),e=this.getAttribute("client");if(Astro[e]===void 0){window.addEventListener(\`astro:\${e}\`,()=>this.start(),{once:!0});return}Astro[e](async()=>{const n=this.getAttribute("renderer-url"),[a,{default:r}]=await Promise.all([import(this.getAttribute("component-url")),n?import(n):()=>()=>{}]),i=this.getAttribute("component-export")||"default";if(!i.includes("."))this.Component=a[i];else{this.Component=a;for(const d of i.split("."))this.Component=this.Component[d]}return this.hydrator=r,this.hydrate},s,this)}attributeChangedCallback(){this.hydrator&&this.hydrate()}},l.observedAttributes=["props"],l))}`;
+
+function determineIfNeedsHydrationScript(result) {
+  if (result._metadata.hasHydrationScript) {
+    return false;
+  }
+  return result._metadata.hasHydrationScript = true;
+}
+const hydrationScripts = {
+  idle: idle_prebuilt_default,
+  load: load_prebuilt_default,
+  only: only_prebuilt_default,
+  media: media_prebuilt_default,
+  visible: visible_prebuilt_default
+};
+function determinesIfNeedsDirectiveScript(result, directive) {
+  if (result._metadata.hasDirectives.has(directive)) {
+    return false;
+  }
+  result._metadata.hasDirectives.add(directive);
+  return true;
+}
+function getDirectiveScriptText(directive) {
+  if (!(directive in hydrationScripts)) {
+    throw new Error(`Unknown directive: ${directive}`);
+  }
+  const directiveScriptText = hydrationScripts[directive];
+  return directiveScriptText;
+}
+function getPrescripts(type, directive) {
+  switch (type) {
+    case "both":
+      return `<style>astro-island,astro-slot{display:contents}</style><script>${getDirectiveScriptText(directive) + astro_island_prebuilt_default}<\/script>`;
+    case "directive":
+      return `<script>${getDirectiveScriptText(directive)}<\/script>`;
+  }
+  return "";
+}
+
+const headAndContentSym = Symbol.for("astro.headAndContent");
+function isHeadAndContent(obj) {
+  return typeof obj === "object" && !!obj[headAndContentSym];
+}
+
+var _a$1;
+const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
+class RenderTemplateResult {
+  constructor(htmlParts, expressions) {
+    this[_a$1] = true;
+    this.htmlParts = htmlParts;
+    this.error = void 0;
+    this.expressions = expressions.map((expression) => {
+      if (isPromise(expression)) {
+        return Promise.resolve(expression).catch((err) => {
+          if (!this.error) {
+            this.error = err;
+            throw err;
+          }
+        });
+      }
+      return expression;
+    });
+  }
+  async *[(_a$1 = renderTemplateResultSym, Symbol.asyncIterator)]() {
+    const { htmlParts, expressions } = this;
+    for (let i = 0; i < htmlParts.length; i++) {
+      const html = htmlParts[i];
+      const expression = expressions[i];
+      yield markHTMLString(html);
+      yield* renderChild(expression);
+    }
+  }
+}
+function isRenderTemplateResult(obj) {
+  return typeof obj === "object" && !!obj[renderTemplateResultSym];
+}
+async function* renderAstroTemplateResult(component) {
+  for await (const value of component) {
+    if (value || value === 0) {
+      for await (const chunk of renderChild(value)) {
+        switch (chunk.type) {
+          case "directive": {
+            yield chunk;
+            break;
+          }
+          default: {
+            yield markHTMLString(chunk);
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+function renderTemplate(htmlParts, ...expressions) {
+  return new RenderTemplateResult(htmlParts, expressions);
+}
+
+function isAstroComponentFactory(obj) {
+  return obj == null ? false : obj.isAstroComponentFactory === true;
+}
+async function renderToString(result, componentFactory, props, children) {
+  const factoryResult = await componentFactory(result, props, children);
+  if (factoryResult instanceof Response) {
+    const response = factoryResult;
+    throw response;
+  }
+  let parts = new HTMLParts();
+  const templateResult = isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
+  for await (const chunk of renderAstroTemplateResult(templateResult)) {
+    parts.append(chunk, result);
+  }
+  return parts.toString();
+}
+function isAPropagatingComponent(result, factory) {
+  let hint = factory.propagation || "none";
+  if (factory.moduleId && result.propagation.has(factory.moduleId) && hint === "none") {
+    hint = result.propagation.get(factory.moduleId);
+  }
+  return hint === "in-tree" || hint === "self";
+}
+
+const defineErrors = (errs) => errs;
+const AstroErrorData = defineErrors({
+  UnknownCompilerError: {
+    title: "Unknown compiler error.",
+    code: 1e3,
+    hint: "This is almost always a problem with the Astro compiler, not your code. Please open an issue at https://astro.build/issues/compiler."
+  },
+  StaticRedirectNotAvailable: {
+    title: "`Astro.redirect` is not available in static mode.",
+    code: 3001,
+    message: "Redirects are only available when using `output: 'server'`. Update your Astro config if you need SSR features.",
+    hint: "See https://docs.astro.build/en/guides/server-side-rendering/#enabling-ssr-in-your-project for more information on how to enable SSR."
+  },
+  ClientAddressNotAvailable: {
+    title: "`Astro.clientAddress` is not available in current adapter.",
+    code: 3002,
+    message: (adapterName) => `\`Astro.clientAddress\` is not available in the \`${adapterName}\` adapter. File an issue with the adapter to add support.`
+  },
+  StaticClientAddressNotAvailable: {
+    title: "`Astro.clientAddress` is not available in static mode.",
+    code: 3003,
+    message: "`Astro.clientAddress` is only available when using `output: 'server'`. Update your Astro config if you need SSR features.",
+    hint: "See https://docs.astro.build/en/guides/server-side-rendering/#enabling-ssr-in-your-project for more information on how to enable SSR."
+  },
+  NoMatchingStaticPathFound: {
+    title: "No static path found for requested path.",
+    code: 3004,
+    message: (pathName) => `A \`getStaticPaths()\` route pattern was matched, but no matching static path was found for requested path \`${pathName}\`.`,
+    hint: (possibleRoutes) => `Possible dynamic routes being matched: ${possibleRoutes.join(", ")}.`
+  },
+  OnlyResponseCanBeReturned: {
+    title: "Invalid type returned by Astro page.",
+    code: 3005,
+    message: (route, returnedValue) => `Route \`${route ? route : ""}\` returned a \`${returnedValue}\`. Only a [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) can be returned from Astro files.`,
+    hint: "See https://docs.astro.build/en/guides/server-side-rendering/#response for more information."
+  },
+  MissingMediaQueryDirective: {
+    title: "Missing value for `client:media` directive.",
+    code: 3006,
+    message: 'Media query not provided for `client:media` directive. A media query similar to `client:media="(max-width: 600px)"` must be provided'
+  },
+  NoMatchingRenderer: {
+    title: "No matching renderer found.",
+    code: 3007,
+    message: (componentName, componentExtension, plural, validRenderersCount) => `Unable to render \`${componentName}\`.
+
+${validRenderersCount > 0 ? `There ${plural ? "are." : "is."} ${validRenderersCount} renderer${plural ? "s." : ""} configured in your \`astro.config.mjs\` file,
+but ${plural ? "none were." : "it was not."} able to server-side render \`${componentName}\`.` : `No valid renderer was found ${componentExtension ? `for the \`.${componentExtension}\` file extension.` : `for this file extension.`}`}`,
+    hint: (probableRenderers) => `Did you mean to enable the ${probableRenderers} integration?
+
+See https://docs.astro.build/en/core-concepts/framework-components/ for more information on how to install and configure integrations.`
+  },
+  NoClientEntrypoint: {
+    title: "No client entrypoint specified in renderer.",
+    code: 3008,
+    message: (componentName, clientDirective, rendererName) => `\`${componentName}\` component has a \`client:${clientDirective}\` directive, but no client entrypoint was provided by \`${rendererName}\`.`,
+    hint: "See https://docs.astro.build/en/reference/integrations-reference/#addrenderer-option for more information on how to configure your renderer."
+  },
+  NoClientOnlyHint: {
+    title: "Missing hint on client:only directive.",
+    code: 3009,
+    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`
+  },
+  InvalidGetStaticPathParam: {
+    title: "Invalid value returned by a `getStaticPaths` path.",
+    code: 3010,
+    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."
+  },
+  InvalidGetStaticPathsReturn: {
+    title: "Invalid value returned by getStaticPaths.",
+    code: 3011,
+    message: (returnType) => `Invalid type returned by \`getStaticPaths\`. Expected an \`array\`, got \`${returnType}\``,
+    hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths."
+  },
+  GetStaticPathsRemovedRSSHelper: {
+    title: "getStaticPaths RSS helper is not available anymore.",
+    code: 3012,
+    message: "The RSS helper has been removed from `getStaticPaths`. Try the new @astrojs/rss package instead.",
+    hint: "See https://docs.astro.build/en/guides/rss/ for more information."
+  },
+  GetStaticPathsExpectedParams: {
+    title: "Missing params property on `getStaticPaths` route.",
+    code: 3013,
+    message: "Missing or empty required `params` property on `getStaticPaths` route.",
+    hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths."
+  },
+  GetStaticPathsInvalidRouteParam: {
+    title: "Invalid value for `getStaticPaths` route parameter.",
+    code: 3014,
+    message: (key, value, valueType) => `Invalid getStaticPaths route parameter for \`${key}\`. Expected undefined, a string or a number, received \`${valueType}\` (\`${value}\`)`,
+    hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths."
+  },
+  GetStaticPathsRequired: {
+    title: "`getStaticPaths()` function required for dynamic routes.",
+    code: 3015,
+    message: "`getStaticPaths()` function is required for dynamic routes. Make sure that you `export` a `getStaticPaths` function from your dynamic route.",
+    hint: `See https://docs.astro.build/en/core-concepts/routing/#dynamic-routes for more information on dynamic routes.
+
+Alternatively, set \`output: "server"\` in your Astro config file to switch to a non-static server build. This error can also occur if using \`export const prerender = true;\`.
+See https://docs.astro.build/en/guides/server-side-rendering/ for more information on non-static rendering.`
+  },
+  ReservedSlotName: {
+    title: "Invalid slot name.",
+    code: 3016,
+    message: (slotName) => `Unable to create a slot named \`${slotName}\`. \`${slotName}\` is a reserved slot name. Please update the name of this slot.`
+  },
+  NoAdapterInstalled: {
+    title: "Cannot use Server-side Rendering without an adapter.",
+    code: 3017,
+    message: `Cannot use \`output: 'server'\` without an adapter. Please install and configure the appropriate server adapter for your final deployment.`,
+    hint: "See https://docs.astro.build/en/guides/server-side-rendering/ for more information."
+  },
+  NoMatchingImport: {
+    title: "No import found for component.",
+    code: 3018,
+    message: (componentName) => `Could not render \`${componentName}\`. No matching import has been found for \`${componentName}\`.`,
+    hint: "Please make sure the component is properly imported."
+  },
+  InvalidPrerenderExport: {
+    title: "Invalid prerender export.",
+    code: 3019,
+    message: (prefix, suffix) => {
+      let msg = `A \`prerender\` export has been detected, but its value cannot be statically analyzed.`;
+      if (prefix !== "const")
+        msg += `
+Expected \`const\` declaration but got \`${prefix}\`.`;
+      if (suffix !== "true")
+        msg += `
+Expected \`true\` value but got \`${suffix}\`.`;
+      return msg;
+    },
+    hint: "Mutable values declared at runtime are not supported. Please make sure to use exactly `export const prerender = true`."
+  },
+  UnknownViteError: {
+    title: "Unknown Vite Error.",
+    code: 4e3
+  },
+  FailedToLoadModuleSSR: {
+    title: "Could not import file.",
+    code: 4001,
+    message: (importName) => `Could not import \`${importName}\`.`,
+    hint: "This is often caused by a typo in the import path. Please make sure the file exists."
+  },
+  InvalidGlob: {
+    title: "Invalid glob pattern.",
+    code: 4002,
+    message: (globPattern) => `Invalid glob pattern: \`${globPattern}\`. Glob patterns must start with './', '../' or '/'.`,
+    hint: "See https://docs.astro.build/en/guides/imports/#glob-patterns for more information on supported glob patterns."
+  },
+  UnknownCSSError: {
+    title: "Unknown CSS Error.",
+    code: 5e3
+  },
+  CSSSyntaxError: {
+    title: "CSS Syntax Error.",
+    code: 5001
+  },
+  UnknownMarkdownError: {
+    title: "Unknown Markdown Error.",
+    code: 6e3
+  },
+  MarkdownFrontmatterParseError: {
+    title: "Failed to parse Markdown frontmatter.",
+    code: 6001
+  },
+  InvalidFrontmatterInjectionError: {
+    title: "Invalid frontmatter injection.",
+    code: 6003,
+    message: 'A remark or rehype plugin attempted to inject invalid frontmatter. Ensure "astro.frontmatter" is set to a valid JSON object that is not `null` or `undefined`.',
+    hint: "See the frontmatter injection docs https://docs.astro.build/en/guides/markdown-content/#modifying-frontmatter-programmatically for more information."
+  },
+  MdxIntegrationMissingError: {
+    title: "MDX integration missing.",
+    code: 6004,
+    message: (file) => `Unable to render ${file}. Ensure that the \`@astrojs/mdx\` integration is installed.`,
+    hint: "See the MDX integration docs for installation and usage instructions: https://docs.astro.build/en/guides/integrations-guide/mdx/"
+  },
+  UnknownConfigError: {
+    title: "Unknown configuration error.",
+    code: 7e3
+  },
+  ConfigNotFound: {
+    title: "Specified configuration file not found.",
+    code: 7001,
+    message: (configFile) => `Unable to resolve \`--config "${configFile}"\`. Does the file exist?`
+  },
+  ConfigLegacyKey: {
+    title: "Legacy configuration detected.",
+    code: 7002,
+    message: (legacyConfigKey) => `Legacy configuration detected: \`${legacyConfigKey}\`.`,
+    hint: "Please update your configuration to the new format.\nSee https://astro.build/config for more information."
+  },
+  UnknownCLIError: {
+    title: "Unknown CLI Error.",
+    code: 8e3
+  },
+  GenerateContentTypesError: {
+    title: "Failed to generate content types.",
+    code: 8001,
+    message: "`astro sync` command failed to generate content collection types.",
+    hint: "Check your `src/content/config.*` file for typos."
+  },
+  UnknownContentCollectionError: {
+    title: "Unknown Content Collection Error.",
+    code: 9e3
+  },
+  InvalidContentEntryFrontmatterError: {
+    title: "Content entry frontmatter does not match schema.",
+    code: 9001,
+    message: (collection, entryId, error) => {
+      return [
+        `${String(collection)} \u2192 ${String(entryId)} frontmatter does not match collection schema.`,
+        ...error.errors.map((zodError) => zodError.message)
+      ].join("\n");
+    },
+    hint: "See https://docs.astro.build/en/guides/content-collections/ for more information on content schemas."
+  },
+  InvalidContentEntrySlugError: {
+    title: "Invalid content entry slug.",
+    code: 9002,
+    message: (collection, entryId) => {
+      return `${String(collection)} \u2192 ${String(
+        entryId
+      )} has an invalid slug. \`slug\` must be a string.`;
+    },
+    hint: "See https://docs.astro.build/en/guides/content-collections/ for more on the `slug` field."
+  },
+  ContentSchemaContainsSlugError: {
+    title: "Content Schema should not contain `slug`.",
+    code: 9003,
+    message: (collection) => {
+      return `A content collection schema should not contain \`slug\` since it is reserved for slug generation. Remove this from your ${collection} collection schema.`;
+    },
+    hint: "See https://docs.astro.build/en/guides/content-collections/ for more on the `slug` field."
+  },
+  UnknownError: {
+    title: "Unknown Error.",
+    code: 99999
+  }
+});
+
+function normalizeLF(code) {
+  return code.replace(/\r\n|\r(?!\n)|\n/g, "\n");
+}
+function getErrorDataByCode(code) {
+  const entry = Object.entries(AstroErrorData).find((data) => data[1].code === code);
+  if (entry) {
+    return {
+      name: entry[0],
+      data: entry[1]
+    };
+  }
+}
+
+function codeFrame(src, loc) {
+  if (!loc || loc.line === void 0 || loc.column === void 0) {
+    return "";
+  }
+  const lines = normalizeLF(src).split("\n").map((ln) => ln.replace(/\t/g, "  "));
+  const visibleLines = [];
+  for (let n = -2; n <= 2; n++) {
+    if (lines[loc.line + n])
+      visibleLines.push(loc.line + n);
+  }
+  let gutterWidth = 0;
+  for (const lineNo of visibleLines) {
+    let w = `> ${lineNo}`;
+    if (w.length > gutterWidth)
+      gutterWidth = w.length;
+  }
+  let output = "";
+  for (const lineNo of visibleLines) {
+    const isFocusedLine = lineNo === loc.line - 1;
+    output += isFocusedLine ? "> " : "  ";
+    output += `${lineNo + 1} | ${lines[lineNo]}
+`;
+    if (isFocusedLine)
+      output += `${Array.from({ length: gutterWidth }).join(" ")}  | ${Array.from({
+        length: loc.column
+      }).join(" ")}^
+`;
+  }
+  return output;
+}
+
+class AstroError extends Error {
+  constructor(props, ...params) {
+    var _a;
+    super(...params);
+    this.type = "AstroError";
+    const { code, name, title, message, stack, location, hint, frame } = props;
+    this.errorCode = code;
+    if (name && name !== "Error") {
+      this.name = name;
+    } else {
+      this.name = ((_a = getErrorDataByCode(this.errorCode)) == null ? void 0 : _a.name) ?? "UnknownError";
+    }
+    this.title = title;
+    if (message)
+      this.message = message;
+    this.stack = stack ? stack : this.stack;
+    this.loc = location;
+    this.hint = hint;
+    this.frame = frame;
+  }
+  setErrorCode(errorCode) {
+    this.errorCode = errorCode;
+  }
+  setLocation(location) {
+    this.loc = location;
+  }
+  setName(name) {
+    this.name = name;
+  }
+  setMessage(message) {
+    this.message = message;
+  }
+  setHint(hint) {
+    this.hint = hint;
+  }
+  setFrame(source, location) {
+    this.frame = codeFrame(source, location);
+  }
+  static is(err) {
+    return err.type === "AstroError";
+  }
+}
+
+const PROP_TYPE = {
+  Value: 0,
+  JSON: 1,
+  RegExp: 2,
+  Date: 3,
+  Map: 4,
+  Set: 5,
+  BigInt: 6,
+  URL: 7,
+  Uint8Array: 8,
+  Uint16Array: 9,
+  Uint32Array: 10
+};
+function serializeArray(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
+    throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
+
+Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
+  }
+  parents.add(value);
+  const serialized = value.map((v) => {
+    return convertToSerializedForm(v, metadata, parents);
+  });
+  parents.delete(value);
+  return serialized;
+}
+function serializeObject(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
+    throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
+
+Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
+  }
+  parents.add(value);
+  const serialized = Object.fromEntries(
+    Object.entries(value).map(([k, v]) => {
+      return [k, convertToSerializedForm(v, metadata, parents)];
+    })
+  );
+  parents.delete(value);
+  return serialized;
+}
+function convertToSerializedForm(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  const tag = Object.prototype.toString.call(value);
+  switch (tag) {
+    case "[object Date]": {
+      return [PROP_TYPE.Date, value.toISOString()];
+    }
+    case "[object RegExp]": {
+      return [PROP_TYPE.RegExp, value.source];
+    }
+    case "[object Map]": {
+      return [
+        PROP_TYPE.Map,
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
+      ];
+    }
+    case "[object Set]": {
+      return [
+        PROP_TYPE.Set,
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
+      ];
+    }
+    case "[object BigInt]": {
+      return [PROP_TYPE.BigInt, value.toString()];
+    }
+    case "[object URL]": {
+      return [PROP_TYPE.URL, value.toString()];
+    }
+    case "[object Array]": {
+      return [PROP_TYPE.JSON, JSON.stringify(serializeArray(value, metadata, parents))];
+    }
+    case "[object Uint8Array]": {
+      return [PROP_TYPE.Uint8Array, JSON.stringify(Array.from(value))];
+    }
+    case "[object Uint16Array]": {
+      return [PROP_TYPE.Uint16Array, JSON.stringify(Array.from(value))];
+    }
+    case "[object Uint32Array]": {
+      return [PROP_TYPE.Uint32Array, JSON.stringify(Array.from(value))];
+    }
+    default: {
+      if (value !== null && typeof value === "object") {
+        return [PROP_TYPE.Value, serializeObject(value, metadata, parents)];
+      } else {
+        return [PROP_TYPE.Value, value];
+      }
+    }
+  }
+}
+function serializeProps(props, metadata) {
+  const serialized = JSON.stringify(serializeObject(props, metadata));
+  return serialized;
+}
+
+const HydrationDirectivesRaw = ["load", "idle", "media", "visible", "only"];
+const HydrationDirectives = new Set(HydrationDirectivesRaw);
+const HydrationDirectiveProps = new Set(HydrationDirectivesRaw.map((n) => `client:${n}`));
+function extractDirectives(displayName, inputProps) {
+  let extracted = {
+    isPage: false,
+    hydration: null,
+    props: {}
+  };
+  for (const [key, value] of Object.entries(inputProps)) {
+    if (key.startsWith("server:")) {
+      if (key === "server:root") {
+        extracted.isPage = true;
+      }
+    }
+    if (key.startsWith("client:")) {
+      if (!extracted.hydration) {
+        extracted.hydration = {
+          directive: "",
+          value: "",
+          componentUrl: "",
+          componentExport: { value: "" }
+        };
+      }
+      switch (key) {
+        case "client:component-path": {
+          extracted.hydration.componentUrl = value;
+          break;
+        }
+        case "client:component-export": {
+          extracted.hydration.componentExport.value = value;
+          break;
+        }
+        case "client:component-hydration": {
+          break;
+        }
+        case "client:display-name": {
+          break;
+        }
+        default: {
+          extracted.hydration.directive = key.split(":")[1];
+          extracted.hydration.value = value;
+          if (!HydrationDirectives.has(extracted.hydration.directive)) {
+            throw new Error(
+              `Error: invalid hydration directive "${key}". Supported hydration methods: ${Array.from(
+                HydrationDirectiveProps
+              ).join(", ")}`
+            );
+          }
+          if (extracted.hydration.directive === "media" && typeof extracted.hydration.value !== "string") {
+            throw new AstroError(AstroErrorData.MissingMediaQueryDirective);
+          }
+          break;
+        }
+      }
+    } else if (key === "class:list") {
+      if (value) {
+        extracted.props[key.slice(0, -5)] = serializeListValue(value);
+      }
+    } else {
+      extracted.props[key] = value;
+    }
+  }
+  for (const sym of Object.getOwnPropertySymbols(inputProps)) {
+    extracted.props[sym] = inputProps[sym];
+  }
+  return extracted;
+}
+async function generateHydrateScript(scriptOptions, metadata) {
+  const { renderer, result, astroId, props, attrs } = scriptOptions;
+  const { hydrate, componentUrl, componentExport } = metadata;
+  if (!componentExport.value) {
+    throw new Error(
+      `Unable to resolve a valid export for "${metadata.displayName}"! Please open an issue at https://astro.build/issues!`
+    );
+  }
+  const island = {
+    children: "",
+    props: {
+      uid: astroId
+    }
+  };
+  if (attrs) {
+    for (const [key, value] of Object.entries(attrs)) {
+      island.props[key] = escapeHTML(value);
+    }
+  }
+  island.props["component-url"] = await result.resolve(decodeURI(componentUrl));
+  if (renderer.clientEntrypoint) {
+    island.props["component-export"] = componentExport.value;
+    island.props["renderer-url"] = await result.resolve(decodeURI(renderer.clientEntrypoint));
+    island.props["props"] = escapeHTML(serializeProps(props, metadata));
+  }
+  island.props["ssr"] = "";
+  island.props["client"] = hydrate;
+  let beforeHydrationUrl = await result.resolve("astro:scripts/before-hydration.js");
+  if (beforeHydrationUrl.length) {
+    island.props["before-hydration-url"] = beforeHydrationUrl;
+  }
+  island.props["opts"] = escapeHTML(
+    JSON.stringify({
+      name: metadata.displayName,
+      value: metadata.hydrateArgs || ""
+    })
+  );
+  return island;
+}
+
+var _a;
+const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
+class AstroComponentInstance {
+  constructor(result, props, slots, factory) {
+    this[_a] = true;
+    this.result = result;
+    this.props = props;
+    this.factory = factory;
+    this.slotValues = {};
+    for (const name in slots) {
+      this.slotValues[name] = slots[name]();
+    }
+  }
+  async init() {
+    this.returnValue = this.factory(this.result, this.props, this.slotValues);
+    return this.returnValue;
+  }
+  async *render() {
+    if (this.returnValue === void 0) {
+      await this.init();
+    }
+    let value = this.returnValue;
+    if (isPromise(value)) {
+      value = await value;
+    }
+    if (isHeadAndContent(value)) {
+      yield* value.content;
+    } else {
+      yield* renderChild(value);
+    }
+  }
+}
+_a = astroComponentInstanceSym;
+function validateComponentProps(props, displayName) {
+  if (props != null) {
+    for (const prop of Object.keys(props)) {
+      if (HydrationDirectiveProps.has(prop)) {
+        console.warn(
+          `You are attempting to render <${displayName} ${prop} />, but ${displayName} is an Astro component. Astro components do not render in the client and should not have a hydration directive. Please use a framework component for client rendering.`
+        );
+      }
+    }
+  }
+}
+function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
+  validateComponentProps(props, displayName);
+  const instance = new AstroComponentInstance(result, props, slots, factory);
+  if (isAPropagatingComponent(result, factory) && !result.propagators.has(factory)) {
+    result.propagators.set(factory, instance);
+  }
+  return instance;
+}
+function isAstroComponentInstance(obj) {
+  return typeof obj === "object" && !!obj[astroComponentInstanceSym];
+}
+
+async function* renderChild(child) {
+  child = await child;
+  if (child instanceof SlotString) {
+    if (child.instructions) {
+      yield* child.instructions;
+    }
+    yield child;
+  } else if (isHTMLString(child)) {
+    yield child;
+  } else if (Array.isArray(child)) {
+    for (const value of child) {
+      yield markHTMLString(await renderChild(value));
+    }
+  } else if (typeof child === "function") {
+    yield* renderChild(child());
+  } else if (typeof child === "string") {
+    yield markHTMLString(escapeHTML(child));
+  } else if (!child && child !== 0) ; else if (isRenderTemplateResult(child)) {
+    yield* renderAstroTemplateResult(child);
+  } else if (isAstroComponentInstance(child)) {
+    yield* child.render();
+  } else if (ArrayBuffer.isView(child)) {
+    yield child;
+  } else if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) {
+    yield* child;
+  } else {
+    yield child;
+  }
+}
+
+const slotString = Symbol.for("astro:slot-string");
+class SlotString extends HTMLString {
+  constructor(content, instructions) {
+    super(content);
+    this.instructions = instructions;
+    this[slotString] = true;
+  }
+}
+function isSlotString(str) {
+  return !!str[slotString];
+}
+async function renderSlot(_result, slotted, fallback) {
+  if (slotted) {
+    let iterator = renderChild(slotted);
+    let content = "";
+    let instructions = null;
+    for await (const chunk of iterator) {
+      if (chunk.type === "directive") {
+        if (instructions === null) {
+          instructions = [];
+        }
+        instructions.push(chunk);
+      } else {
+        content += chunk;
+      }
+    }
+    return markHTMLString(new SlotString(content, instructions));
+  }
+  return fallback;
+}
+async function renderSlots(result, slots = {}) {
+  let slotInstructions = null;
+  let children = {};
+  if (slots) {
+    await Promise.all(
+      Object.entries(slots).map(
+        ([key, value]) => renderSlot(result, value).then((output) => {
+          if (output.instructions) {
+            if (slotInstructions === null) {
+              slotInstructions = [];
+            }
+            slotInstructions.push(...output.instructions);
+          }
+          children[key] = output;
+        })
+      )
+    );
+  }
+  return { slotInstructions, children };
+}
+
+const Fragment = Symbol.for("astro:fragment");
+const Renderer = Symbol.for("astro:renderer");
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function stringifyChunk(result, chunk) {
+  switch (chunk.type) {
+    case "directive": {
+      const { hydration } = chunk;
+      let needsHydrationScript = hydration && determineIfNeedsHydrationScript(result);
+      let needsDirectiveScript = hydration && determinesIfNeedsDirectiveScript(result, hydration.directive);
+      let prescriptType = needsHydrationScript ? "both" : needsDirectiveScript ? "directive" : null;
+      if (prescriptType) {
+        let prescripts = getPrescripts(prescriptType, hydration.directive);
+        return markHTMLString(prescripts);
+      } else {
+        return "";
+      }
+    }
+    default: {
+      if (isSlotString(chunk)) {
+        let out = "";
+        const c = chunk;
+        if (c.instructions) {
+          for (const instr of c.instructions) {
+            out += stringifyChunk(result, instr);
+          }
+        }
+        out += chunk.toString();
+        return out;
+      }
+      return chunk.toString();
+    }
+  }
+}
+class HTMLParts {
+  constructor() {
+    this.parts = "";
+  }
+  append(part, result) {
+    if (ArrayBuffer.isView(part)) {
+      this.parts += decoder.decode(part);
+    } else {
+      this.parts += stringifyChunk(result, part);
+    }
+  }
+  toString() {
+    return this.parts;
+  }
+  toArrayBuffer() {
+    return encoder.encode(this.parts);
+  }
+}
+function chunkToByteArray(result, chunk) {
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  return encoder.encode(stringifyChunk(result, chunk));
+}
+
+const ClientOnlyPlaceholder = "astro-client-only";
+class Skip {
+  constructor(vnode) {
+    this.vnode = vnode;
+    this.count = 0;
+  }
+  increment() {
+    this.count++;
+  }
+  haveNoTried() {
+    return this.count === 0;
+  }
+  isCompleted() {
+    return this.count > 2;
+  }
+}
+Skip.symbol = Symbol("astro:jsx:skip");
+let originalConsoleError;
+let consoleFilterRefs = 0;
+async function renderJSX(result, vnode) {
+  switch (true) {
+    case vnode instanceof HTMLString:
+      if (vnode.toString().trim() === "") {
+        return "";
+      }
+      return vnode;
+    case typeof vnode === "string":
+      return markHTMLString(escapeHTML(vnode));
+    case typeof vnode === "function":
+      return vnode;
+    case (!vnode && vnode !== 0):
+      return "";
+    case Array.isArray(vnode):
+      return markHTMLString(
+        (await Promise.all(vnode.map((v) => renderJSX(result, v)))).join("")
+      );
+  }
+  let skip;
+  if (vnode.props) {
+    if (vnode.props[Skip.symbol]) {
+      skip = vnode.props[Skip.symbol];
+    } else {
+      skip = new Skip(vnode);
+    }
+  } else {
+    skip = new Skip(vnode);
+  }
+  return renderJSXVNode(result, vnode, skip);
+}
+async function renderJSXVNode(result, vnode, skip) {
+  if (isVNode(vnode)) {
+    switch (true) {
+      case !vnode.type: {
+        throw new Error(`Unable to render ${result._metadata.pathname} because it contains an undefined Component!
+Did you forget to import the component or is it possible there is a typo?`);
+      }
+      case vnode.type === Symbol.for("astro:fragment"):
+        return renderJSX(result, vnode.props.children);
+      case vnode.type.isAstroComponentFactory: {
+        let props = {};
+        let slots = {};
+        for (const [key, value] of Object.entries(vnode.props ?? {})) {
+          if (key === "children" || value && typeof value === "object" && value["$$slot"]) {
+            slots[key === "children" ? "default" : key] = () => renderJSX(result, value);
+          } else {
+            props[key] = value;
+          }
+        }
+        return markHTMLString(await renderToString(result, vnode.type, props, slots));
+      }
+      case (!vnode.type && vnode.type !== 0):
+        return "";
+      case (typeof vnode.type === "string" && vnode.type !== ClientOnlyPlaceholder):
+        return markHTMLString(await renderElement$1(result, vnode.type, vnode.props ?? {}));
+    }
+    if (vnode.type) {
+      let extractSlots2 = function(child) {
+        if (Array.isArray(child)) {
+          return child.map((c) => extractSlots2(c));
+        }
+        if (!isVNode(child)) {
+          _slots.default.push(child);
+          return;
+        }
+        if ("slot" in child.props) {
+          _slots[child.props.slot] = [..._slots[child.props.slot] ?? [], child];
+          delete child.props.slot;
+          return;
+        }
+        _slots.default.push(child);
+      };
+      if (typeof vnode.type === "function" && vnode.type["astro:renderer"]) {
+        skip.increment();
+      }
+      if (typeof vnode.type === "function" && vnode.props["server:root"]) {
+        const output2 = await vnode.type(vnode.props ?? {});
+        return await renderJSX(result, output2);
+      }
+      if (typeof vnode.type === "function") {
+        if (skip.haveNoTried() || skip.isCompleted()) {
+          useConsoleFilter();
+          try {
+            const output2 = await vnode.type(vnode.props ?? {});
+            let renderResult;
+            if (output2 && output2[AstroJSX]) {
+              renderResult = await renderJSXVNode(result, output2, skip);
+              return renderResult;
+            } else if (!output2) {
+              renderResult = await renderJSXVNode(result, output2, skip);
+              return renderResult;
+            }
+          } catch (e) {
+            if (skip.isCompleted()) {
+              throw e;
+            }
+            skip.increment();
+          } finally {
+            finishUsingConsoleFilter();
+          }
+        } else {
+          skip.increment();
+        }
+      }
+      const { children = null, ...props } = vnode.props ?? {};
+      const _slots = {
+        default: []
+      };
+      extractSlots2(children);
+      for (const [key, value] of Object.entries(props)) {
+        if (value["$$slot"]) {
+          _slots[key] = value;
+          delete props[key];
+        }
+      }
+      const slotPromises = [];
+      const slots = {};
+      for (const [key, value] of Object.entries(_slots)) {
+        slotPromises.push(
+          renderJSX(result, value).then((output2) => {
+            if (output2.toString().trim().length === 0)
+              return;
+            slots[key] = () => output2;
+          })
+        );
+      }
+      await Promise.all(slotPromises);
+      props[Skip.symbol] = skip;
+      let output;
+      if (vnode.type === ClientOnlyPlaceholder && vnode.props["client:only"]) {
+        output = await renderComponentToIterable(
+          result,
+          vnode.props["client:display-name"] ?? "",
+          null,
+          props,
+          slots
+        );
+      } else {
+        output = await renderComponentToIterable(
+          result,
+          typeof vnode.type === "function" ? vnode.type.name : vnode.type,
+          vnode.type,
+          props,
+          slots
+        );
+      }
+      if (typeof output !== "string" && Symbol.asyncIterator in output) {
+        let parts = new HTMLParts();
+        for await (const chunk of output) {
+          parts.append(chunk, result);
+        }
+        return markHTMLString(parts.toString());
+      } else {
+        return markHTMLString(output);
+      }
+    }
+  }
+  return markHTMLString(`${vnode}`);
+}
+async function renderElement$1(result, tag, { children, ...props }) {
+  return markHTMLString(
+    `<${tag}${spreadAttributes(props)}${markHTMLString(
+      (children == null || children == "") && voidElementNames.test(tag) ? `/>` : `>${children == null ? "" : await renderJSX(result, children)}</${tag}>`
+    )}`
+  );
+}
+function useConsoleFilter() {
+  consoleFilterRefs++;
+  if (!originalConsoleError) {
+    originalConsoleError = console.error;
+    try {
+      console.error = filteredConsoleError;
+    } catch (error) {
+    }
+  }
+}
+function finishUsingConsoleFilter() {
+  consoleFilterRefs--;
+}
+function filteredConsoleError(msg, ...rest) {
+  if (consoleFilterRefs > 0 && typeof msg === "string") {
+    const isKnownReactHookError = msg.includes("Warning: Invalid hook call.") && msg.includes("https://reactjs.org/link/invalid-hook-call");
+    if (isKnownReactHookError)
+      return;
+  }
+  originalConsoleError(msg, ...rest);
+}
+
+/**
+ * shortdash - https://github.com/bibig/node-shorthash
+ *
+ * @license
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2013 Bibig <bibig@me.com>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+const dictionary = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXY";
+const binary = dictionary.length;
+function bitwise(str) {
+  let hash = 0;
+  if (str.length === 0)
+    return hash;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    hash = (hash << 5) - hash + ch;
+    hash = hash & hash;
+  }
+  return hash;
+}
+function shorthash(text) {
+  let num;
+  let result = "";
+  let integer = bitwise(text);
+  const sign = integer < 0 ? "Z" : "";
+  integer = Math.abs(integer);
+  while (integer >= binary) {
+    num = integer % binary;
+    integer = Math.floor(integer / binary);
+    result = dictionary[num] + result;
+  }
+  if (integer > 0) {
+    result = dictionary[integer] + result;
+  }
+  return sign + result;
+}
+
+const voidElementNames = /^(area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)$/i;
+const htmlBooleanAttributes = /^(allowfullscreen|async|autofocus|autoplay|controls|default|defer|disabled|disablepictureinpicture|disableremoteplayback|formnovalidate|hidden|loop|nomodule|novalidate|open|playsinline|readonly|required|reversed|scoped|seamless|itemscope)$/i;
+const htmlEnumAttributes = /^(contenteditable|draggable|spellcheck|value)$/i;
+const svgEnumAttributes = /^(autoReverse|externalResourcesRequired|focusable|preserveAlpha)$/i;
+const STATIC_DIRECTIVES = /* @__PURE__ */ new Set(["set:html", "set:text"]);
+const toIdent = (k) => k.trim().replace(/(?:(?!^)\b\w|\s+|[^\w]+)/g, (match, index) => {
+  if (/[^\w]|\s/.test(match))
+    return "";
+  return index === 0 ? match : match.toUpperCase();
+});
+const toAttributeString = (value, shouldEscape = true) => shouldEscape ? String(value).replace(/&/g, "&#38;").replace(/"/g, "&#34;") : value;
+const kebab = (k) => k.toLowerCase() === k ? k : k.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+const toStyleString = (obj) => Object.entries(obj).map(([k, v]) => `${kebab(k)}:${v}`).join(";");
+function defineScriptVars(vars) {
+  let output = "";
+  for (const [key, value] of Object.entries(vars)) {
+    output += `const ${toIdent(key)} = ${JSON.stringify(value)};
+`;
+  }
+  return markHTMLString(output);
+}
+function formatList(values) {
+  if (values.length === 1) {
+    return values[0];
+  }
+  return `${values.slice(0, -1).join(", ")} or ${values[values.length - 1]}`;
+}
+function addAttribute(value, key, shouldEscape = true) {
+  if (value == null) {
+    return "";
+  }
+  if (value === false) {
+    if (htmlEnumAttributes.test(key) || svgEnumAttributes.test(key)) {
+      return markHTMLString(` ${key}="false"`);
+    }
+    return "";
+  }
+  if (STATIC_DIRECTIVES.has(key)) {
+    console.warn(`[astro] The "${key}" directive cannot be applied dynamically at runtime. It will not be rendered as an attribute.
+
+Make sure to use the static attribute syntax (\`${key}={value}\`) instead of the dynamic spread syntax (\`{...{ "${key}": value }}\`).`);
+    return "";
+  }
+  if (key === "class:list") {
+    const listValue = toAttributeString(serializeListValue(value), shouldEscape);
+    if (listValue === "") {
+      return "";
+    }
+    return markHTMLString(` ${key.slice(0, -5)}="${listValue}"`);
+  }
+  if (key === "style" && !(value instanceof HTMLString) && typeof value === "object") {
+    return markHTMLString(` ${key}="${toAttributeString(toStyleString(value), shouldEscape)}"`);
+  }
+  if (key === "className") {
+    return markHTMLString(` class="${toAttributeString(value, shouldEscape)}"`);
+  }
+  if (value === true && (key.startsWith("data-") || htmlBooleanAttributes.test(key))) {
+    return markHTMLString(` ${key}`);
+  } else {
+    return markHTMLString(` ${key}="${toAttributeString(value, shouldEscape)}"`);
+  }
+}
+function internalSpreadAttributes(values, shouldEscape = true) {
+  let output = "";
+  for (const [key, value] of Object.entries(values)) {
+    output += addAttribute(value, key, shouldEscape);
+  }
+  return markHTMLString(output);
+}
+function renderElement(name, { props: _props, children = "" }, shouldEscape = true) {
+  const { lang: _, "data-astro-id": astroId, "define:vars": defineVars, ...props } = _props;
+  if (defineVars) {
+    if (name === "style") {
+      delete props["is:global"];
+      delete props["is:scoped"];
+    }
+    if (name === "script") {
+      delete props.hoist;
+      children = defineScriptVars(defineVars) + "\n" + children;
+    }
+  }
+  if ((children == null || children == "") && voidElementNames.test(name)) {
+    return `<${name}${internalSpreadAttributes(props, shouldEscape)} />`;
+  }
+  return `<${name}${internalSpreadAttributes(props, shouldEscape)}>${children}</${name}>`;
+}
+
+function componentIsHTMLElement(Component) {
+  return typeof HTMLElement !== "undefined" && HTMLElement.isPrototypeOf(Component);
+}
+async function renderHTMLElement(result, constructor, props, slots) {
+  const name = getHTMLElementName(constructor);
+  let attrHTML = "";
+  for (const attr in props) {
+    attrHTML += ` ${attr}="${toAttributeString(await props[attr])}"`;
+  }
+  return markHTMLString(
+    `<${name}${attrHTML}>${await renderSlot(result, slots == null ? void 0 : slots.default)}</${name}>`
+  );
+}
+function getHTMLElementName(constructor) {
+  const definedName = customElements.getName(constructor);
+  if (definedName)
+    return definedName;
+  const assignedName = constructor.name.replace(/^HTML|Element$/g, "").replace(/[A-Z]/g, "-$&").toLowerCase().replace(/^-/, "html-");
+  return assignedName;
+}
+
+const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]);
+function guessRenderers(componentUrl) {
+  const extname = componentUrl == null ? void 0 : componentUrl.split(".").pop();
+  switch (extname) {
+    case "svelte":
+      return ["@astrojs/svelte"];
+    case "vue":
+      return ["@astrojs/vue"];
+    case "jsx":
+    case "tsx":
+      return ["@astrojs/react", "@astrojs/preact", "@astrojs/solid-js", "@astrojs/vue (jsx)"];
+    default:
+      return [
+        "@astrojs/react",
+        "@astrojs/preact",
+        "@astrojs/solid-js",
+        "@astrojs/vue",
+        "@astrojs/svelte"
+      ];
+  }
+}
+function isFragmentComponent(Component) {
+  return Component === Fragment;
+}
+function isHTMLComponent(Component) {
+  return Component && typeof Component === "object" && Component["astro:html"];
+}
+async function renderFrameworkComponent(result, displayName, Component, _props, slots = {}) {
+  var _a, _b;
+  if (!Component && !_props["client:only"]) {
+    throw new Error(
+      `Unable to render ${displayName} because it is ${Component}!
+Did you forget to import the component or is it possible there is a typo?`
+    );
+  }
+  const { renderers } = result._metadata;
+  const metadata = { displayName };
+  const { hydration, isPage, props } = extractDirectives(displayName, _props);
+  let html = "";
+  let attrs = void 0;
+  if (hydration) {
+    metadata.hydrate = hydration.directive;
+    metadata.hydrateArgs = hydration.value;
+    metadata.componentExport = hydration.componentExport;
+    metadata.componentUrl = hydration.componentUrl;
+  }
+  const probableRendererNames = guessRenderers(metadata.componentUrl);
+  const validRenderers = renderers.filter((r) => r.name !== "astro:jsx");
+  const { children, slotInstructions } = await renderSlots(result, slots);
+  let renderer;
+  if (metadata.hydrate !== "only") {
+    let isTagged = false;
+    try {
+      isTagged = Component && Component[Renderer];
+    } catch {
+    }
+    if (isTagged) {
+      const rendererName = Component[Renderer];
+      renderer = renderers.find(({ name }) => name === rendererName);
+    }
+    if (!renderer) {
+      let error;
+      for (const r of renderers) {
+        try {
+          if (await r.ssr.check.call({ result }, Component, props, children)) {
+            renderer = r;
+            break;
+          }
+        } catch (e) {
+          error ?? (error = e);
+        }
+      }
+      if (!renderer && error) {
+        throw error;
+      }
+    }
+    if (!renderer && typeof HTMLElement === "function" && componentIsHTMLElement(Component)) {
+      const output = renderHTMLElement(result, Component, _props, slots);
+      return output;
+    }
+  } else {
+    if (metadata.hydrateArgs) {
+      const passedName = metadata.hydrateArgs;
+      const rendererName = rendererAliases.has(passedName) ? rendererAliases.get(passedName) : passedName;
+      renderer = renderers.find(
+        ({ name }) => name === `@astrojs/${rendererName}` || name === rendererName
+      );
+    }
+    if (!renderer && validRenderers.length === 1) {
+      renderer = validRenderers[0];
+    }
+    if (!renderer) {
+      const extname = (_a = metadata.componentUrl) == null ? void 0 : _a.split(".").pop();
+      renderer = renderers.filter(
+        ({ name }) => name === `@astrojs/${extname}` || name === extname
+      )[0];
+    }
+  }
+  if (!renderer) {
+    if (metadata.hydrate === "only") {
+      throw new AstroError({
+        ...AstroErrorData.NoClientOnlyHint,
+        message: AstroErrorData.NoClientOnlyHint.message(metadata.displayName),
+        hint: AstroErrorData.NoClientOnlyHint.hint(
+          probableRendererNames.map((r) => r.replace("@astrojs/", "")).join("|")
+        )
+      });
+    } else if (typeof Component !== "string") {
+      const matchingRenderers = validRenderers.filter(
+        (r) => probableRendererNames.includes(r.name)
+      );
+      const plural = validRenderers.length > 1;
+      if (matchingRenderers.length === 0) {
+        throw new AstroError({
+          ...AstroErrorData.NoMatchingRenderer,
+          message: AstroErrorData.NoMatchingRenderer.message(
+            metadata.displayName,
+            (_b = metadata == null ? void 0 : metadata.componentUrl) == null ? void 0 : _b.split(".").pop(),
+            plural,
+            validRenderers.length
+          ),
+          hint: AstroErrorData.NoMatchingRenderer.hint(
+            formatList(probableRendererNames.map((r) => "`" + r + "`"))
+          )
+        });
+      } else if (matchingRenderers.length === 1) {
+        renderer = matchingRenderers[0];
+        ({ html, attrs } = await renderer.ssr.renderToStaticMarkup.call(
+          { result },
+          Component,
+          props,
+          children,
+          metadata
+        ));
+      } else {
+        throw new Error(`Unable to render ${metadata.displayName}!
+
+This component likely uses ${formatList(probableRendererNames)},
+but Astro encountered an error during server-side rendering.
+
+Please ensure that ${metadata.displayName}:
+1. Does not unconditionally access browser-specific globals like \`window\` or \`document\`.
+   If this is unavoidable, use the \`client:only\` hydration directive.
+2. Does not conditionally return \`null\` or \`undefined\` when rendered on the server.
+
+If you're still stuck, please open an issue on GitHub or join us at https://astro.build/chat.`);
+      }
+    }
+  } else {
+    if (metadata.hydrate === "only") {
+      html = await renderSlot(result, slots == null ? void 0 : slots.fallback);
+    } else {
+      ({ html, attrs } = await renderer.ssr.renderToStaticMarkup.call(
+        { result },
+        Component,
+        props,
+        children,
+        metadata
+      ));
+    }
+  }
+  if (renderer && !renderer.clientEntrypoint && renderer.name !== "@astrojs/lit" && metadata.hydrate) {
+    throw new AstroError({
+      ...AstroErrorData.NoClientEntrypoint,
+      message: AstroErrorData.NoClientEntrypoint.message(
+        displayName,
+        metadata.hydrate,
+        renderer.name
+      )
+    });
+  }
+  if (!html && typeof Component === "string") {
+    const Tag = sanitizeElementName(Component);
+    const childSlots = Object.values(children).join("");
+    const iterable = renderAstroTemplateResult(
+      await renderTemplate`<${Tag}${internalSpreadAttributes(props)}${markHTMLString(
+        childSlots === "" && voidElementNames.test(Tag) ? `/>` : `>${childSlots}</${Tag}>`
+      )}`
+    );
+    html = "";
+    for await (const chunk of iterable) {
+      html += chunk;
+    }
+  }
+  if (!hydration) {
+    return async function* () {
+      if (slotInstructions) {
+        yield* slotInstructions;
+      }
+      if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") {
+        yield html;
+      } else {
+        yield markHTMLString(html.replace(/\<\/?astro-slot\>/g, ""));
+      }
+    }();
+  }
+  const astroId = shorthash(
+    `<!--${metadata.componentExport.value}:${metadata.componentUrl}-->
+${html}
+${serializeProps(
+      props,
+      metadata
+    )}`
+  );
+  const island = await generateHydrateScript(
+    { renderer, result, astroId, props, attrs },
+    metadata
+  );
+  let unrenderedSlots = [];
+  if (html) {
+    if (Object.keys(children).length > 0) {
+      for (const key of Object.keys(children)) {
+        if (!html.includes(key === "default" ? `<astro-slot>` : `<astro-slot name="${key}">`)) {
+          unrenderedSlots.push(key);
+        }
+      }
+    }
+  } else {
+    unrenderedSlots = Object.keys(children);
+  }
+  const template = unrenderedSlots.length > 0 ? unrenderedSlots.map(
+    (key) => `<template data-astro-template${key !== "default" ? `="${key}"` : ""}>${children[key]}</template>`
+  ).join("") : "";
+  island.children = `${html ?? ""}${template}`;
+  if (island.children) {
+    island.props["await-children"] = "";
+  }
+  async function* renderAll() {
+    if (slotInstructions) {
+      yield* slotInstructions;
+    }
+    yield { type: "directive", hydration, result };
+    yield markHTMLString(renderElement("astro-island", island, false));
+  }
+  return renderAll();
+}
+function sanitizeElementName(tag) {
+  const unsafe = /[&<>'"\s]+/g;
+  if (!unsafe.test(tag))
+    return tag;
+  return tag.trim().split(unsafe)[0].trim();
+}
+async function renderFragmentComponent(result, slots = {}) {
+  const children = await renderSlot(result, slots == null ? void 0 : slots.default);
+  if (children == null) {
+    return children;
+  }
+  return markHTMLString(children);
+}
+async function renderHTMLComponent(result, Component, _props, slots = {}) {
+  const { slotInstructions, children } = await renderSlots(result, slots);
+  const html = Component.render({ slots: children });
+  const hydrationHtml = slotInstructions ? slotInstructions.map((instr) => stringifyChunk(result, instr)).join("") : "";
+  return markHTMLString(hydrationHtml + html);
+}
+function renderComponent(result, displayName, Component, props, slots = {}) {
+  if (isPromise(Component)) {
+    return Promise.resolve(Component).then((Unwrapped) => {
+      return renderComponent(result, displayName, Unwrapped, props, slots);
+    });
+  }
+  if (isFragmentComponent(Component)) {
+    return renderFragmentComponent(result, slots);
+  }
+  if (isHTMLComponent(Component)) {
+    return renderHTMLComponent(result, Component, props, slots);
+  }
+  if (isAstroComponentFactory(Component)) {
+    return createAstroComponentInstance(result, displayName, Component, props, slots);
+  }
+  return renderFrameworkComponent(result, displayName, Component, props, slots);
+}
+function renderComponentToIterable(result, displayName, Component, props, slots = {}) {
+  const renderResult = renderComponent(result, displayName, Component, props, slots);
+  if (isAstroComponentInstance(renderResult)) {
+    return renderResult.render();
+  }
+  return renderResult;
+}
+
+const uniqueElements = (item, index, all) => {
+  const props = JSON.stringify(item.props);
+  const children = item.children;
+  return index === all.findIndex((i) => JSON.stringify(i.props) === props && i.children == children);
+};
+async function* renderExtraHead(result, base) {
+  yield base;
+  for (const part of result.extraHead) {
+    yield* renderChild(part);
+  }
+}
+function renderAllHeadContent(result) {
+  const styles = Array.from(result.styles).filter(uniqueElements).map((style) => renderElement("style", style));
+  result.styles.clear();
+  const scripts = Array.from(result.scripts).filter(uniqueElements).map((script, i) => {
+    return renderElement("script", script, false);
+  });
+  const links = Array.from(result.links).filter(uniqueElements).map((link) => renderElement("link", link, false));
+  const baseHeadContent = markHTMLString(links.join("\n") + styles.join("\n") + scripts.join("\n"));
+  if (result.extraHead.length > 0) {
+    return renderExtraHead(result, baseHeadContent);
+  } else {
+    return baseHeadContent;
+  }
+}
+function createRenderHead(result) {
+  result._metadata.hasRenderedHead = true;
+  return renderAllHeadContent.bind(null, result);
+}
+const renderHead = createRenderHead;
+async function* maybeRenderHead(result) {
+  if (result._metadata.hasRenderedHead) {
+    return;
+  }
+  yield createRenderHead(result)();
+}
+
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (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$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+const isNodeJS = typeof process === "object" && Object.prototype.toString.call(process) === "[object process]";
+let StreamingCompatibleResponse;
+function createResponseClass() {
+  var _isStream, _body, _a;
+  StreamingCompatibleResponse = (_a = class extends Response {
+    constructor(body, init) {
+      let isStream = body instanceof ReadableStream;
+      super(isStream ? null : body, init);
+      __privateAdd$2(this, _isStream, void 0);
+      __privateAdd$2(this, _body, void 0);
+      __privateSet$2(this, _isStream, isStream);
+      __privateSet$2(this, _body, body);
+    }
+    get body() {
+      return __privateGet$2(this, _body);
+    }
+    async text() {
+      if (__privateGet$2(this, _isStream) && isNodeJS) {
+        let decoder = new TextDecoder();
+        let body = __privateGet$2(this, _body);
+        let out = "";
+        for await (let chunk of streamAsyncIterator(body)) {
+          out += decoder.decode(chunk);
+        }
+        return out;
+      }
+      return super.text();
+    }
+    async arrayBuffer() {
+      if (__privateGet$2(this, _isStream) && isNodeJS) {
+        let body = __privateGet$2(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();
+    }
+  }, _isStream = new WeakMap(), _body = new WeakMap(), _a);
+  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);
+
+const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
+function nonAstroPageNeedsHeadInjection(pageComponent) {
+  return needsHeadRenderingSymbol in pageComponent && !!pageComponent[needsHeadRenderingSymbol];
+}
+async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
+  const parts = new HTMLParts();
+  let i = 0;
+  for await (const chunk of iterable) {
+    if (isHTMLString(chunk)) {
+      if (i === 0) {
+        i++;
+        if (!/<!doctype html/i.test(String(chunk))) {
+          parts.append("<!DOCTYPE html>\n", result);
+          if (onDocTypeInjection) {
+            await onDocTypeInjection(parts);
+          }
+        }
+      }
+    }
+    parts.append(chunk, result);
+  }
+  return parts.toArrayBuffer();
+}
+async function bufferHeadContent(result) {
+  const iterator = result.propagators.values();
+  while (true) {
+    const { value, done } = iterator.next();
+    if (done) {
+      break;
+    }
+    const returnValue = await value.init();
+    if (isHeadAndContent(returnValue)) {
+      result.extraHead.push(returnValue.head);
+    }
+  }
+}
+async function renderPage$1(result, componentFactory, props, children, streaming, route) {
+  if (!isAstroComponentFactory(componentFactory)) {
+    const pageProps = { ...props ?? {}, "server:root": true };
+    let output;
+    try {
+      const renderResult = await renderComponent(
+        result,
+        componentFactory.name,
+        componentFactory,
+        pageProps,
+        null
+      );
+      if (isAstroComponentInstance(renderResult)) {
+        output = renderResult.render();
+      } else {
+        output = renderResult;
+      }
+    } catch (e) {
+      if (AstroError.is(e) && !e.loc) {
+        e.setLocation({
+          file: route == null ? void 0 : route.component
+        });
+      }
+      throw e;
+    }
+    const bytes = await iterableToHTMLBytes(result, output, async (parts) => {
+      if (nonAstroPageNeedsHeadInjection(componentFactory)) {
+        for await (let chunk of maybeRenderHead(result)) {
+          parts.append(chunk, result);
+        }
+      }
+    });
+    return new Response(bytes, {
+      headers: new Headers([
+        ["Content-Type", "text/html; charset=utf-8"],
+        ["Content-Length", bytes.byteLength.toString()]
+      ])
+    });
+  }
+  const factoryReturnValue = await componentFactory(result, props, children);
+  const factoryIsHeadAndContent = isHeadAndContent(factoryReturnValue);
+  if (isRenderTemplateResult(factoryReturnValue) || factoryIsHeadAndContent) {
+    await bufferHeadContent(result);
+    const templateResult = factoryIsHeadAndContent ? factoryReturnValue.content : factoryReturnValue;
+    let iterable = renderAstroTemplateResult(templateResult);
+    let init = result.response;
+    let headers = new Headers(init.headers);
+    let body;
+    if (streaming) {
+      body = new ReadableStream({
+        start(controller) {
+          async function read() {
+            let i = 0;
+            try {
+              for await (const chunk of iterable) {
+                if (isHTMLString(chunk)) {
+                  if (i === 0) {
+                    if (!/<!doctype html/i.test(String(chunk))) {
+                      controller.enqueue(encoder.encode("<!DOCTYPE html>\n"));
+                    }
+                  }
+                }
+                const bytes = chunkToByteArray(result, chunk);
+                controller.enqueue(bytes);
+                i++;
+              }
+              controller.close();
+            } catch (e) {
+              if (AstroError.is(e) && !e.loc) {
+                e.setLocation({
+                  file: route == null ? void 0 : route.component
+                });
+              }
+              controller.error(e);
+            }
+          }
+          read();
+        }
+      });
+    } else {
+      body = await iterableToHTMLBytes(result, iterable);
+      headers.set("Content-Length", body.byteLength.toString());
+    }
+    let response = createResponse(body, { ...init, headers });
+    return response;
+  }
+  if (!(factoryReturnValue instanceof Response)) {
+    throw new AstroError({
+      ...AstroErrorData.OnlyResponseCanBeReturned,
+      message: AstroErrorData.OnlyResponseCanBeReturned.message(
+        route == null ? void 0 : route.route,
+        typeof factoryReturnValue
+      ),
+      location: {
+        file: route == null ? void 0 : route.component
+      }
+    });
+  }
+  return factoryReturnValue;
+}
+
+function spreadAttributes(values, _name, { class: scopedClassName } = {}) {
+  let output = "";
+  if (scopedClassName) {
+    if (typeof values.class !== "undefined") {
+      values.class += ` ${scopedClassName}`;
+    } else if (typeof values["class:list"] !== "undefined") {
+      values["class:list"] = [values["class:list"], scopedClassName];
+    } else {
+      values.class = scopedClassName;
+    }
+  }
+  for (const [key, value] of Object.entries(values)) {
+    output += addAttribute(value, key, true);
+  }
+  return markHTMLString(output);
+}
+
+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 ;
+  }
+}
+
+const VALID_PARAM_TYPES = ["string", "number", "undefined"];
+function validateGetStaticPathsParameter([key, value], route) {
+  if (!VALID_PARAM_TYPES.includes(typeof value)) {
+    throw new AstroError({
+      ...AstroErrorData.GetStaticPathsInvalidRouteParam,
+      message: AstroErrorData.GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
+      location: {
+        file: route
+      }
+    });
+  }
+}
+function validateDynamicRouteModule(mod, {
+  ssr,
+  logging,
+  route
+}) {
+  if (ssr && mod.getStaticPaths && !mod.prerender) {
+    warn(logging, "getStaticPaths", 'getStaticPaths() is ignored when "output: server" is set.');
+  }
+  if ((!ssr || mod.prerender) && !mod.getStaticPaths) {
+    throw new AstroError({
+      ...AstroErrorData.GetStaticPathsRequired,
+      location: { file: route.component }
+    });
+  }
+}
+function validateGetStaticPathsResult(result, logging, route) {
+  if (!Array.isArray(result)) {
+    throw new AstroError({
+      ...AstroErrorData.InvalidGetStaticPathsReturn,
+      message: AstroErrorData.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({
+        ...AstroErrorData.GetStaticPathsExpectedParams,
+        location: {
+          file: route.component
+        }
+      });
+    }
+    if (typeof pathObject.params !== "object") {
+      throw new AstroError({
+        ...AstroErrorData.InvalidGetStaticPathParam,
+        message: AstroErrorData.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, routeComponent) {
+  const validatedParams = Object.entries(params).reduce((acc, next) => {
+    validateGetStaticPathsParameter(next, routeComponent);
+    const [key, value] = next;
+    acc[key] = value == null ? void 0 : value.toString();
+    return acc;
+  }, {});
+  return JSON.stringify(validatedParams, Object.keys(params).sort());
+}
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (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$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _result, _slots, _loggingOpts;
+const clientAddressSymbol$2 = Symbol.for("astro.clientAddress");
+function onlyAvailableInSSR(name) {
+  return function _onlyAvailableInSSR() {
+    switch (name) {
+      case "Astro.redirect":
+        throw new AstroError(AstroErrorData.StaticRedirectNotAvailable);
+    }
+  };
+}
+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 {
+  constructor(result, slots, logging) {
+    __privateAdd$1(this, _result, void 0);
+    __privateAdd$1(this, _slots, void 0);
+    __privateAdd$1(this, _loggingOpts, void 0);
+    __privateSet$1(this, _result, result);
+    __privateSet$1(this, _slots, slots);
+    __privateSet$1(this, _loggingOpts, logging);
+    if (slots) {
+      for (const key of Object.keys(slots)) {
+        if (this[key] !== void 0) {
+          throw new AstroError({
+            ...AstroErrorData.ReservedSlotName,
+            message: AstroErrorData.ReservedSlotName.message(key)
+          });
+        }
+        Object.defineProperty(this, key, {
+          get() {
+            return true;
+          },
+          enumerable: true
+        });
+      }
+    }
+  }
+  has(name) {
+    if (!__privateGet$1(this, _slots))
+      return false;
+    return Boolean(__privateGet$1(this, _slots)[name]);
+  }
+  async render(name, args = []) {
+    if (!__privateGet$1(this, _slots) || !this.has(name))
+      return;
+    if (!Array.isArray(args)) {
+      warn(
+        __privateGet$1(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 = __privateGet$1(this, _slots)[name];
+      const component = typeof slotValue === "function" ? await slotValue() : await slotValue;
+      const expression = getFunctionExpression(component);
+      if (expression) {
+        const slot = expression(...args);
+        return await renderSlot(__privateGet$1(this, _result), slot).then(
+          (res) => res != null ? String(res) : res
+        );
+      }
+      if (typeof component === "function") {
+        return await renderJSX(__privateGet$1(this, _result), component(...args)).then(
+          (res) => res != null ? String(res) : res
+        );
+      }
+    }
+    const content = await renderSlot(__privateGet$1(this, _result), __privateGet$1(this, _slots)[name]);
+    const outHTML = stringifyChunk(__privateGet$1(this, _result), content);
+    return outHTML;
+  }
+}
+_result = new WeakMap();
+_slots = new WeakMap();
+_loggingOpts = new WeakMap();
+let renderMarkdown = null;
+function createResult(args) {
+  const { markdown, params, pathname, renderers, request, resolve } = 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 = void 0;
+  const result = {
+    styles: args.styles ?? /* @__PURE__ */ new Set(),
+    scripts: args.scripts ?? /* @__PURE__ */ new Set(),
+    links: args.links ?? /* @__PURE__ */ new Set(),
+    propagation: args.propagation ?? /* @__PURE__ */ new Map(),
+    propagators: /* @__PURE__ */ new Map(),
+    extraHead: [],
+    cookies,
+    createAstro(astroGlobal, props, slots) {
+      const astroSlots = new Slots(result, slots, args.logging);
+      const Astro = {
+        __proto__: astroGlobal,
+        get clientAddress() {
+          if (!(clientAddressSymbol$2 in request)) {
+            if (args.adapterName) {
+              throw new AstroError({
+                ...AstroErrorData.ClientAddressNotAvailable,
+                message: AstroErrorData.ClientAddressNotAvailable.message(args.adapterName)
+              });
+            } else {
+              throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+            }
+          }
+          return Reflect.get(request, clientAddressSymbol$2);
+        },
+        get cookies() {
+          if (cookies) {
+            return cookies;
+          }
+          cookies = new AstroCookies(request);
+          result.cookies = cookies;
+          return cookies;
+        },
+        params,
+        props,
+        request,
+        url,
+        redirect: args.ssr ? (path, status) => {
+          return new Response(null, {
+            status: status || 302,
+            headers: {
+              Location: path
+            }
+          });
+        } : onlyAvailableInSSR("Astro.redirect"),
+        response,
+        slots: astroSlots
+      };
+      Object.defineProperty(Astro, "__renderMarkdown", {
+        enumerable: false,
+        writable: false,
+        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,
+    _metadata: {
+      renderers,
+      pathname,
+      hasHydrationScript: false,
+      hasRenderedHead: false,
+      hasDirectives: /* @__PURE__ */ new Set()
+    },
+    response
+  };
+  return result;
+}
+
+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 Error(
+        `[paginate()] page number param \`${paramName}\` not found in your filepath.
+Rename your file to \`[...page].astro\` or customize the param name via the \`paginate([], {param: '...'}\` option.`
+      );
+    }
+    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
+      };
+      return {
+        params,
+        props: {
+          ...additionalProps,
+          page: {
+            data: data.slice(start, end),
+            start,
+            end: end - 1,
+            size: pageSize,
+            total: data.length,
+            currentPage: pageNum,
+            lastPage,
+            url: {
+              current: routeMatch.generate({ ...params }),
+              next: pageNum === lastPage ? void 0 : routeMatch.generate({ ...params, page: String(pageNum + 1) }),
+              prev: pageNum === 1 ? void 0 : routeMatch.generate({
+                ...params,
+                page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
+              })
+            }
+          }
+        }
+      };
+    });
+    return result;
+  };
+}
+
+async function callGetStaticPaths({
+  isValidate,
+  logging,
+  mod,
+  route,
+  ssr
+}) {
+  validateDynamicRouteModule(mod, { ssr, logging, route });
+  if (ssr && !mod.prerender) {
+    return { staticPaths: Object.assign([], { keyed: /* @__PURE__ */ new Map() }) };
+  }
+  if (!mod.getStaticPaths) {
+    throw new Error("Unexpected Error.");
+  }
+  let staticPaths = [];
+  staticPaths = await mod.getStaticPaths({
+    paginate: generatePaginateFunction(route),
+    rss() {
+      throw new AstroError(AstroErrorData.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.component);
+    keyedStaticPaths.keyed.set(paramsKey, sp);
+  }
+  return {
+    staticPaths: keyedStaticPaths
+  };
+}
+class RouteCache {
+  constructor(logging, mode = "production") {
+    this.cache = {};
+    this.logging = logging;
+    this.mode = mode;
+  }
+  clearAll() {
+    this.cache = {};
+  }
+  set(route, entry) {
+    if (this.mode === "production" && this.cache[route.component]) {
+      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.component);
+  const matchedStaticPath = staticPaths.keyed.get(paramsKey);
+  if (matchedStaticPath) {
+    return matchedStaticPath;
+  }
+  debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
+}
+
+var GetParamsAndPropsError = /* @__PURE__ */ ((GetParamsAndPropsError2) => {
+  GetParamsAndPropsError2[GetParamsAndPropsError2["NoMatchingStaticPath"] = 0] = "NoMatchingStaticPath";
+  return GetParamsAndPropsError2;
+})(GetParamsAndPropsError || {});
+async function getParamsAndProps(opts) {
+  const { logging, mod, route, routeCache, pathname, ssr } = opts;
+  let params = {};
+  let pageProps;
+  if (route && !route.pathname) {
+    if (route.params.length) {
+      const paramsMatch = route.pattern.exec(pathname);
+      if (paramsMatch) {
+        params = getParams(route.params)(paramsMatch);
+      }
+    }
+    let routeCacheEntry = routeCache.get(route);
+    if (!routeCacheEntry) {
+      routeCacheEntry = await callGetStaticPaths({ mod, route, isValidate: true, logging, ssr });
+      routeCache.set(route, routeCacheEntry);
+    }
+    const matchedStaticPath = findPathItemByKey(routeCacheEntry.staticPaths, params, route);
+    if (!matchedStaticPath && (ssr ? mod.prerender : true)) {
+      return 0 /* NoMatchingStaticPath */;
+    }
+    pageProps = (matchedStaticPath == null ? void 0 : matchedStaticPath.props) ? { ...matchedStaticPath.props } : {};
+  } else {
+    pageProps = {};
+  }
+  return [params, pageProps];
+}
+async function renderPage(mod, ctx, env) {
+  var _a, _b;
+  const paramsAndPropsRes = await getParamsAndProps({
+    logging: env.logging,
+    mod,
+    route: ctx.route,
+    routeCache: env.routeCache,
+    pathname: ctx.pathname,
+    ssr: env.ssr
+  });
+  if (paramsAndPropsRes === 0 /* NoMatchingStaticPath */) {
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
+      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
+    });
+  }
+  const [params, pageProps] = paramsAndPropsRes;
+  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: ctx.links,
+    styles: ctx.styles,
+    logging: env.logging,
+    markdown: env.markdown,
+    mode: env.mode,
+    origin: ctx.origin,
+    params,
+    props: pageProps,
+    pathname: ctx.pathname,
+    propagation: ctx.propagation,
+    resolve: env.resolve,
+    renderers: env.renderers,
+    request: ctx.request,
+    site: env.site,
+    scripts: ctx.scripts,
+    ssr: env.ssr,
+    status: ctx.status ?? 200
+  });
+  if (typeof mod.components === "object") {
+    Object.assign(pageProps, { components: mod.components });
+  }
+  const response = await renderPage$1(
+    result,
+    Component,
+    pageProps,
+    null,
+    env.streaming,
+    ctx.route
+  );
+  if (result.cookies) {
+    attachToResponse(response, result.cookies);
+  }
+  return response;
+}
+
+const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
+function createAPIContext({
+  request,
+  params,
+  site,
+  props,
+  adapterName
+}) {
+  return {
+    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$1 in request)) {
+        if (adapterName) {
+          throw new AstroError({
+            ...AstroErrorData.ClientAddressNotAvailable,
+            message: AstroErrorData.ClientAddressNotAvailable.message(adapterName)
+          });
+        } else {
+          throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+        }
+      }
+      return Reflect.get(request, clientAddressSymbol$1);
+    }
+  };
+}
+async function call(mod, env, ctx) {
+  var _a, _b;
+  const paramsAndPropsResp = await getParamsAndProps({
+    mod,
+    route: ctx.route,
+    routeCache: env.routeCache,
+    pathname: ctx.pathname,
+    logging: env.logging,
+    ssr: env.ssr
+  });
+  if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
+      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
+    });
+  }
+  const [params, props] = paramsAndPropsResp;
+  const context = createAPIContext({
+    request: ctx.request,
+    params,
+    props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  const response = await renderEndpoint(mod, context, env.ssr);
+  if (response instanceof Response) {
+    attachToResponse(response, context.cookies);
+    return {
+      type: "response",
+      response
+    };
+  }
+  return {
+    type: "simple",
+    body: response.body,
+    encoding: response.encoding,
+    cookies: context.cookies
+  };
+}
+
+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(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;
+  }
+};
+
+function appendForwardSlash(path) {
+  return path.endsWith("/") ? path : path + "/";
+}
+function prependForwardSlash(path) {
+  return path[0] === "/" ? path : "/" + path;
+}
+function removeTrailingForwardSlash(path) {
+  return path.endsWith("/") ? path.slice(0, path.length - 1) : path;
+}
+function removeLeadingForwardSlash(path) {
+  return path.startsWith("/") ? path.substring(1) : path;
+}
+function trimSlashes(path) {
+  return path.replace(/^\/|\/$/g, "");
+}
+function isString(path) {
+  return typeof path === "string" || path instanceof String;
+}
+function joinPaths(...paths) {
+  return paths.filter(isString).map(trimSlashes).join("/");
+}
+
+function createRenderContext(options) {
+  const request = options.request;
+  const url = new URL(request.url);
+  const origin = options.origin ?? url.origin;
+  const pathname = options.pathname ?? url.pathname;
+  return {
+    ...options,
+    origin,
+    pathname,
+    url
+  };
+}
+
+function createEnvironment(options) {
+  return options;
+}
+
+function getRootPath(base) {
+  return appendForwardSlash(new URL(base || "/", "http://localhost/").pathname);
+}
+function joinToRoot(href, base) {
+  const rootPath = getRootPath(base);
+  const normalizedHref = slashify(href);
+  return appendForwardSlash(rootPath) + removeLeadingForwardSlash(normalizedHref);
+}
+function createLinkStylesheetElement(href, base) {
+  return {
+    props: {
+      rel: "stylesheet",
+      href: joinToRoot(href, base)
+    },
+    children: ""
+  };
+}
+function createLinkStylesheetElementSet(hrefs, base) {
+  return new Set(hrefs.map((href) => createLinkStylesheetElement(href, base)));
+}
+function createModuleScriptElement(script, base) {
+  if (script.type === "external") {
+    return createModuleScriptElementWithSrc(script.value, base);
+  } else {
+    return {
+      props: {
+        type: "module"
+      },
+      children: script.value
+    };
+  }
+}
+function createModuleScriptElementWithSrc(src, site) {
+  return {
+    props: {
+      type: "module",
+      src: joinToRoot(src, site)
+    },
+    children: ""
+  };
+}
+
+function matchRoute(pathname, manifest) {
+  return manifest.routes.find((route) => route.pattern.test(decodeURI(pathname)));
+}
+function matchAssets(route, assets) {
+  for (const asset of assets) {
+    if (!asset.endsWith(".html"))
+      continue;
+    if (route.pattern.test(asset)) {
+      return asset;
+    }
+    if (route.pattern.test(asset.replace(/index\.html$/, ""))) {
+      return asset;
+    }
+  }
+}
+
+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;
+class App {
+  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, {
+      routes: manifest.routes.map((route) => route.routeData)
+    });
+    __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
+    __privateSet(this, _env, createEnvironment({
+      adapterName: manifest.adapterName,
+      logging: __privateGet(this, _logging),
+      markdown: manifest.markdown,
+      mode: "production",
+      renderers: manifest.renderers,
+      async resolve(specifier) {
+        if (!(specifier in manifest.entryModules)) {
+          throw new Error(`Unable to resolve [${specifier}]`);
+        }
+        const bundlePath = manifest.entryModules[specifier];
+        switch (true) {
+          case bundlePath.startsWith("data:"):
+          case bundlePath.length === 0: {
+            return bundlePath;
+          }
+          default: {
+            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
+          }
+        }
+      },
+      routeCache: new RouteCache(__privateGet(this, _logging)),
+      site: __privateGet(this, _manifest).site,
+      ssr: true,
+      streaming
+    }));
+    __privateSet(this, _base, __privateGet(this, _manifest).base || "/");
+    __privateSet(this, _baseWithoutTrailingSlash, removeTrailingForwardSlash(__privateGet(this, _base)));
+  }
+  removeBase(pathname) {
+    if (pathname.startsWith(__privateGet(this, _base))) {
+      return pathname.slice(__privateGet(this, _baseWithoutTrailingSlash).length + 1);
+    }
+    return pathname;
+  }
+  match(request, { matchNotFound = false } = {}) {
+    const url = new URL(request.url);
+    if (__privateGet(this, _manifest).assets.has(url.pathname)) {
+      return void 0;
+    }
+    let pathname = "/" + this.removeBase(url.pathname);
+    let routeData = matchRoute(pathname, __privateGet(this, _manifestData));
+    if (routeData) {
+      const asset = matchAssets(routeData, __privateGet(this, _manifest).assets);
+      if (asset)
+        return void 0;
+      return routeData;
+    } else if (matchNotFound) {
+      return matchRoute("/404", __privateGet(this, _manifestData));
+    } else {
+      return void 0;
+    }
+  }
+  async render(request, routeData) {
+    let defaultStatus = 200;
+    if (!routeData) {
+      routeData = this.match(request);
+      if (!routeData) {
+        defaultStatus = 404;
+        routeData = this.match(request, { matchNotFound: true });
+      }
+      if (!routeData) {
+        return new Response(null, {
+          status: 404,
+          statusText: "Not found"
+        });
+      }
+    }
+    if (routeData.route === "/404") {
+      defaultStatus = 404;
+    }
+    let mod = __privateGet(this, _manifest).pageMap.get(routeData.component);
+    if (routeData.type === "page") {
+      let response = await __privateMethod(this, _renderPage, renderPage_fn).call(this, request, routeData, mod, defaultStatus);
+      if (response.status === 500) {
+        const fiveHundredRouteData = matchRoute("/500", __privateGet(this, _manifestData));
+        if (fiveHundredRouteData) {
+          mod = __privateGet(this, _manifest).pageMap.get(fiveHundredRouteData.component);
+          try {
+            let fiveHundredResponse = await __privateMethod(this, _renderPage, renderPage_fn).call(this, request, fiveHundredRouteData, mod, 500);
+            return fiveHundredResponse;
+          } catch {
+          }
+        }
+      }
+      return response;
+    } else if (routeData.type === "endpoint") {
+      return __privateMethod(this, _callEndpoint, callEndpoint_fn).call(this, request, routeData, mod, defaultStatus);
+    } else {
+      throw new Error(`Unsupported route type [${routeData.type}].`);
+    }
+  }
+  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
+        });
+      }
+    } else {
+      scripts.add(createModuleScriptElement(script));
+    }
+  }
+  try {
+    const ctx = createRenderContext({
+      request,
+      origin: url.origin,
+      pathname,
+      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 call(handler, __privateGet(this, _env), ctx);
+  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`);
+    } else {
+      headers.set("Content-Type", "text/plain;charset=utf-8");
+    }
+    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;
+  }
+};
+
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+function createRequestFromNodeRequest(req, body) {
+  var _a;
+  const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+  let url = `${protocol}://${req.headers.host}${req.url}`;
+  let rawHeaders = req.headers;
+  const entries = Object.entries(rawHeaders);
+  const method = req.method || "GET";
+  let request = new Request(url, {
+    method,
+    headers: new Headers(entries),
+    body: ["HEAD", "GET"].includes(method) ? null : body
+  });
+  if ((_a = req.socket) == null ? void 0 : _a.remoteAddress) {
+    Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+  }
+  return request;
+}
+class NodeApp extends App {
+  match(req, opts = {}) {
+    return super.match(req instanceof Request ? req : createRequestFromNodeRequest(req), opts);
+  }
+  render(req, routeData) {
+    if ("on" in req) {
+      let body = Buffer.from([]);
+      let reqBodyComplete = new Promise((resolve, reject) => {
+        req.on("data", (d) => {
+          body = Buffer.concat([body, d]);
+        });
+        req.on("end", () => {
+          resolve(body);
+        });
+        req.on("error", (err) => {
+          reject(err);
+        });
+      });
+      return reqBodyComplete.then(() => {
+        return super.render(
+          req instanceof Request ? req : createRequestFromNodeRequest(req, body),
+          routeData
+        );
+      });
+    }
+    return super.render(
+      req instanceof Request ? req : createRequestFromNodeRequest(req),
+      routeData
+    );
+  }
+}
+
+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) {
+  }
+  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 };
+}
+var server_default = {
+  check,
+  renderToStaticMarkup
+};
+
+export { Fragment as F, NodeApp as N, createComponent as a, addAttribute as b, createAstro as c, renderComponent as d, renderSlot as e, renderHead as f, server_default as g, deserializeManifest as h, maybeRenderHead as m, renderTemplate as r, spreadAttributes as s, unescapeHTML as u };