Initial commit: New MoreminiMore website with fresh design

node_modules/astro/dist/assets/endpoint/config.d.ts

@@ -0,0 +1,2 @@
+import type { AstroSettings, RoutesList } from '../../types/astro.js';
+export declare function injectImageEndpoint(settings: AstroSettings, manifest: RoutesList, mode: 'dev' | 'build', cwd?: string): void;

node_modules/astro/dist/assets/endpoint/config.js

@@ -0,0 +1,20 @@
+import { resolveInjectedRoute } from "../../core/routing/create-manifest.js";
+import { parseRoute } from "../../core/routing/parse-route.js";
+function injectImageEndpoint(settings, manifest, mode, cwd) {
+  manifest.routes.unshift(getImageEndpointData(settings, mode, cwd));
+}
+function getImageEndpointData(settings, mode, cwd) {
+  const endpointEntrypoint = settings.config.image.endpoint.entrypoint === void 0 ? mode === "dev" ? "astro/assets/endpoint/dev" : "astro/assets/endpoint/generic" : settings.config.image.endpoint.entrypoint;
+  const component = resolveInjectedRoute(endpointEntrypoint, settings.config.root, cwd).component;
+  return parseRoute(settings.config.image.endpoint.route, settings, {
+    component,
+    type: "endpoint",
+    origin: "internal",
+    isIndex: false,
+    prerender: false,
+    params: []
+  });
+}
+export {
+  injectImageEndpoint
+};

node_modules/astro/dist/assets/endpoint/dev.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from '../../types/public/common.js';
+/**
+ * Endpoint used in dev and SSR to serve optimized images by the base image services
+ */
+export declare const GET: APIRoute;

node_modules/astro/dist/assets/endpoint/dev.js

@@ -0,0 +1,63 @@
+import { fsDenyGlob, safeModulePaths, viteFSConfig } from "astro:assets";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import { isFileLoadingAllowed } from "vite";
+import { handleImageRequest, loadRemoteImage } from "./shared.js";
+function replaceFileSystemReferences(src) {
+  return os.platform().includes("win32") ? src.replace(/^\/@fs\//, "") : src.replace(/^\/@fs/, "");
+}
+async function loadLocalImage(src, url) {
+  let returnValue;
+  let fsPath;
+  if (src.startsWith("/@fs/")) {
+    fsPath = replaceFileSystemReferences(src);
+  }
+  if (fsPath && isFileLoadingAllowed(
+    {
+      fsDenyGlob,
+      server: { fs: viteFSConfig },
+      safeModulePaths
+    },
+    fsPath
+  )) {
+    try {
+      returnValue = await readFile(fsPath);
+    } catch {
+      returnValue = void 0;
+    }
+    if (!returnValue) {
+      try {
+        const res = await fetch(new URL(src, url));
+        if (res.ok) {
+          returnValue = Buffer.from(await res.arrayBuffer());
+        }
+      } catch {
+        returnValue = void 0;
+      }
+    }
+  } else {
+    const sourceUrl = new URL(src, url.origin);
+    if (sourceUrl.origin !== url.origin) {
+      returnValue = void 0;
+    }
+    return loadRemoteImage(sourceUrl);
+  }
+  return returnValue;
+}
+const GET = async ({ request }) => {
+  if (!import.meta.env.DEV) {
+    console.error("The dev image endpoint can only be used in dev mode.");
+    return new Response("Invalid endpoint", { status: 500 });
+  }
+  try {
+    return await handleImageRequest({ request, loadLocalImage });
+  } catch (err) {
+    console.error("Could not process image request:", err);
+    return new Response(`Could not process image request: ${err}`, {
+      status: 500
+    });
+  }
+};
+export {
+  GET
+};

node_modules/astro/dist/assets/endpoint/generic.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from '../../types/public/common.js';
+/**
+ * Endpoint used in dev and SSR to serve optimized images by the base image services
+ */
+export declare const GET: APIRoute;

node_modules/astro/dist/assets/endpoint/generic.js

@@ -0,0 +1,70 @@
+import { imageConfig } from "astro:assets";
+import { isRemotePath } from "@astrojs/internal-helpers/path";
+import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+import * as mime from "mrmime";
+import { getConfiguredImageService } from "../internal.js";
+import { etag } from "../utils/etag.js";
+async function loadRemoteImage(src, headers) {
+  try {
+    const res = await fetch(src, {
+      // Forward all headers from the original request
+      headers,
+      redirect: "manual"
+    });
+    if (res.status >= 300 && res.status < 400) {
+      return void 0;
+    }
+    if (!res.ok) {
+      return void 0;
+    }
+    return await res.arrayBuffer();
+  } catch {
+    return void 0;
+  }
+}
+const GET = async ({ request }) => {
+  try {
+    const imageService = await getConfiguredImageService();
+    if (!("transform" in imageService)) {
+      throw new Error("Configured image service is not a local service");
+    }
+    const url = new URL(request.url);
+    const transform = await imageService.parseURL(url, imageConfig);
+    if (!transform?.src) {
+      throw new Error("Incorrect transform returned by `parseURL`");
+    }
+    let inputBuffer = void 0;
+    const isRemoteImage = isRemotePath(transform.src);
+    if (isRemoteImage && isRemoteAllowed(transform.src, imageConfig) === false) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    const sourceUrl = new URL(transform.src, url.origin);
+    if (!isRemoteImage && sourceUrl.origin !== url.origin) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    inputBuffer = await loadRemoteImage(sourceUrl, isRemoteImage ? new Headers() : request.headers);
+    if (!inputBuffer) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const { data, format } = await imageService.transform(
+      new Uint8Array(inputBuffer),
+      transform,
+      imageConfig
+    );
+    return new Response(data, {
+      status: 200,
+      headers: {
+        "Content-Type": mime.lookup(format) ?? `image/${format}`,
+        "Cache-Control": "public, max-age=31536000",
+        ETag: etag(data.toString()),
+        Date: (/* @__PURE__ */ new Date()).toUTCString()
+      }
+    });
+  } catch (err) {
+    console.error("Could not process image request:", err);
+    return new Response(`Server Error: ${err}`, { status: 500 });
+  }
+};
+export {
+  GET
+};

node_modules/astro/dist/assets/endpoint/node.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from '../../types/public/common.js';
+/**
+ * Endpoint used in dev and SSR to serve optimized images by the base image services
+ */
+export declare const GET: APIRoute;

node_modules/astro/dist/assets/endpoint/node.js

@@ -0,0 +1,56 @@
+import { outDir, serverDir } from "astro:assets";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isParentDirectory } from "@astrojs/internal-helpers/path";
+import { handleImageRequest } from "./shared.js";
+async function loadLocalImage(src, url) {
+  const outDirURL = resolveOutDir();
+  const idx = url.pathname.indexOf("/_image");
+  if (idx > 0) {
+    src = src.slice(idx);
+  }
+  if (!URL.canParse("." + src, outDirURL)) {
+    return void 0;
+  }
+  const fileUrl = new URL("." + src, outDirURL);
+  if (fileUrl.protocol !== "file:") {
+    return void 0;
+  }
+  if (!isParentDirectory(fileURLToPath(outDirURL), fileURLToPath(fileUrl))) {
+    return void 0;
+  }
+  try {
+    return await readFile(fileUrl);
+  } catch {
+    return void 0;
+  }
+}
+const GET = async ({ request }) => {
+  try {
+    return await handleImageRequest({ request, loadLocalImage });
+  } catch (err) {
+    console.error("Could not process image request:", err);
+    return new Response("Internal Server Error", {
+      status: 500
+    });
+  }
+};
+function resolveOutDir() {
+  const serverDirPath = fileURLToPath(serverDir);
+  const rel = path.relative(serverDirPath, fileURLToPath(outDir));
+  const serverFolder = path.basename(serverDirPath);
+  let serverEntryFolderURL = path.dirname(import.meta.url);
+  while (!serverEntryFolderURL.endsWith(serverFolder)) {
+    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
+  }
+  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
+  const outDirURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  return outDirURL;
+}
+function appendForwardSlash(pth) {
+  return pth.endsWith("/") ? pth : pth + "/";
+}
+export {
+  GET
+};

node_modules/astro/dist/assets/endpoint/shared.d.ts

@@ -0,0 +1,5 @@
+export declare function loadRemoteImage(src: URL): Promise<Buffer | undefined>;
+export declare const handleImageRequest: ({ request, loadLocalImage, }: {
+    request: Request;
+    loadLocalImage: (src: string, baseUrl: URL) => Promise<Buffer | undefined>;
+}) => Promise<Response>;

node_modules/astro/dist/assets/endpoint/shared.js

@@ -0,0 +1,67 @@
+import { imageConfig } from "astro:assets";
+import { isRemotePath, removeQueryString } from "@astrojs/internal-helpers/path";
+import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+import * as mime from "mrmime";
+import { getConfiguredImageService } from "../internal.js";
+import { etag } from "../utils/etag.js";
+import { inferSourceFormat } from "../utils/inferSourceFormat.js";
+async function loadRemoteImage(src) {
+  try {
+    const res = await fetch(src, { redirect: "manual" });
+    if (res.status >= 300 && res.status < 400) {
+      return void 0;
+    }
+    if (!res.ok) {
+      return void 0;
+    }
+    return Buffer.from(await res.arrayBuffer());
+  } catch {
+    return void 0;
+  }
+}
+const handleImageRequest = async ({
+  request,
+  loadLocalImage
+}) => {
+  const imageService = await getConfiguredImageService();
+  if (!("transform" in imageService)) {
+    throw new Error("Configured image service is not a local service");
+  }
+  const url = new URL(request.url);
+  const transform = await imageService.parseURL(url, imageConfig);
+  if (!transform?.src) {
+    return new Response("Invalid request", { status: 400 });
+  }
+  if (transform.format === "svg") {
+    const sourceFormat = inferSourceFormat(transform.src);
+    if (sourceFormat !== "svg") {
+      return new Response("Cannot convert non-SVG source to SVG format", { status: 403 });
+    }
+  }
+  let inputBuffer = void 0;
+  if (isRemotePath(transform.src)) {
+    if (!isRemoteAllowed(transform.src, imageConfig)) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    inputBuffer = await loadRemoteImage(new URL(transform.src));
+  } else {
+    inputBuffer = await loadLocalImage(removeQueryString(transform.src), url);
+  }
+  if (!inputBuffer) {
+    return new Response("Internal Server Error", { status: 500 });
+  }
+  const { data, format } = await imageService.transform(inputBuffer, transform, imageConfig);
+  return new Response(data, {
+    status: 200,
+    headers: {
+      "Content-Type": mime.lookup(format) ?? `image/${format}`,
+      "Cache-Control": "public, max-age=31536000",
+      ETag: etag(data.toString()),
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+export {
+  handleImageRequest,
+  loadRemoteImage
+};