Initial commit: New MoreminiMore website with fresh design

node_modules/@astrojs/node/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { AstroAdapter, AstroIntegration } from 'astro';
+import type { Options, UserOptions } from './types.js';
+export declare function getAdapter({ staticHeaders }: Pick<Options, 'staticHeaders'>): AstroAdapter;
+export default function createIntegration(userOptions: UserOptions): AstroIntegration;

node_modules/@astrojs/node/dist/index.js

@@ -0,0 +1,116 @@
+import { fileURLToPath } from "node:url";
+import { writeJson } from "@astrojs/internal-helpers/fs";
+import { AstroError } from "astro/errors";
+import { STATIC_HEADERS_FILE } from "./shared.js";
+import { sessionDrivers } from "astro/config";
+import { createConfigPlugin } from "./vite-plugin-config.js";
+function getAdapter({ staticHeaders }) {
+  return {
+    name: "@astrojs/node",
+    entrypointResolution: "auto",
+    serverEntrypoint: "@astrojs/node/server.js",
+    previewEntrypoint: "@astrojs/node/preview.js",
+    adapterFeatures: {
+      buildOutput: "server",
+      middlewareMode: "classic",
+      staticHeaders
+    },
+    supportedAstroFeatures: {
+      hybridOutput: "stable",
+      staticOutput: "stable",
+      serverOutput: "stable",
+      sharpImageService: "stable",
+      i18nDomains: "experimental",
+      envGetSecret: "stable"
+    }
+  };
+}
+function createIntegration(userOptions) {
+  if (!userOptions?.mode) {
+    throw new AstroError(`Setting the 'mode' option is required.`);
+  }
+  let _config = void 0;
+  let _routeToHeaders = void 0;
+  return {
+    name: "@astrojs/node",
+    hooks: {
+      "astro:config:setup": async ({ updateConfig, config, logger, command }) => {
+        let session = config.session;
+        _config = config;
+        if (!session?.driver) {
+          logger.info("Enabling sessions with filesystem storage");
+          session = {
+            driver: sessionDrivers.fsLite({
+              base: fileURLToPath(new URL("sessions", config.cacheDir))
+            }),
+            cookie: session?.cookie,
+            ttl: session?.ttl
+          };
+        }
+        updateConfig({
+          build: {
+            redirects: false
+          },
+          image: {
+            endpoint: {
+              route: config.image.endpoint.route ?? "_image",
+              entrypoint: config.image.endpoint.entrypoint ?? (command === "dev" ? "astro/assets/endpoint/dev" : "astro/assets/endpoint/node")
+            }
+          },
+          session,
+          vite: {
+            plugins: [
+              createConfigPlugin({
+                ...userOptions,
+                client: _config.build.client?.toString(),
+                server: _config.build.server?.toString(),
+                host: _config.server.host,
+                port: _config.server.port,
+                staticHeaders: userOptions.staticHeaders ?? false,
+                bodySizeLimit: userOptions.bodySizeLimit ?? 1024 * 1024 * 1024,
+                experimentalDisableStreaming: userOptions.experimentalDisableStreaming ?? false
+              })
+            ]
+          }
+        });
+      },
+      "astro:build:generated": ({ routeToHeaders }) => {
+        _routeToHeaders = routeToHeaders;
+      },
+      "astro:config:done": ({ setAdapter, config }) => {
+        _config = config;
+        setAdapter(getAdapter({ staticHeaders: userOptions.staticHeaders ?? false }));
+      },
+      "astro:build:done": async () => {
+        if (!_config) {
+          return;
+        }
+        if (_routeToHeaders && _routeToHeaders.size > 0) {
+          const headersFileUrl = new URL(STATIC_HEADERS_FILE, _config.outDir);
+          const headersValue = [];
+          for (const [pathname, { headers }] of _routeToHeaders.entries()) {
+            if (_config.security.csp) {
+              const csp = headers.get("Content-Security-Policy");
+              if (csp) {
+                headersValue.push({
+                  pathname,
+                  headers: [
+                    {
+                      key: "Content-Security-Policy",
+                      value: csp
+                    }
+                  ]
+                });
+              }
+            }
+          }
+          await writeJson(headersFileUrl, headersValue);
+        }
+      }
+    }
+  };
+}
+export {
+  createIntegration as default,
+  getAdapter
+};

node_modules/@astrojs/node/dist/log-listening-on.d.ts

@@ -0,0 +1,4 @@
+import type http from 'node:http';
+import https from 'node:https';
+import type { AstroIntegrationLogger } from 'astro';
+export declare function logListeningOn(logger: AstroIntegrationLogger, server: http.Server | https.Server, configuredHost: string | boolean | undefined): Promise<void>;

node_modules/@astrojs/node/dist/log-listening-on.js

@@ -0,0 +1,54 @@
+import https from "node:https";
+import os from "node:os";
+const wildcardHosts = /* @__PURE__ */ new Set(["0.0.0.0", "::", "0000:0000:0000:0000:0000:0000:0000:0000"]);
+async function logListeningOn(logger, server, configuredHost) {
+  await new Promise((resolve) => server.once("listening", resolve));
+  const protocol = server instanceof https.Server ? "https" : "http";
+  const host = getResolvedHostForHttpServer(configuredHost);
+  const { port } = server.address();
+  const address = getNetworkAddress(protocol, host, port);
+  if (host === void 0 || wildcardHosts.has(host)) {
+    logger.info(
+      `Server listening on 
+  local: ${address.local[0]} 	
+  network: ${address.network[0]}
+`
+    );
+  } else {
+    logger.info(`Server listening on ${address.local[0]}`);
+  }
+}
+function getResolvedHostForHttpServer(host) {
+  if (host === false) {
+    return "localhost";
+  } else if (host === true) {
+    return void 0;
+  } else {
+    return host;
+  }
+}
+function getNetworkAddress(protocol = "http", hostname, port, base) {
+  const NetworkAddress = {
+    local: [],
+    network: []
+  };
+  Object.values(os.networkInterfaces()).flatMap((nInterface) => nInterface ?? []).filter((detail) => detail && detail.address && detail.family === "IPv4").forEach((detail) => {
+    let host = detail.address.replace(
+      "127.0.0.1",
+      hostname === void 0 || wildcardHosts.has(hostname) ? "localhost" : hostname
+    );
+    if (host.includes(":")) {
+      host = `[${host}]`;
+    }
+    const url = `${protocol}://${host}:${port}${base ? base : ""}`;
+    if (detail.address.includes("127.0.0.1")) {
+      NetworkAddress.local.push(url);
+    } else {
+      NetworkAddress.network.push(url);
+    }
+  });
+  return NetworkAddress;
+}
+export {
+  logListeningOn
+};

node_modules/@astrojs/node/dist/middleware.d.ts

@@ -0,0 +1,11 @@
+import type { BaseApp } from 'astro/app';
+import type { Options, RequestHandler } from './types.js';
+/**
+ * Creates a middleware that can be used with Express, Connect, etc.
+ *
+ * Similar to `createAppHandler` but can additionally be placed in the express
+ * chain as an error middleware.
+ *
+ * https://expressjs.com/en/guide/using-middleware.html#middleware.error-handling
+ */
+export default function createMiddleware(app: BaseApp, options: Options): RequestHandler;

node_modules/@astrojs/node/dist/middleware.js

@@ -0,0 +1,29 @@
+import { createAppHandler } from "./serve-app.js";
+function createMiddleware(app, options) {
+  const handler = createAppHandler(app, options);
+  const logger = app.getAdapterLogger();
+  return async (...args) => {
+    const [req, res, next, locals] = args;
+    if (req instanceof Error) {
+      const error = req;
+      if (next) {
+        return next(error);
+      } else {
+        throw error;
+      }
+    }
+    try {
+      await handler(req, res, next, locals);
+    } catch (err) {
+      logger.error(`Could not render ${req.url}`);
+      console.error(err);
+      if (!res.headersSent) {
+        res.writeHead(500, `Server error`);
+        res.end();
+      }
+    }
+  };
+}
+export {
+  createMiddleware as default
+};

node_modules/@astrojs/node/dist/preview.d.ts

@@ -0,0 +1,3 @@
+import type { CreatePreviewServer } from 'astro';
+declare const createPreviewServer: CreatePreviewServer;
+export { createPreviewServer as default };

node_modules/@astrojs/node/dist/preview.js

@@ -0,0 +1,50 @@
+import { fileURLToPath } from "node:url";
+import { AstroError } from "astro/errors";
+import { logListeningOn } from "./log-listening-on.js";
+import { createServer } from "./standalone.js";
+const createPreviewServer = async (preview) => {
+  let ssrHandler;
+  try {
+    process.env.ASTRO_NODE_AUTOSTART = "disabled";
+    const ssrModule = await import(preview.serverEntrypoint.toString());
+    if (typeof ssrModule.handler === "function") {
+      ssrHandler = ssrModule.handler;
+    } else {
+      throw new AstroError(
+        `The server entrypoint doesn't have a handler. Are you sure this is the right file?`
+      );
+    }
+  } catch (err) {
+    if (err.code === "ERR_MODULE_NOT_FOUND" && err.url === preview.serverEntrypoint.href) {
+      throw new AstroError(
+        `The server entrypoint ${fileURLToPath(
+          preview.serverEntrypoint
+        )} does not exist. Have you ran a build yet?`
+      );
+    } else {
+      throw err;
+    }
+  }
+  const host = process.env.HOST ?? preview.host ?? "0.0.0.0";
+  const port = preview.port ?? 4321;
+  const server = createServer(ssrHandler, host, port);
+  if (preview.headers) {
+    server.server.addListener("request", (_, res) => {
+      if (res.statusCode === 200) {
+        for (const [name, value] of Object.entries(preview.headers ?? {})) {
+          if (value) res.setHeader(name, value);
+        }
+      }
+    });
+  }
+  logListeningOn(preview.logger, server.server, host);
+  await new Promise((resolve, reject) => {
+    server.server.once("listening", resolve);
+    server.server.once("error", reject);
+    server.server.listen(port, host);
+  });
+  return server;
+};
+export {
+  createPreviewServer as default
+};

node_modules/@astrojs/node/dist/serve-app.d.ts

@@ -0,0 +1,8 @@
+import type { BaseApp } from 'astro/app';
+import type { Options, RequestHandler } from './types.js';
+/**
+ * Creates a Node.js http listener for on-demand rendered pages, compatible with http.createServer and Connect middleware.
+ * If the next callback is provided, it will be called if the request does not have a matching route.
+ * Intended to be used in both standalone and middleware mode.
+ */
+export declare function createAppHandler(app: BaseApp, options: Options): RequestHandler;

node_modules/@astrojs/node/dist/serve-app.js

@@ -0,0 +1,92 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { createRequest, writeResponse, getAbortControllerCleanup } from "astro/app/node";
+import { resolveClientDir } from "./shared.js";
+async function readErrorPageFromDisk(client, status) {
+  const filePaths = [`${status}.html`, `${status}/index.html`];
+  for (const filePath of filePaths) {
+    const fullPath = path.join(client, filePath);
+    let stream;
+    try {
+      stream = createReadStream(fullPath);
+      await new Promise((resolve, reject) => {
+        stream.once("open", () => resolve());
+        stream.once("error", reject);
+      });
+      const webStream = Readable.toWeb(stream);
+      return new Response(webStream, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch {
+      stream?.destroy();
+    }
+  }
+  return void 0;
+}
+function createAppHandler(app, options) {
+  const als = new AsyncLocalStorage();
+  const logger = app.getAdapterLogger();
+  process.on("unhandledRejection", (reason) => {
+    const requestUrl = als.getStore();
+    logger.error(`Unhandled rejection while rendering ${requestUrl}`);
+    console.error(reason);
+  });
+  const client = resolveClientDir(options);
+  const prerenderedErrorPageFetch = async (url) => {
+    const { pathname } = new URL(url);
+    if (pathname.endsWith("/404.html") || pathname.endsWith("/404/index.html")) {
+      const response = await readErrorPageFromDisk(client, 404);
+      if (response) return response;
+    }
+    if (pathname.endsWith("/500.html") || pathname.endsWith("/500/index.html")) {
+      const response = await readErrorPageFromDisk(client, 500);
+      if (response) return response;
+    }
+    return new Response(null, { status: 404 });
+  };
+  const effectiveBodySizeLimit = options.bodySizeLimit === 0 || options.bodySizeLimit === Number.POSITIVE_INFINITY ? void 0 : options.bodySizeLimit;
+  return async (req, res, next, locals) => {
+    let request;
+    try {
+      request = createRequest(req, {
+        allowedDomains: app.getAllowedDomains?.() ?? [],
+        bodySizeLimit: effectiveBodySizeLimit,
+        port: options.port
+      });
+    } catch (err) {
+      logger.error(`Could not render ${req.url}`);
+      console.error(err);
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+      return;
+    }
+    const routeData = app.match(request, true);
+    if (routeData && !(routeData.type === "page" && routeData.prerender)) {
+      const response = await als.run(
+        request.url,
+        () => app.render(request, {
+          addCookieHeader: true,
+          locals,
+          routeData,
+          prerenderedErrorPageFetch
+        })
+      );
+      await writeResponse(response, res);
+    } else if (next) {
+      const cleanup = getAbortControllerCleanup(req);
+      if (cleanup) cleanup();
+      return next();
+    } else {
+      const response = await app.render(request, {
+        addCookieHeader: true,
+        prerenderedErrorPageFetch
+      });
+      await writeResponse(response, res);
+    }
+  };
+}
+export {
+  createAppHandler
+};

node_modules/@astrojs/node/dist/serve-static.d.ts

@@ -0,0 +1,21 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { BaseApp } from 'astro/app';
+import type { NodeAppHeadersJson, Options } from './types.js';
+/**
+ * Resolves a URL path to a filesystem path within the client directory,
+ * and checks whether it is a directory.
+ *
+ * Returns `isDirectory: false` if the resolved path escapes the client root
+ * (e.g. via `..` path traversal segments).
+ */
+export declare function resolveStaticPath(client: string, urlPath: string): {
+    filePath: string;
+    isDirectory: boolean;
+};
+/**
+ * Creates a Node.js http listener for static files and prerendered pages.
+ * In standalone mode, the static handler is queried first for the static files.
+ * If one matching the request path is not found, it relegates to the SSR handler.
+ * Intended to be used only in the standalone mode.
+ */
+export declare function createStaticHandler(app: BaseApp, options: Options, headersMap: NodeAppHeadersJson | undefined): (req: IncomingMessage, res: ServerResponse, ssr: () => unknown) => ServerResponse<IncomingMessage> | undefined;

node_modules/@astrojs/node/dist/serve-static.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+import { hasFileExtension, isInternalPath } from "@astrojs/internal-helpers/path";
+import send from "send";
+import { resolveClientDir } from "./shared.js";
+import { createRequest } from "astro/app/node";
+function resolveStaticPath(client, urlPath) {
+  const filePath = path.join(client, urlPath);
+  const resolved = path.resolve(filePath);
+  const resolvedClient = path.resolve(client);
+  if (resolved !== resolvedClient && !resolved.startsWith(resolvedClient + path.sep)) {
+    return { filePath: resolved, isDirectory: false };
+  }
+  let isDirectory = false;
+  try {
+    isDirectory = fs.lstatSync(filePath).isDirectory();
+  } catch {
+  }
+  return { filePath: resolved, isDirectory };
+}
+function createStaticHandler(app, options, headersMap) {
+  const client = resolveClientDir(options);
+  return (req, res, ssr) => {
+    if (req.url) {
+      let fullUrl = req.url;
+      if (req.url.includes("#")) {
+        fullUrl = fullUrl.slice(0, req.url.indexOf("#"));
+      }
+      const [urlPath, urlQuery] = fullUrl.split("?");
+      const { isDirectory } = resolveStaticPath(client, app.removeBase(urlPath));
+      const hasSlash = urlPath.endsWith("/");
+      let pathname = urlPath;
+      if (headersMap && headersMap.length > 0) {
+        const request = createRequest(req, {
+          allowedDomains: app.getAllowedDomains?.() ?? [],
+          port: options.port
+        });
+        const routeData = app.match(request, true);
+        if (routeData && routeData.prerender) {
+          const baselessPathname = prependForwardSlash(app.removeBase(urlPath));
+          const matchedRoute = headersMap.find(
+            (header) => header.pathname.includes(baselessPathname)
+          );
+          if (matchedRoute) {
+            for (const header of matchedRoute.headers) {
+              res.setHeader(header.key, header.value);
+            }
+          }
+        }
+      }
+      switch (app.manifest.trailingSlash) {
+        case "never": {
+          if (isDirectory && urlPath !== "/" && hasSlash) {
+            pathname = urlPath.slice(0, -1) + (urlQuery ? "?" + urlQuery : "");
+            res.statusCode = 301;
+            res.setHeader("Location", pathname);
+            return res.end();
+          }
+          if (isDirectory && !hasSlash) {
+            pathname = `${urlPath}/index.html`;
+          }
+          break;
+        }
+        case "ignore": {
+          if (isDirectory && !hasSlash) {
+            pathname = `${urlPath}/index.html`;
+          }
+          break;
+        }
+        case "always": {
+          if (!hasSlash && !hasFileExtension(urlPath) && !isInternalPath(urlPath)) {
+            pathname = urlPath + "/" + (urlQuery ? "?" + urlQuery : "");
+            res.statusCode = 301;
+            res.setHeader("Location", pathname);
+            return res.end();
+          }
+          break;
+        }
+      }
+      pathname = prependForwardSlash(app.removeBase(pathname));
+      const normalizedPathname = path.posix.normalize(pathname);
+      const stream = send(req, normalizedPathname, {
+        root: client,
+        dotfiles: normalizedPathname.startsWith("/.well-known/") ? "allow" : "deny"
+      });
+      let forwardError = false;
+      stream.on("error", (err) => {
+        if (forwardError) {
+          const status = "statusCode" in err ? err.statusCode : 500;
+          if (status >= 500) {
+            console.error(err.toString());
+          }
+          res.writeHead(status);
+          res.end(status >= 500 ? "Internal server error" : "");
+          return;
+        }
+        ssr();
+      });
+      stream.on("file", () => {
+        forwardError = true;
+      });
+      stream.on("stream", () => {
+        if (normalizedPathname.startsWith(`/${app.manifest.assetsDir}/`)) {
+          res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+        }
+      });
+      stream.pipe(res);
+    } else {
+      ssr();
+    }
+  };
+}
+function prependForwardSlash(pth) {
+  return pth.startsWith("/") ? pth : "/" + pth;
+}
+export {
+  createStaticHandler,
+  resolveStaticPath
+};

node_modules/@astrojs/node/dist/server.d.ts

@@ -0,0 +1,13 @@
+import * as options from 'virtual:astro-node:config';
+export { options };
+export declare const handler: import("./types.js").RequestHandler;
+export declare const startServer: () => {
+    server: {
+        host: string;
+        port: number;
+        closed(): Promise<void>;
+        stop(): Promise<void>;
+        server: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    };
+    done: Promise<void>;
+};

node_modules/@astrojs/node/dist/server.js

@@ -0,0 +1,19 @@
+import { createApp } from "astro/app/entrypoint";
+import { setGetEnv } from "astro/env/setup";
+import * as options from "virtual:astro-node:config";
+import createMiddleware from "./middleware.js";
+import { readHeadersJson } from "./shared.js";
+import _startServer, { createStandaloneHandler } from "./standalone.js";
+setGetEnv((key) => process.env[key]);
+const app = createApp({ streaming: !options.experimentalDisableStreaming });
+const headersMap = options.staticHeaders ? readHeadersJson(app.manifest.outDir) : void 0;
+const handler = options.mode === "middleware" ? createMiddleware(app, options) : createStandaloneHandler(app, options, headersMap);
+const startServer = () => _startServer(app, options, headersMap);
+if (options.mode === "standalone" && process.env.ASTRO_NODE_AUTOSTART !== "disabled") {
+  startServer();
+}
+export {
+  handler,
+  options,
+  startServer
+};

node_modules/@astrojs/node/dist/shared.d.ts

@@ -0,0 +1,14 @@
+import type { NodeAppHeadersJson, Options } from './types.js';
+export declare const STATIC_HEADERS_FILE = "_headers.json";
+/**
+ * Resolves the client directory path at runtime.
+ *
+ * At build time, we know the relative path between server and client directories.
+ * At runtime, we need to find the actual location based on where the server entry is running.
+ *
+ * ## Error
+ *
+ * It throws an error if it can't find the directory while walking the parent directories.
+ */
+export declare function resolveClientDir(options: Options): string;
+export declare function readHeadersJson(outDir: string | URL): NodeAppHeadersJson | undefined;

node_modules/@astrojs/node/dist/shared.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import url from "node:url";
+import fs from "node:fs";
+import { appendForwardSlash } from "@astrojs/internal-helpers/path";
+const STATIC_HEADERS_FILE = "_headers.json";
+function resolveClientDir(options) {
+  const clientURLRaw = new URL(options.client);
+  const serverURLRaw = new URL(options.server);
+  const rel = path.relative(url.fileURLToPath(serverURLRaw), url.fileURLToPath(clientURLRaw));
+  const serverFolder = path.basename(options.server);
+  let serverEntryFolderURL = path.dirname(import.meta.url);
+  let previous = "";
+  while (!serverEntryFolderURL.endsWith(serverFolder)) {
+    if (serverEntryFolderURL === previous) {
+      throw new Error(
+        `[@astrojs/node] Could not find the server directory "${serverFolder}" by walking up from "${import.meta.url}". This can happen when the server entry point is bundled into a single file (e.g. with esbuild) so that import.meta.url no longer contains the original "${serverFolder}" path segment. When bundling the server entry, make sure the output path contains a "${serverFolder}" directory segment, or avoid bundling the server entry entirely.`
+      );
+    }
+    previous = serverEntryFolderURL;
+    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
+  }
+  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
+  const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  return url.fileURLToPath(clientURL);
+}
+function readHeadersJson(outDir) {
+  let headersMap = void 0;
+  const headersUrl = new URL(STATIC_HEADERS_FILE, outDir);
+  if (fs.existsSync(headersUrl)) {
+    const content = fs.readFileSync(headersUrl, "utf-8");
+    try {
+      headersMap = JSON.parse(content);
+    } catch (e) {
+      console.error("[@astrojs/node] Error parsing _headers.json: " + e.message);
+      console.error("[@astrojs/node] Please make sure your _headers.json is valid JSON.");
+    }
+  }
+  return headersMap;
+}
+export {
+  STATIC_HEADERS_FILE,
+  readHeadersJson,
+  resolveClientDir
+};

node_modules/@astrojs/node/dist/standalone.d.ts

@@ -0,0 +1,23 @@
+import http from 'node:http';
+import https from 'node:https';
+import type { BaseApp } from 'astro/app';
+import type { NodeAppHeadersJson, Options } from './types.js';
+export declare const hostOptions: (host: Options["host"]) => string;
+export default function standalone(app: BaseApp, options: Options, headersMap: NodeAppHeadersJson | undefined): {
+    server: {
+        host: string;
+        port: number;
+        closed(): Promise<void>;
+        stop(): Promise<void>;
+        server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    };
+    done: Promise<void>;
+};
+export declare function createStandaloneHandler(app: BaseApp, options: Options, headersMap: NodeAppHeadersJson | undefined): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare function createServer(listener: http.RequestListener, host: string, port: number): {
+    host: string;
+    port: number;
+    closed(): Promise<void>;
+    stop(): Promise<void>;
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+};

node_modules/@astrojs/node/dist/standalone.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import enableDestroy from "server-destroy";
+import { logListeningOn } from "./log-listening-on.js";
+import { createAppHandler } from "./serve-app.js";
+import { createStaticHandler } from "./serve-static.js";
+const hostOptions = (host) => {
+  if (typeof host === "boolean") {
+    return host ? "0.0.0.0" : "localhost";
+  }
+  return host;
+};
+function standalone(app, options, headersMap) {
+  const port = process.env.PORT ? Number(process.env.PORT) : options.port ?? 8080;
+  const host = process.env.HOST ?? hostOptions(options.host);
+  const resolvedOptions = { ...options, port };
+  const handler = createStandaloneHandler(app, resolvedOptions, headersMap);
+  const server = createServer(handler, host, port);
+  server.server.listen(port, host);
+  if (process.env.ASTRO_NODE_LOGGING !== "disabled") {
+    logListeningOn(app.getAdapterLogger(), server.server, host);
+  }
+  return {
+    server,
+    done: server.closed()
+  };
+}
+function createStandaloneHandler(app, options, headersMap) {
+  const appHandler = createAppHandler(app, options);
+  const staticHandler = createStaticHandler(app, options, headersMap);
+  return (req, res) => {
+    try {
+      decodeURI(req.url);
+    } catch {
+      res.writeHead(400);
+      res.end("Bad request.");
+      return;
+    }
+    staticHandler(req, res, () => appHandler(req, res));
+  };
+}
+function createServer(listener, host, port) {
+  let httpServer;
+  if (process.env.SERVER_CERT_PATH && process.env.SERVER_KEY_PATH) {
+    httpServer = https.createServer(
+      {
+        key: fs.readFileSync(process.env.SERVER_KEY_PATH),
+        cert: fs.readFileSync(process.env.SERVER_CERT_PATH)
+      },
+      listener
+    );
+  } else {
+    httpServer = http.createServer(listener);
+  }
+  enableDestroy(httpServer);
+  const closed = new Promise((resolve, reject) => {
+    httpServer.addListener("close", resolve);
+    httpServer.addListener("error", reject);
+  });
+  const previewable = {
+    host,
+    port,
+    closed() {
+      return closed;
+    },
+    async stop() {
+      await new Promise((resolve, reject) => {
+        httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
+      });
+    }
+  };
+  return {
+    server: httpServer,
+    ...previewable
+  };
+}
+export {
+  createServer,
+  createStandaloneHandler,
+  standalone as default,
+  hostOptions
+};

node_modules/@astrojs/node/dist/types.d.ts

@@ -0,0 +1,53 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface UserOptions {
+    /**
+     * Specifies the mode that the adapter builds to.
+     *
+     * - 'middleware' - Build to middleware, to be used within another Node.js server, such as Express.
+     * - 'standalone' - Build to a standalone server. The server starts up just by running the built script.
+     */
+    mode: 'middleware' | 'standalone';
+    /**
+     * Disables HTML streaming. This is useful for example if there are constraints from your host.
+     */
+    experimentalDisableStreaming?: boolean;
+    /**
+     * If enabled, the adapter will save [static headers in the framework API file](https://docs.netlify.com/frameworks-api/#headers).
+     *
+     * Here the list of the headers that are added:
+     * - The CSP header of the static pages is added when CSP support is enabled.
+     */
+    staticHeaders?: boolean;
+    /**
+     * Maximum allowed request body size in bytes. Requests with bodies larger than
+     * this limit will throw an error when the body is consumed.
+     *
+     * Set to `Infinity` or `0` to disable the limit.
+     *
+     * @default {1073741824} 1GB
+     */
+    bodySizeLimit?: number;
+}
+export interface Options extends UserOptions {
+    host: string | boolean;
+    port: number;
+    server: string;
+    client: string;
+    staticHeaders: boolean;
+    bodySizeLimit: number;
+}
+export type RequestHandler = (...args: RequestHandlerParams) => void | Promise<void>;
+type RequestHandlerParams = [
+    req: IncomingMessage,
+    res: ServerResponse,
+    next?: (err?: unknown) => void,
+    locals?: object
+];
+export type NodeAppHeadersJson = {
+    pathname: string;
+    headers: {
+        key: string;
+        value: string;
+    }[];
+}[];
+export {};

node_modules/@astrojs/node/dist/vite-plugin-config.d.ts

@@ -0,0 +1,3 @@
+import type { AstroConfig } from 'astro';
+import type { Options } from './types.js';
+export declare function createConfigPlugin(config: Options): NonNullable<AstroConfig['vite']['plugins']>[number];

node_modules/@astrojs/node/dist/vite-plugin-config.js

@@ -0,0 +1,36 @@
+const VIRTUAL_CONFIG_ID = "virtual:astro-node:config";
+const RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+const SERVER_ENVIRONMENTS = ["ssr", "prerender", "astro"];
+function createConfigPlugin(config) {
+  return {
+    name: VIRTUAL_CONFIG_ID,
+    configEnvironment(environmentName) {
+      if (SERVER_ENVIRONMENTS.includes(environmentName)) {
+        return {
+          resolve: {
+            noExternal: ["@astrojs/node"]
+          }
+        };
+      }
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_CONFIG_ID}$`)
+      },
+      handler() {
+        return RESOLVED_VIRTUAL_CONFIG_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_VIRTUAL_CONFIG_ID}$`)
+      },
+      handler() {
+        return Object.entries(config).map(([k, v]) => `export const ${k} = ${JSON.stringify(v)};`).join("\n");
+      }
+    }
+  };
+}
+export {
+  createConfigPlugin
+};