🎉 initiate project *astro_rewrite*

node_modules/astro/dist/core/render/context.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentInstance, Params, Props, RouteData, SSRElement, SSRResult } from '../../@types/astro';
+import type { Environment } from './environment';
+/**
+ * The RenderContext represents the parts of rendering that are specific to one request.
+ */
+export interface RenderContext {
+    request: Request;
+    pathname: string;
+    scripts?: Set<SSRElement>;
+    links?: Set<SSRElement>;
+    styles?: Set<SSRElement>;
+    componentMetadata?: SSRResult['componentMetadata'];
+    route?: RouteData;
+    status?: number;
+    params: Params;
+    props: Props;
+    locals?: object;
+}
+export type CreateRenderContextArgs = Partial<Omit<RenderContext, 'params' | 'props' | 'locals'>> & {
+    request: RenderContext['request'];
+    mod: ComponentInstance;
+    env: Environment;
+};
+export declare function createRenderContext(options: CreateRenderContextArgs): Promise<RenderContext>;

node_modules/astro/dist/core/render/context.js

@@ -0,0 +1,38 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { getParamsAndProps } from "./params-and-props.js";
+const clientLocalsSymbol = Symbol.for("astro.locals");
+async function createRenderContext(options) {
+  const request = options.request;
+  const pathname = options.pathname ?? new URL(request.url).pathname;
+  const [params, props] = await getParamsAndProps({
+    mod: options.mod,
+    route: options.route,
+    routeCache: options.env.routeCache,
+    pathname,
+    logging: options.env.logging,
+    ssr: options.env.ssr
+  });
+  const context = {
+    ...options,
+    pathname,
+    params,
+    props
+  };
+  Object.defineProperty(context, "locals", {
+    enumerable: true,
+    get() {
+      return Reflect.get(request, clientLocalsSymbol);
+    },
+    set(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol, val);
+      }
+    }
+  });
+  return context;
+}
+export {
+  createRenderContext
+};

node_modules/astro/dist/core/render/core.d.ts

@@ -0,0 +1,17 @@
+import type { AstroCookies, ComponentInstance, MiddlewareHandler } from '../../@types/astro';
+import type { RenderContext } from './context.js';
+import type { Environment } from './environment.js';
+export type RenderPage = {
+    mod: ComponentInstance;
+    renderContext: RenderContext;
+    env: Environment;
+    cookies: AstroCookies;
+};
+/**
+ * It attempts to render a page.
+ *
+ * ## Errors
+ *
+ * It throws an error if the page can't be rendered.
+ */
+export declare function tryRenderPage<MiddlewareReturnType = Response>(renderContext: Readonly<RenderContext>, env: Readonly<Environment>, mod: Readonly<ComponentInstance>, onRequest?: MiddlewareHandler<MiddlewareReturnType>): Promise<Response>;

node_modules/astro/dist/core/render/core.js

@@ -0,0 +1,89 @@
+import { renderPage as runtimeRenderPage } from "../../runtime/server/index.js";
+import { attachToResponse } from "../cookies/index.js";
+import { createAPIContext } from "../endpoint/index.js";
+import { callMiddleware } from "../middleware/callMiddleware.js";
+import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "../redirects/index.js";
+import { createResult } from "./result.js";
+async function renderPage({ mod, renderContext, env, cookies }) {
+  if (routeIsRedirect(renderContext.route)) {
+    return new Response(null, {
+      status: redirectRouteStatus(renderContext.route, renderContext.request.method),
+      headers: {
+        location: redirectRouteGenerate(renderContext.route, renderContext.params)
+      }
+    });
+  }
+  const Component = mod.default;
+  if (!Component)
+    throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
+  const result = createResult({
+    adapterName: env.adapterName,
+    links: renderContext.links,
+    styles: renderContext.styles,
+    logging: env.logging,
+    markdown: env.markdown,
+    params: renderContext.params,
+    pathname: renderContext.pathname,
+    componentMetadata: renderContext.componentMetadata,
+    resolve: env.resolve,
+    renderers: env.renderers,
+    clientDirectives: env.clientDirectives,
+    compressHTML: env.compressHTML,
+    request: renderContext.request,
+    site: env.site,
+    scripts: renderContext.scripts,
+    ssr: env.ssr,
+    status: renderContext.status ?? 200,
+    cookies,
+    locals: renderContext.locals ?? {}
+  });
+  if (typeof mod.components === "object") {
+    Object.assign(renderContext.props, { components: mod.components });
+  }
+  let response = await runtimeRenderPage(
+    result,
+    Component,
+    renderContext.props,
+    null,
+    env.streaming,
+    renderContext.route
+  );
+  if (result.cookies) {
+    attachToResponse(response, result.cookies);
+  }
+  return response;
+}
+async function tryRenderPage(renderContext, env, mod, onRequest) {
+  const apiContext = createAPIContext({
+    request: renderContext.request,
+    params: renderContext.params,
+    props: renderContext.props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  if (onRequest) {
+    return await callMiddleware(
+      env.logging,
+      onRequest,
+      apiContext,
+      () => {
+        return renderPage({
+          mod,
+          renderContext,
+          env,
+          cookies: apiContext.cookies
+        });
+      }
+    );
+  } else {
+    return await renderPage({
+      mod,
+      renderContext,
+      env,
+      cookies: apiContext.cookies
+    });
+  }
+}
+export {
+  tryRenderPage
+};

node_modules/astro/dist/core/render/dev/css.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleLoader } from '../../module-loader/index';
+import type { RuntimeMode } from '../../../@types/astro.js';
+/** Given a filePath URL, crawl Vite’s module graph to find all style imports. */
+export declare function getStylesForURL(filePath: URL, loader: ModuleLoader, mode: RuntimeMode): Promise<{
+    urls: Set<string>;
+    stylesMap: Map<string, string>;
+}>;

node_modules/astro/dist/core/render/dev/css.js

@@ -0,0 +1,30 @@
+import { viteID } from "../../util.js";
+import { isBuildableCSSRequest } from "./util.js";
+import { crawlGraph } from "./vite.js";
+async function getStylesForURL(filePath, loader, mode) {
+  const importedCssUrls = /* @__PURE__ */ new Set();
+  const importedStylesMap = /* @__PURE__ */ new Map();
+  for await (const importedModule of crawlGraph(loader, viteID(filePath), true)) {
+    if (isBuildableCSSRequest(importedModule.url)) {
+      let ssrModule;
+      try {
+        ssrModule = importedModule.ssrModule ?? await loader.import(importedModule.url);
+      } catch {
+        continue;
+      }
+      if (mode === "development" && // only inline in development
+      typeof (ssrModule == null ? void 0 : ssrModule.default) === "string") {
+        importedStylesMap.set(importedModule.url, ssrModule.default);
+      } else {
+        importedCssUrls.add(importedModule.url);
+      }
+    }
+  }
+  return {
+    urls: importedCssUrls,
+    stylesMap: importedStylesMap
+  };
+}
+export {
+  getStylesForURL
+};

node_modules/astro/dist/core/render/dev/environment.d.ts

@@ -0,0 +1,9 @@
+import type { AstroSettings, SSRManifest } from '../../../@types/astro';
+import type { LogOptions } from '../../logger/core.js';
+import type { ModuleLoader } from '../../module-loader/index';
+import type { Environment } from '../index';
+export type DevelopmentEnvironment = Environment & {
+    loader: ModuleLoader;
+    settings: AstroSettings;
+};
+export declare function createDevelopmentEnvironment(manifest: SSRManifest, settings: AstroSettings, logging: LogOptions, loader: ModuleLoader): DevelopmentEnvironment;

node_modules/astro/dist/core/render/dev/environment.js

@@ -0,0 +1,30 @@
+import { isServerLikeOutput } from "../../../prerender/utils.js";
+import { createEnvironment } from "../index.js";
+import { RouteCache } from "../route-cache.js";
+import { createResolve } from "./resolve.js";
+function createDevelopmentEnvironment(manifest, settings, logging, loader) {
+  const mode = "development";
+  let env = createEnvironment({
+    adapterName: manifest.adapterName,
+    logging,
+    markdown: manifest.markdown,
+    mode,
+    // This will be overridden in the dev server
+    renderers: [],
+    clientDirectives: manifest.clientDirectives,
+    compressHTML: manifest.compressHTML,
+    resolve: createResolve(loader, settings.config.root),
+    routeCache: new RouteCache(logging, mode),
+    site: manifest.site,
+    ssr: isServerLikeOutput(settings.config),
+    streaming: true
+  });
+  return {
+    ...env,
+    loader,
+    settings
+  };
+}
+export {
+  createDevelopmentEnvironment
+};

node_modules/astro/dist/core/render/dev/index.d.ts

@@ -0,0 +1,27 @@
+import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../../@types/astro';
+import type { DevelopmentEnvironment } from './environment';
+export { createDevelopmentEnvironment } from './environment.js';
+export type { DevelopmentEnvironment };
+export interface SSROptions {
+    /** The environment instance */
+    env: DevelopmentEnvironment;
+    /** location of file on disk */
+    filePath: URL;
+    /** the web request (needed for dynamic routes) */
+    pathname: string;
+    /** The runtime component instance */
+    preload: ComponentInstance;
+    /** Request */
+    request: Request;
+    /** optional, in case we need to render something outside of a dev server */
+    route?: RouteData;
+    /**
+     * Optional middlewares
+     */
+    middleware?: AstroMiddlewareInstance<unknown>;
+}
+export declare function preload({ env, filePath, }: {
+    env: DevelopmentEnvironment;
+    filePath: URL;
+}): Promise<ComponentInstance>;
+export declare function renderPage(options: SSROptions): Promise<Response>;

node_modules/astro/dist/core/render/dev/index.js

@@ -0,0 +1,112 @@
+import { PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
+import { enhanceViteSSRError } from "../../errors/dev/index.js";
+import { AggregateError, CSSError, MarkdownError } from "../../errors/index.js";
+import { isPage, resolveIdToUrl, viteID } from "../../util.js";
+import { createRenderContext, loadRenderers, tryRenderPage } from "../index.js";
+import { getStylesForURL } from "./css.js";
+import { getComponentMetadata } from "./metadata.js";
+import { getScriptsForURL } from "./scripts.js";
+import { createDevelopmentEnvironment } from "./environment.js";
+async function preload({
+  env,
+  filePath
+}) {
+  const renderers = await loadRenderers(env.settings, env.loader);
+  env.renderers = renderers;
+  try {
+    const mod = await env.loader.import(viteID(filePath));
+    return mod;
+  } catch (error) {
+    if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+      throw error;
+    }
+    throw enhanceViteSSRError({ error, filePath, loader: env.loader });
+  }
+}
+async function getScriptsAndStyles({ env, filePath }) {
+  const scripts = await getScriptsForURL(filePath, env.settings.config.root, env.loader);
+  if (isPage(filePath, env.settings) && env.mode === "development") {
+    scripts.add({
+      props: { type: "module", src: "/@vite/client" },
+      children: ""
+    });
+    scripts.add({
+      props: {
+        type: "module",
+        src: await resolveIdToUrl(env.loader, "astro/runtime/client/hmr.js")
+      },
+      children: ""
+    });
+  }
+  for (const script of env.settings.scripts) {
+    if (script.stage === "head-inline") {
+      scripts.add({
+        props: {},
+        children: script.content
+      });
+    } else if (script.stage === "page" && isPage(filePath, env.settings)) {
+      scripts.add({
+        props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
+        children: ""
+      });
+    }
+  }
+  const { urls: styleUrls, stylesMap } = await getStylesForURL(filePath, env.loader, env.mode);
+  let links = /* @__PURE__ */ new Set();
+  [...styleUrls].forEach((href) => {
+    links.add({
+      props: {
+        rel: "stylesheet",
+        href
+      },
+      children: ""
+    });
+  });
+  let styles = /* @__PURE__ */ new Set();
+  [...stylesMap].forEach(([url, content]) => {
+    scripts.add({
+      props: {
+        type: "module",
+        src: url
+      },
+      children: ""
+    });
+    styles.add({
+      props: {
+        type: "text/css",
+        // Track the ID so we can match it to Vite's injected style later
+        "data-astro-dev-id": viteID(new URL(`.${url}`, env.settings.config.root))
+      },
+      children: content
+    });
+  });
+  const metadata = await getComponentMetadata(filePath, env.loader);
+  return { scripts, styles, links, metadata };
+}
+async function renderPage(options) {
+  var _a;
+  const mod = options.preload;
+  const { scripts, links, styles, metadata } = await getScriptsAndStyles({
+    env: options.env,
+    filePath: options.filePath
+  });
+  const { env } = options;
+  const renderContext = await createRenderContext({
+    request: options.request,
+    pathname: options.pathname,
+    scripts,
+    links,
+    styles,
+    componentMetadata: metadata,
+    route: options.route,
+    mod,
+    env
+  });
+  const onRequest = (_a = options.middleware) == null ? void 0 : _a.onRequest;
+  return tryRenderPage(renderContext, env, mod, onRequest);
+}
+export {
+  createDevelopmentEnvironment,
+  preload,
+  renderPage
+};

node_modules/astro/dist/core/render/dev/metadata.d.ts

@@ -0,0 +1,3 @@
+import type { SSRResult } from '../../../@types/astro';
+import type { ModuleLoader } from '../../module-loader/index';
+export declare function getComponentMetadata(filePath: URL, loader: ModuleLoader): Promise<SSRResult['componentMetadata']>;

node_modules/astro/dist/core/render/dev/metadata.js

@@ -0,0 +1,36 @@
+import { getAstroMetadata } from "../../../vite-plugin-astro/index.js";
+import { viteID } from "../../util.js";
+import { crawlGraph } from "./vite.js";
+async function getComponentMetadata(filePath, loader) {
+  const map = /* @__PURE__ */ new Map();
+  const rootID = viteID(filePath);
+  addMetadata(map, loader.getModuleInfo(rootID));
+  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
+    const id = moduleNode.id;
+    if (id) {
+      addMetadata(map, loader.getModuleInfo(id));
+    }
+  }
+  return map;
+}
+function addMetadata(map, modInfo) {
+  if (modInfo) {
+    const astro = getAstroMetadata(modInfo);
+    if (astro) {
+      let metadata = {
+        containsHead: false,
+        propagation: "none"
+      };
+      if (astro.propagation) {
+        metadata.propagation = astro.propagation;
+      }
+      if (astro.containsHead) {
+        metadata.containsHead = astro.containsHead;
+      }
+      map.set(modInfo.id, metadata);
+    }
+  }
+}
+export {
+  getComponentMetadata
+};

node_modules/astro/dist/core/render/dev/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleLoader } from '../../module-loader/index';
+export declare function createResolve(loader: ModuleLoader, root: URL): (s: string) => Promise<string>;

node_modules/astro/dist/core/render/dev/resolve.js

@@ -0,0 +1,9 @@
+import { resolveIdToUrl } from "../../util.js";
+function createResolve(loader, root) {
+  return async function(s) {
+    return await resolveIdToUrl(loader, s, root);
+  };
+}
+export {
+  createResolve
+};

node_modules/astro/dist/core/render/dev/scripts.d.ts

@@ -0,0 +1,3 @@
+import type { SSRElement } from '../../../@types/astro';
+import type { ModuleLoader } from '../../module-loader/index';
+export declare function getScriptsForURL(filePath: URL, root: URL, loader: ModuleLoader): Promise<Set<SSRElement>>;

node_modules/astro/dist/core/render/dev/scripts.js

@@ -0,0 +1,34 @@
+import { rootRelativePath, viteID } from "../../util.js";
+import { createModuleScriptElementWithSrc } from "../ssr-element.js";
+import { crawlGraph } from "./vite.js";
+async function getScriptsForURL(filePath, root, loader) {
+  const elements = /* @__PURE__ */ new Set();
+  const rootID = viteID(filePath);
+  const modInfo = loader.getModuleInfo(rootID);
+  addHoistedScripts(elements, modInfo, root);
+  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
+    const id = moduleNode.id;
+    if (id) {
+      const info = loader.getModuleInfo(id);
+      addHoistedScripts(elements, info, root);
+    }
+  }
+  return elements;
+}
+function addHoistedScripts(set, info, root) {
+  var _a, _b;
+  if (!((_a = info == null ? void 0 : info.meta) == null ? void 0 : _a.astro)) {
+    return;
+  }
+  let id = info.id;
+  const astro = (_b = info == null ? void 0 : info.meta) == null ? void 0 : _b.astro;
+  for (let i = 0; i < astro.scripts.length; i++) {
+    let scriptId = `${id}?astro&type=script&index=${i}&lang.ts`;
+    scriptId = rootRelativePath(root, scriptId);
+    const element = createModuleScriptElementWithSrc(scriptId);
+    set.add(element);
+  }
+}
+export {
+  getScriptsForURL
+};

node_modules/astro/dist/core/render/dev/util.d.ts

@@ -0,0 +1,3 @@
+import { isCSSRequest } from 'vite';
+export { isCSSRequest };
+export declare const isBuildableCSSRequest: (request: string) => boolean;

node_modules/astro/dist/core/render/dev/util.js

@@ -0,0 +1,8 @@
+import { isCSSRequest } from "vite";
+const rawRE = /(?:\?|&)raw(?:&|$)/;
+const inlineRE = /(?:\?|&)inline\b/;
+const isBuildableCSSRequest = (request) => isCSSRequest(request) && !rawRE.test(request) && !inlineRE.test(request);
+export {
+  isBuildableCSSRequest,
+  isCSSRequest
+};

node_modules/astro/dist/core/render/dev/vite.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleLoader, ModuleNode } from '../../module-loader/index';
+/** recursively crawl the module graph to get all style files imported by parent id */
+export declare function crawlGraph(loader: ModuleLoader, _id: string, isRootFile: boolean, scanned?: Set<string>): AsyncGenerator<ModuleNode, void, unknown>;

node_modules/astro/dist/core/render/dev/vite.js

@@ -0,0 +1,71 @@
+import npath from "node:path";
+import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "../../constants.js";
+import { unwrapId } from "../../util.js";
+import { isCSSRequest } from "./util.js";
+const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ".mdoc", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
+const STRIP_QUERY_PARAMS_REGEX = /\?.*$/;
+const ASTRO_PROPAGATED_ASSET_REGEX = /\?astroPropagatedAssets/;
+async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
+  const id = unwrapId(_id);
+  const importedModules = /* @__PURE__ */ new Set();
+  const moduleEntriesForId = isRootFile ? (
+    // "getModulesByFile" pulls from a delayed module cache (fun implementation detail),
+    // So we can get up-to-date info on initial server load.
+    // Needed for slower CSS preprocessing like Tailwind
+    loader.getModulesByFile(id) ?? /* @__PURE__ */ new Set()
+  ) : (
+    // For non-root files, we're safe to pull from "getModuleById" based on testing.
+    // TODO: Find better invalidation strat to use "getModuleById" in all cases!
+    /* @__PURE__ */ new Set([loader.getModuleById(id)])
+  );
+  for (const entry of moduleEntriesForId) {
+    if (!entry) {
+      continue;
+    }
+    if (id === entry.id) {
+      scanned.add(id);
+      const entryIsStyle = isCSSRequest(id);
+      for (const importedModule of entry.importedModules) {
+        if (!importedModule.id)
+          continue;
+        const importedModulePathname = importedModule.id.replace(STRIP_QUERY_PARAMS_REGEX, "");
+        if (entryIsStyle && !isCSSRequest(importedModulePathname)) {
+          continue;
+        }
+        const isFileTypeNeedingSSR = fileExtensionsToSSR.has(npath.extname(importedModulePathname));
+        const isPropagationStoppingPoint = ASTRO_PROPAGATED_ASSET_REGEX.test(importedModule.id);
+        if (isFileTypeNeedingSSR && // Should not SSR a module with ?astroPropagatedAssets
+        !isPropagationStoppingPoint) {
+          const mod = loader.getModuleById(importedModule.id);
+          if (!(mod == null ? void 0 : mod.ssrModule)) {
+            try {
+              await loader.import(importedModule.id);
+            } catch {
+            }
+          }
+        }
+        if (isImportedBy(id, importedModule) && !isPropagationStoppingPoint) {
+          importedModules.add(importedModule);
+        }
+      }
+    }
+  }
+  for (const importedModule of importedModules) {
+    if (!importedModule.id || scanned.has(importedModule.id)) {
+      continue;
+    }
+    yield importedModule;
+    yield* crawlGraph(loader, importedModule.id, false, scanned);
+  }
+}
+function isImportedBy(parent, entry) {
+  for (const importer of entry.importers) {
+    if (importer.id === parent) {
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  crawlGraph
+};

node_modules/astro/dist/core/render/environment.d.ts

@@ -0,0 +1,39 @@
+import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
+import type { RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { LogOptions } from '../logger/core.js';
+import type { RouteCache } from './route-cache.js';
+/**
+ * An environment represents the static parts of rendering that do not change
+ * between requests. These are mostly known when the server first starts up and do not change.
+ * Thus they can be created once and passed through to renderPage on each request.
+ */
+export interface Environment {
+    /**
+     * Used to provide better error messages for `Astro.clientAddress`
+     */
+    adapterName?: string;
+    /** logging options */
+    logging: LogOptions;
+    /**
+     * Used to support `Astro.__renderMarkdown` for legacy `<Markdown />` component
+     */
+    markdown: MarkdownRenderingOptions;
+    /** "development" or "production" */
+    mode: RuntimeMode;
+    compressHTML: boolean;
+    renderers: SSRLoadedRenderer[];
+    clientDirectives: Map<string, string>;
+    resolve: (s: string) => Promise<string>;
+    routeCache: RouteCache;
+    /**
+     * Used for `Astro.site`
+     */
+    site?: string;
+    /**
+     * Value of Astro config's `output` option, true if "server" or "hybrid"
+     */
+    ssr: boolean;
+    streaming: boolean;
+}
+export type CreateEnvironmentArgs = Environment;
+export declare function createEnvironment(options: CreateEnvironmentArgs): Environment;

node_modules/astro/dist/core/render/environment.js

@@ -0,0 +1,6 @@
+function createEnvironment(options) {
+  return options;
+}
+export {
+  createEnvironment
+};

node_modules/astro/dist/core/render/index.d.ts

@@ -0,0 +1,7 @@
+export { createRenderContext } from './context.js';
+export type { RenderContext } from './context.js';
+export { tryRenderPage } from './core.js';
+export type { Environment } from './environment';
+export { createEnvironment } from './environment.js';
+export { getParamsAndProps } from './params-and-props.js';
+export { loadRenderer, loadRenderers } from './renderer.js';

node_modules/astro/dist/core/render/index.js

@@ -0,0 +1,13 @@
+import { createRenderContext } from "./context.js";
+import { tryRenderPage } from "./core.js";
+import { createEnvironment } from "./environment.js";
+import { getParamsAndProps } from "./params-and-props.js";
+import { loadRenderer, loadRenderers } from "./renderer.js";
+export {
+  createEnvironment,
+  createRenderContext,
+  getParamsAndProps,
+  loadRenderer,
+  loadRenderers,
+  tryRenderPage
+};

node_modules/astro/dist/core/render/paginate.d.ts

@@ -0,0 +1,2 @@
+import type { PaginateFunction, RouteData } from '../../@types/astro';
+export declare function generatePaginateFunction(routeMatch: RouteData): PaginateFunction;

node_modules/astro/dist/core/render/paginate.js

@@ -0,0 +1,65 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
+function generatePaginateFunction(routeMatch) {
+  return function paginateUtility(data, args = {}) {
+    let { pageSize: _pageSize, params: _params, props: _props } = args;
+    const pageSize = _pageSize || 10;
+    const paramName = "page";
+    const additionalParams = _params || {};
+    const additionalProps = _props || {};
+    let includesFirstPageNumber;
+    if (routeMatch.params.includes(`...${paramName}`)) {
+      includesFirstPageNumber = false;
+    } else if (routeMatch.params.includes(`${paramName}`)) {
+      includesFirstPageNumber = true;
+    } else {
+      throw new AstroError({
+        ...AstroErrorData.PageNumberParamNotFound,
+        message: AstroErrorData.PageNumberParamNotFound.message(paramName)
+      });
+    }
+    const lastPage = Math.max(1, Math.ceil(data.length / pageSize));
+    const result = [...Array(lastPage).keys()].map((num) => {
+      const pageNum = num + 1;
+      const start = pageSize === Infinity ? 0 : (pageNum - 1) * pageSize;
+      const end = Math.min(start + pageSize, data.length);
+      const params = {
+        ...additionalParams,
+        [paramName]: includesFirstPageNumber || pageNum > 1 ? String(pageNum) : void 0
+      };
+      const current = correctIndexRoute(routeMatch.generate({ ...params }));
+      const next = pageNum === lastPage ? void 0 : correctIndexRoute(routeMatch.generate({ ...params, page: String(pageNum + 1) }));
+      const prev = pageNum === 1 ? void 0 : correctIndexRoute(
+        routeMatch.generate({
+          ...params,
+          page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
+        })
+      );
+      return {
+        params,
+        props: {
+          ...additionalProps,
+          page: {
+            data: data.slice(start, end),
+            start,
+            end: end - 1,
+            size: pageSize,
+            total: data.length,
+            currentPage: pageNum,
+            lastPage,
+            url: { current, next, prev }
+          }
+        }
+      };
+    });
+    return result;
+  };
+}
+function correctIndexRoute(route) {
+  if (route === "") {
+    return "/";
+  }
+  return route;
+}
+export {
+  generatePaginateFunction
+};

node_modules/astro/dist/core/render/params-and-props.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentInstance, Params, Props, RouteData } from '../../@types/astro';
+import type { LogOptions } from '../logger/core.js';
+import { RouteCache } from './route-cache.js';
+interface GetParamsAndPropsOptions {
+    mod: ComponentInstance;
+    route?: RouteData | undefined;
+    routeCache: RouteCache;
+    pathname: string;
+    logging: LogOptions;
+    ssr: boolean;
+}
+export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props]>;
+export {};

node_modules/astro/dist/core/render/params-and-props.js

@@ -0,0 +1,57 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { getParams } from "../routing/params.js";
+import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
+async function getParamsAndProps(opts) {
+  const { logging, mod, route, routeCache, pathname, ssr } = opts;
+  if (!route || route.pathname) {
+    return [{}, {}];
+  }
+  const params = getRouteParams(route, pathname) ?? {};
+  validatePrerenderEndpointCollision(route, mod, params);
+  const staticPaths = await callGetStaticPaths({
+    mod,
+    route,
+    routeCache,
+    isValidate: true,
+    logging,
+    ssr
+  });
+  const matchedStaticPath = findPathItemByKey(staticPaths, params, route);
+  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(pathname),
+      hint: AstroErrorData.NoMatchingStaticPathFound.hint([route.component])
+    });
+  }
+  const props = (matchedStaticPath == null ? void 0 : matchedStaticPath.props) ? { ...matchedStaticPath.props } : {};
+  return [params, props];
+}
+function getRouteParams(route, pathname) {
+  if (route.params.length) {
+    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
+    if (paramsMatch) {
+      return getParams(route.params)(paramsMatch);
+    }
+  }
+}
+function validatePrerenderEndpointCollision(route, mod, params) {
+  if (route.type === "endpoint" && mod.getStaticPaths) {
+    const lastSegment = route.segments[route.segments.length - 1];
+    const paramValues = Object.values(params);
+    const lastParam = paramValues[paramValues.length - 1];
+    if (lastSegment.length === 1 && lastSegment[0].dynamic && lastParam === void 0) {
+      throw new AstroError({
+        ...AstroErrorData.PrerenderDynamicEndpointPathCollide,
+        message: AstroErrorData.PrerenderDynamicEndpointPathCollide.message(route.route),
+        hint: AstroErrorData.PrerenderDynamicEndpointPathCollide.hint(route.component),
+        location: {
+          file: route.component
+        }
+      });
+    }
+  }
+}
+export {
+  getParamsAndProps
+};

node_modules/astro/dist/core/render/renderer.d.ts

@@ -0,0 +1,4 @@
+import type { AstroRenderer, AstroSettings, SSRLoadedRenderer } from '../../@types/astro';
+import type { ModuleLoader } from '../module-loader/index.js';
+export declare function loadRenderers(settings: AstroSettings, moduleLoader: ModuleLoader): Promise<SSRLoadedRenderer[]>;
+export declare function loadRenderer(renderer: AstroRenderer, moduleLoader: ModuleLoader): Promise<SSRLoadedRenderer | undefined>;

node_modules/astro/dist/core/render/renderer.js

@@ -0,0 +1,18 @@
+async function loadRenderers(settings, moduleLoader) {
+  const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, moduleLoader)));
+  return renderers.filter(Boolean);
+}
+async function loadRenderer(renderer, moduleLoader) {
+  const mod = await moduleLoader.import(renderer.serverEntrypoint);
+  if (typeof mod.default !== "undefined") {
+    return {
+      ...renderer,
+      ssr: mod.default
+    };
+  }
+  return void 0;
+}
+export {
+  loadRenderer,
+  loadRenderers
+};

node_modules/astro/dist/core/render/result.d.ts

@@ -0,0 +1,38 @@
+import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
+import type { Params, SSRElement, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
+import { AstroCookies } from '../cookies/index.js';
+import { type LogOptions } from '../logger/core.js';
+export interface CreateResultArgs {
+    /**
+     * Used to provide better error messages for `Astro.clientAddress`
+     */
+    adapterName: string | undefined;
+    /**
+     * Value of Astro config's `output` option, true if "server" or "hybrid"
+     */
+    ssr: boolean;
+    logging: LogOptions;
+    /**
+     * Used to support `Astro.__renderMarkdown` for legacy `<Markdown />` component
+     */
+    markdown: MarkdownRenderingOptions;
+    params: Params;
+    pathname: string;
+    renderers: SSRLoadedRenderer[];
+    clientDirectives: Map<string, string>;
+    compressHTML: boolean;
+    resolve: (s: string) => Promise<string>;
+    /**
+     * Used for `Astro.site`
+     */
+    site: string | undefined;
+    links?: Set<SSRElement>;
+    scripts?: Set<SSRElement>;
+    styles?: Set<SSRElement>;
+    componentMetadata?: SSRResult['componentMetadata'];
+    request: Request;
+    status: number;
+    locals: App.Locals;
+    cookies?: AstroCookies;
+}
+export declare function createResult(args: CreateResultArgs): SSRResult;

node_modules/astro/dist/core/render/result.js

@@ -0,0 +1,191 @@
+import { isHTMLString } from "../../runtime/server/escape.js";
+import {
+  renderSlotToString,
+  stringifyChunk
+} from "../../runtime/server/index.js";
+import { renderJSX } from "../../runtime/server/jsx.js";
+import { AstroCookies } from "../cookies/index.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { warn } from "../logger/core.js";
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const responseSentSymbol = Symbol.for("astro.responseSent");
+function getFunctionExpression(slot) {
+  var _a;
+  if (!slot)
+    return;
+  if (((_a = slot.expressions) == null ? void 0 : _a.length) !== 1)
+    return;
+  return slot.expressions[0];
+}
+class Slots {
+  #result;
+  #slots;
+  #loggingOpts;
+  constructor(result, slots, logging) {
+    this.#result = result;
+    this.#slots = slots;
+    this.#loggingOpts = logging;
+    if (slots) {
+      for (const key of Object.keys(slots)) {
+        if (this[key] !== void 0) {
+          throw new AstroError({
+            ...AstroErrorData.ReservedSlotName,
+            message: AstroErrorData.ReservedSlotName.message(key)
+          });
+        }
+        Object.defineProperty(this, key, {
+          get() {
+            return true;
+          },
+          enumerable: true
+        });
+      }
+    }
+  }
+  has(name) {
+    if (!this.#slots)
+      return false;
+    return Boolean(this.#slots[name]);
+  }
+  async render(name, args = []) {
+    if (!this.#slots || !this.has(name))
+      return;
+    const result = this.#result;
+    if (!Array.isArray(args)) {
+      warn(
+        this.#loggingOpts,
+        "Astro.slots.render",
+        `Expected second parameter to be an array, received a ${typeof args}. If you're trying to pass an array as a single argument and getting unexpected results, make sure you're passing your array as a item of an array. Ex: Astro.slots.render('default', [["Hello", "World"]])`
+      );
+    } else if (args.length > 0) {
+      const slotValue = this.#slots[name];
+      const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
+      const expression = getFunctionExpression(component);
+      if (expression) {
+        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
+        return await renderSlotToString(result, slot).then((res) => {
+          return res != null ? String(res) : res;
+        });
+      }
+      if (typeof component === "function") {
+        return await renderJSX(result, component(...args)).then(
+          (res) => res != null ? String(res) : res
+        );
+      }
+    }
+    const content = await renderSlotToString(result, this.#slots[name]);
+    const outHTML = stringifyChunk(result, content);
+    return outHTML;
+  }
+}
+let renderMarkdown = null;
+function createResult(args) {
+  const { markdown, params, request, resolve, locals } = args;
+  const url = new URL(request.url);
+  const headers = new Headers();
+  headers.set("Content-Type", "text/html");
+  const response = {
+    status: args.status,
+    statusText: "OK",
+    headers
+  };
+  Object.defineProperty(response, "headers", {
+    value: response.headers,
+    enumerable: true,
+    writable: false
+  });
+  let cookies = args.cookies;
+  const result = {
+    styles: args.styles ?? /* @__PURE__ */ new Set(),
+    scripts: args.scripts ?? /* @__PURE__ */ new Set(),
+    links: args.links ?? /* @__PURE__ */ new Set(),
+    componentMetadata: args.componentMetadata ?? /* @__PURE__ */ new Map(),
+    renderers: args.renderers,
+    clientDirectives: args.clientDirectives,
+    compressHTML: args.compressHTML,
+    pathname: args.pathname,
+    cookies,
+    /** This function returns the `Astro` faux-global */
+    createAstro(astroGlobal, props, slots) {
+      const astroSlots = new Slots(result, slots, args.logging);
+      const Astro = {
+        // @ts-expect-error
+        __proto__: astroGlobal,
+        get clientAddress() {
+          if (!(clientAddressSymbol 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);
+        },
+        get cookies() {
+          if (cookies) {
+            return cookies;
+          }
+          cookies = new AstroCookies(request);
+          result.cookies = cookies;
+          return cookies;
+        },
+        params,
+        props,
+        locals,
+        request,
+        url,
+        redirect(path, status) {
+          if (request[responseSentSymbol]) {
+            throw new AstroError({
+              ...AstroErrorData.ResponseSentError
+            });
+          }
+          return new Response(null, {
+            status: status || 302,
+            headers: {
+              Location: path
+            }
+          });
+        },
+        response,
+        slots: astroSlots
+      };
+      Object.defineProperty(Astro, "__renderMarkdown", {
+        // Ensure this API is not exposed to users
+        enumerable: false,
+        writable: false,
+        // TODO: Remove this hole "Deno" logic once our plugin gets Deno support
+        value: async function(content, opts) {
+          if (typeof Deno !== "undefined") {
+            throw new Error("Markdown is not supported in Deno SSR");
+          }
+          if (!renderMarkdown) {
+            let astroRemark = "@astrojs/";
+            astroRemark += "markdown-remark";
+            renderMarkdown = (await import(astroRemark)).renderMarkdown;
+          }
+          const { code } = await renderMarkdown(content, { ...markdown, ...opts ?? {} });
+          return code;
+        }
+      });
+      return Astro;
+    },
+    resolve,
+    response,
+    _metadata: {
+      hasHydrationScript: false,
+      hasRenderedHead: false,
+      hasDirectives: /* @__PURE__ */ new Set(),
+      headInTree: false,
+      extraHead: [],
+      propagators: /* @__PURE__ */ new Map()
+    }
+  };
+  return result;
+}
+export {
+  createResult
+};

node_modules/astro/dist/core/render/route-cache.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentInstance, GetStaticPathsItem, GetStaticPathsResultKeyed, Params, RouteData, RuntimeMode } from '../../@types/astro';
+import { type LogOptions } from '../logger/core.js';
+interface CallGetStaticPathsOptions {
+    mod: ComponentInstance;
+    route: RouteData;
+    routeCache: RouteCache;
+    isValidate: boolean;
+    logging: LogOptions;
+    ssr: boolean;
+}
+export declare function callGetStaticPaths({ mod, route, routeCache, isValidate, logging, ssr, }: CallGetStaticPathsOptions): Promise<GetStaticPathsResultKeyed>;
+interface RouteCacheEntry {
+    staticPaths: GetStaticPathsResultKeyed;
+}
+/**
+ * Manage the route cache, responsible for caching data related to each route,
+ * including the result of calling getStaticPath() so that it can be reused across
+ * responses during dev and only ever called once during build.
+ */
+export declare class RouteCache {
+    private logging;
+    private cache;
+    private mode;
+    constructor(logging: LogOptions, mode?: RuntimeMode);
+    /** Clear the cache. */
+    clearAll(): void;
+    set(route: RouteData, entry: RouteCacheEntry): void;
+    get(route: RouteData): RouteCacheEntry | undefined;
+}
+export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData): GetStaticPathsItem | undefined;
+export {};

node_modules/astro/dist/core/render/route-cache.js

@@ -0,0 +1,85 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { debug, warn } from "../logger/core.js";
+import { stringifyParams } from "../routing/params.js";
+import { validateDynamicRouteModule, validateGetStaticPathsResult } from "../routing/validation.js";
+import { generatePaginateFunction } from "./paginate.js";
+async function callGetStaticPaths({
+  mod,
+  route,
+  routeCache,
+  isValidate,
+  logging,
+  ssr
+}) {
+  const cached = routeCache.get(route);
+  if (cached == null ? void 0 : cached.staticPaths)
+    return cached.staticPaths;
+  validateDynamicRouteModule(mod, { ssr, logging, route });
+  if (ssr && !route.prerender) {
+    const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
+    routeCache.set(route, { ...cached, staticPaths: entry });
+    return entry;
+  }
+  if (!mod.getStaticPaths) {
+    throw new Error("Unexpected Error.");
+  }
+  let staticPaths = [];
+  staticPaths = await mod.getStaticPaths({
+    paginate: generatePaginateFunction(route),
+    rss() {
+      throw new AstroError(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);
+    keyedStaticPaths.keyed.set(paramsKey, sp);
+  }
+  routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
+  return keyedStaticPaths;
+}
+class RouteCache {
+  constructor(logging, mode = "production") {
+    this.cache = {};
+    this.logging = logging;
+    this.mode = mode;
+  }
+  /** Clear the cache. */
+  clearAll() {
+    this.cache = {};
+  }
+  set(route, entry) {
+    var _a;
+    if (this.mode === "production" && ((_a = this.cache[route.component]) == null ? void 0 : _a.staticPaths)) {
+      warn(
+        this.logging,
+        "routeCache",
+        `Internal Warning: route cache overwritten. (${route.component})`
+      );
+    }
+    this.cache[route.component] = entry;
+  }
+  get(route) {
+    return this.cache[route.component];
+  }
+}
+function findPathItemByKey(staticPaths, params, route) {
+  const paramsKey = stringifyParams(params, route);
+  const matchedStaticPath = staticPaths.keyed.get(paramsKey);
+  if (matchedStaticPath) {
+    return matchedStaticPath;
+  }
+  debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
+}
+export {
+  RouteCache,
+  callGetStaticPaths,
+  findPathItemByKey
+};

node_modules/astro/dist/core/render/ssr-element.d.ts

@@ -0,0 +1,15 @@
+import type { SSRElement } from '../../@types/astro';
+import type { StylesheetAsset } from '../app/types';
+export declare function createAssetLink(href: string, base?: string, assetsPrefix?: string): string;
+export declare function createStylesheetElement(stylesheet: StylesheetAsset, base?: string, assetsPrefix?: string): SSRElement;
+export declare function createStylesheetElementSet(stylesheets: StylesheetAsset[], base?: string, assetsPrefix?: string): Set<SSRElement>;
+export declare function createModuleScriptElement(script: {
+    type: 'inline' | 'external';
+    value: string;
+}, base?: string, assetsPrefix?: string): SSRElement;
+export declare function createModuleScriptElementWithSrc(src: string, base?: string, assetsPrefix?: string): SSRElement;
+export declare function createModuleScriptElementWithSrcSet(srces: string[], site?: string, assetsPrefix?: string): Set<SSRElement>;
+export declare function createModuleScriptsSet(scripts: {
+    type: 'inline' | 'external';
+    value: string;
+}[], base?: string, assetsPrefix?: string): Set<SSRElement>;

node_modules/astro/dist/core/render/ssr-element.js

@@ -0,0 +1,71 @@
+import { joinPaths, prependForwardSlash, slash } from "../../core/path.js";
+function createAssetLink(href, base, assetsPrefix) {
+  if (assetsPrefix) {
+    return joinPaths(assetsPrefix, slash(href));
+  } else if (base) {
+    return prependForwardSlash(joinPaths(base, slash(href)));
+  } else {
+    return href;
+  }
+}
+function createStylesheetElement(stylesheet, base, assetsPrefix) {
+  if (stylesheet.type === "inline") {
+    return {
+      props: {
+        type: "text/css"
+      },
+      children: stylesheet.content
+    };
+  } else {
+    return {
+      props: {
+        rel: "stylesheet",
+        href: createAssetLink(stylesheet.src, base, assetsPrefix)
+      },
+      children: ""
+    };
+  }
+}
+function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
+  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
+}
+function createModuleScriptElement(script, base, assetsPrefix) {
+  if (script.type === "external") {
+    return createModuleScriptElementWithSrc(script.value, base, assetsPrefix);
+  } else {
+    return {
+      props: {
+        type: "module"
+      },
+      children: script.value
+    };
+  }
+}
+function createModuleScriptElementWithSrc(src, base, assetsPrefix) {
+  return {
+    props: {
+      type: "module",
+      src: createAssetLink(src, base, assetsPrefix)
+    },
+    children: ""
+  };
+}
+function createModuleScriptElementWithSrcSet(srces, site, assetsPrefix) {
+  return new Set(
+    srces.map((src) => createModuleScriptElementWithSrc(src, site, assetsPrefix))
+  );
+}
+function createModuleScriptsSet(scripts, base, assetsPrefix) {
+  return new Set(
+    scripts.map((script) => createModuleScriptElement(script, base, assetsPrefix))
+  );
+}
+export {
+  createAssetLink,
+  createModuleScriptElement,
+  createModuleScriptElementWithSrc,
+  createModuleScriptElementWithSrcSet,
+  createModuleScriptsSet,
+  createStylesheetElement,
+  createStylesheetElementSet
+};