blank project

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,40 @@
+import {
+  removeLeadingForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { resolveInjectedRoute } from "../../core/routing/manifest/create.js";
+import { getPattern } from "../../core/routing/manifest/pattern.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 segments = [
+    [
+      {
+        content: removeTrailingForwardSlash(
+          removeLeadingForwardSlash(settings.config.image.endpoint.route)
+        ),
+        dynamic: false,
+        spread: false
+      }
+    ]
+  ];
+  return {
+    type: "endpoint",
+    isIndex: false,
+    route: settings.config.image.endpoint.route,
+    pattern: getPattern(segments, settings.config.base, settings.config.trailingSlash),
+    segments,
+    params: [],
+    component: resolveInjectedRoute(endpointEntrypoint, settings.config.root, cwd).component,
+    generate: () => "",
+    pathname: settings.config.image.endpoint.route,
+    prerender: false,
+    fallbackRoutes: [],
+    origin: "internal"
+  };
+}
+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,47 @@
+import { root } from "astro:config/server";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { isParentDirectory } from "@astrojs/internal-helpers/path";
+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) {
+  if (src.startsWith("/@fs/")) {
+    src = replaceFileSystemReferences(src);
+    if (!isParentDirectory(fileURLToPath(root), src)) {
+      return void 0;
+    }
+  }
+  if (isParentDirectory(fileURLToPath(root), src)) {
+    try {
+      return await readFile(src);
+    } catch {
+      return void 0;
+    }
+  } else {
+    const sourceUrl = new URL(src, url.origin);
+    if (sourceUrl.origin !== url.origin) {
+      return void 0;
+    }
+    return loadRemoteImage(sourceUrl);
+  }
+}
+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,66 @@
+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
+    });
+    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,39 @@
+import { outDir } from "astro:assets";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { isParentDirectory } from "@astrojs/internal-helpers/path";
+import { handleImageRequest } from "./shared.js";
+async function loadLocalImage(src, url) {
+  const idx = url.pathname.indexOf("/_image");
+  if (idx > 0) {
+    src = src.slice(idx);
+  }
+  if (!URL.canParse("." + src, outDir)) {
+    return void 0;
+  }
+  const fileUrl = new URL("." + src, outDir);
+  if (fileUrl.protocol !== "file:") {
+    return void 0;
+  }
+  if (!isParentDirectory(fileURLToPath(outDir), 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
+    });
+  }
+};
+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,57 @@
+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";
+async function loadRemoteImage(src) {
+  try {
+    const res = await fetch(src);
+    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 });
+  }
+  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
+};