@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-qn4z5s3c.js

@@ -0,0 +1,819 @@
+// @bun
+import {
+  hasLocalMatch,
+  hasRemoteMatch
+} from "./index-tgsfjmep.js";
+import {
+  getImagesConfig
+} from "./index-357na4a8.js";
+import {
+  cacheHandlerGet,
+  cacheHandlerSet,
+  hasCacheHandler
+} from "./index-bcws5eh2.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/image-optimizer/optimize.ts
+import path2 from "path";
+
+// src/compat/image-optimizer/detect.ts
+var AVIF = "image/avif";
+var WEBP = "image/webp";
+var PNG = "image/png";
+var JPEG = "image/jpeg";
+var JXL = "image/jxl";
+var JP2 = "image/jp2";
+var HEIC = "image/heic";
+var GIF = "image/gif";
+var SVG = "image/svg+xml";
+var ICO = "image/x-icon";
+var ICNS = "image/x-icns";
+var TIFF = "image/tiff";
+var BMP = "image/bmp";
+var PDF = "application/pdf";
+var ANIMATABLE_TYPES = [WEBP, PNG, GIF];
+var BYPASS_TYPES = [SVG, ICO, ICNS, BMP, JXL, HEIC];
+var EXTENSION_BY_TYPE = {
+  [AVIF]: "avif",
+  [WEBP]: "webp",
+  [PNG]: "png",
+  [JPEG]: "jpeg",
+  [JXL]: "jxl",
+  [JP2]: "jp2",
+  [HEIC]: "heic",
+  [GIF]: "gif",
+  [SVG]: "svg",
+  [ICO]: "ico",
+  [ICNS]: "icns",
+  [TIFF]: "tiff",
+  [BMP]: "bmp"
+};
+var TYPE_BY_EXTENSION = Object.fromEntries(Object.entries(EXTENSION_BY_TYPE).map(([type, ext]) => [ext, type]));
+function extensionForType(contentType) {
+  return EXTENSION_BY_TYPE[contentType];
+}
+function typeForExtension(extension) {
+  return TYPE_BY_EXTENSION[extension];
+}
+function startsWithBytes(buffer, bytes) {
+  return bytes.every((b, i) => !b || buffer[i] === b);
+}
+function detectContentType(buffer) {
+  if (buffer.byteLength === 0)
+    return null;
+  if ([255, 216, 255].every((b, i) => buffer[i] === b))
+    return JPEG;
+  if ([137, 80, 78, 71, 13, 10, 26, 10].every((b, i) => buffer[i] === b)) {
+    return PNG;
+  }
+  if ([71, 73, 70, 56].every((b, i) => buffer[i] === b))
+    return GIF;
+  if (startsWithBytes(buffer, [82, 73, 70, 70, 0, 0, 0, 0, 87, 69, 66, 80])) {
+    return WEBP;
+  }
+  if ([60, 63, 120, 109, 108].every((b, i) => buffer[i] === b))
+    return SVG;
+  if ([60, 115, 118, 103].every((b, i) => buffer[i] === b))
+    return SVG;
+  if (startsWithBytes(buffer, [0, 0, 0, 0, 102, 116, 121, 112, 97, 118, 105, 102])) {
+    return AVIF;
+  }
+  if ([0, 0, 1, 0].every((b, i) => buffer[i] === b))
+    return ICO;
+  if ([105, 99, 110, 115].every((b, i) => buffer[i] === b))
+    return ICNS;
+  if ([73, 73, 42, 0].every((b, i) => buffer[i] === b))
+    return TIFF;
+  if ([77, 77, 0, 42].every((b, i) => buffer[i] === b))
+    return TIFF;
+  if ([66, 77].every((b, i) => buffer[i] === b))
+    return BMP;
+  if ([255, 10].every((b, i) => buffer[i] === b))
+    return JXL;
+  if ([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10].every((b, i) => buffer[i] === b)) {
+    return JXL;
+  }
+  if (startsWithBytes(buffer, [0, 0, 0, 0, 102, 116, 121, 112, 104, 101, 105, 99])) {
+    return HEIC;
+  }
+  if ([37, 80, 68, 70, 45].every((b, i) => buffer[i] === b))
+    return PDF;
+  if ([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10].every((b, i) => buffer[i] === b)) {
+    return JP2;
+  }
+  const head = buffer.toString("utf8", 0, Math.min(buffer.length, 512)).trimStart();
+  if (/^(<\?xml|<!doctype svg|<svg)/i.test(head))
+    return SVG;
+  return null;
+}
+function isAnimated(buffer) {
+  if (buffer.length > 6 && buffer.toString("ascii", 0, 3) === "GIF") {
+    let frames = 0;
+    for (let i = 0;i < buffer.length - 2; i++) {
+      if (buffer[i] === 33 && buffer[i + 1] === 249 && buffer[i + 2] === 4) {
+        frames++;
+        if (frames > 1)
+          return true;
+      }
+    }
+    return false;
+  }
+  if (buffer.length > 8 && [137, 80, 78, 71, 13, 10, 26, 10].every((b, i) => buffer[i] === b)) {
+    const actl = buffer.indexOf("acTL");
+    if (actl === -1)
+      return false;
+    const idat = buffer.indexOf("IDAT");
+    return idat === -1 || actl < idat;
+  }
+  if (buffer.length > 16 && buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") {
+    return buffer.includes("ANIM");
+  }
+  return false;
+}
+
+// src/compat/image-optimizer/cache.ts
+import { createHash } from "crypto";
+import { promises as fs } from "fs";
+import path from "path";
+var IMAGE_CACHE_VERSION = 4;
+function getHash(items) {
+  const hash = createHash("sha256");
+  for (const item of items) {
+    hash.update(typeof item === "number" ? String(item) : item);
+  }
+  return hash.digest("base64url");
+}
+function imageCacheDir(root) {
+  return path.join(root, ".next", "cache", "images");
+}
+async function readCacheEntry(cacheDir, cacheKey) {
+  try {
+    const dir = path.join(cacheDir, cacheKey);
+    const files = await fs.readdir(dir);
+    const file = files[0];
+    if (!file)
+      return;
+    const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split(".", 5);
+    if (!etag || !upstreamEtag || !extension)
+      return;
+    const buffer = await fs.readFile(path.join(dir, file));
+    return {
+      buffer,
+      etag,
+      upstreamEtag,
+      extension,
+      maxAge: Number(maxAgeSt),
+      expireAt: Number(expireAtSt)
+    };
+  } catch {
+    return;
+  }
+}
+async function writeCacheEntry(cacheDir, cacheKey, entry, maximumDiskCacheSize) {
+  if (maximumDiskCacheSize === 0)
+    return;
+  if (maximumDiskCacheSize !== undefined && entry.buffer.byteLength > maximumDiskCacheSize) {
+    return;
+  }
+  try {
+    const dir = path.join(cacheDir, cacheKey);
+    const filename = path.join(dir, `${entry.maxAge}.${entry.expireAt}.${entry.etag}.${entry.upstreamEtag}.${entry.extension}`);
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {
+      return;
+    });
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filename, entry.buffer);
+    if (maximumDiskCacheSize !== undefined) {
+      await evictToBudget(cacheDir, cacheKey, maximumDiskCacheSize);
+    }
+  } catch (err) {
+    console.error(`Failed to write image to cache ${cacheKey}`, err);
+  }
+}
+async function evictToBudget(cacheDir, keepKey, maximumDiskCacheSize) {
+  const keys = await fs.readdir(cacheDir).catch(() => []);
+  const entries = [];
+  let total = 0;
+  for (const key of keys) {
+    const dir = path.join(cacheDir, key);
+    const files = await fs.readdir(dir).catch(() => []);
+    const file = files[0];
+    if (!file)
+      continue;
+    const stat = await fs.stat(path.join(dir, file)).catch(() => null);
+    if (!stat)
+      continue;
+    total += stat.size;
+    entries.push({ key, size: stat.size, expireAt: Number(file.split(".", 2)[1]) || 0 });
+  }
+  if (total <= maximumDiskCacheSize)
+    return;
+  entries.sort((a, b) => a.expireAt - b.expireAt);
+  for (const entry of entries) {
+    if (total <= maximumDiskCacheSize)
+      break;
+    if (entry.key === keepKey)
+      continue;
+    await fs.rm(path.join(cacheDir, entry.key), { recursive: true, force: true }).catch(() => {
+      return;
+    });
+    total -= entry.size;
+  }
+}
+
+// src/compat/image-optimizer/source.ts
+import { lookup } from "dns/promises";
+import { isIP } from "net";
+class ImageError extends Error {
+  statusCode;
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode >= 400 ? statusCode : 500;
+  }
+}
+function extractEtag(etag, buffer) {
+  if (etag)
+    return Buffer.from(etag).toString("base64url");
+  return getHash([buffer]);
+}
+function isPrivateIp(ip) {
+  if (isIP(ip) === 4) {
+    const parts = ip.split(".").map(Number);
+    const [a = -1, b = -1] = parts;
+    return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+  }
+  const lower = ip.toLowerCase();
+  return lower === "::" || lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd") || lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb") || lower.startsWith("::ffff:127.") || lower === "localhost";
+}
+function isRedirect(status) {
+  return [301, 302, 303, 307, 308].includes(status);
+}
+async function readBodyWithLimit(body, maximumResponseBody, onExceeded) {
+  const chunks = [];
+  let totalSize = 0;
+  const reader = body.getReader();
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    const chunk = Buffer.from(value);
+    totalSize += chunk.byteLength;
+    if (totalSize > maximumResponseBody) {
+      await reader.cancel().catch(() => {
+        return;
+      });
+      onExceeded();
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody, count) {
+  if (!dangerouslyAllowLocalIP) {
+    const { hostname } = new URL(href);
+    let ips = [hostname];
+    if (!isIP(hostname)) {
+      const records = await lookup(hostname, { family: 0, all: true }).catch(() => [
+        { address: hostname }
+      ]);
+      ips = records.map((record) => record.address);
+    }
+    const privateIps = ips.filter((ip) => isPrivateIp(ip));
+    if (privateIps.length > 0) {
+      console.error("upstream image", href, "hostname resolved to private IP", JSON.stringify(privateIps), "If this is expected and you understand SSRF risk, use images.dangerouslyAllowLocalIP = true to continue.");
+      throw new ImageError(400, '"url" parameter is not allowed');
+    }
+  }
+  const res = await fetch(href, {
+    signal: AbortSignal.timeout(7000),
+    redirect: "manual"
+  }).catch((err) => err);
+  if (res instanceof Error) {
+    const err = res;
+    if (err.name === "TimeoutError" || err.name === "AbortError") {
+      console.error("upstream image response timed out for", href);
+      throw new ImageError(504, '"url" parameter is valid but upstream response timed out');
+    }
+    throw err;
+  }
+  const locationHeader = res.headers.get("Location");
+  if (isRedirect(res.status) && locationHeader && URL.canParse(locationHeader, href)) {
+    await res.body?.cancel().catch(() => {
+      return;
+    });
+    if (count === 0) {
+      console.error("upstream image response had too many redirects", href);
+      throw new ImageError(508, '"url" parameter is valid but upstream response is invalid');
+    }
+    const redirect = new URL(locationHeader, href).href;
+    return fetchExternalImage(redirect, dangerouslyAllowLocalIP, maximumResponseBody, count - 1);
+  }
+  if (!res.ok) {
+    console.error("upstream image response failed for", href, res.status);
+    throw new ImageError(res.status, '"url" parameter is valid but upstream response is invalid');
+  }
+  if (!res.body) {
+    console.error("upstream image response is empty for", href);
+    throw new ImageError(400, '"url" parameter is valid but upstream response is invalid');
+  }
+  const buffer = await readBodyWithLimit(res.body, maximumResponseBody, () => {
+    console.error("upstream image response exceeded maximum size for", href);
+    throw new ImageError(413, '"url" parameter is valid but upstream response is invalid');
+  });
+  return {
+    buffer,
+    contentType: res.headers.get("Content-Type"),
+    cacheControl: res.headers.get("Cache-Control"),
+    etag: extractEtag(res.headers.get("ETag"), buffer)
+  };
+}
+async function readPublicFile(publicDirs, href) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(href.split("?", 1)[0] ?? href);
+  } catch {
+    return;
+  }
+  if (decoded.includes("..") || decoded.includes("\x00"))
+    return;
+  const fs2 = await import("fs/promises");
+  const path2 = await import("path");
+  for (const dir of publicDirs) {
+    for (const form of ["NFC", "NFD"]) {
+      const candidate = path2.join(dir, ...decoded.normalize(form).split("/").filter(Boolean));
+      if (!candidate.startsWith(dir))
+        continue;
+      try {
+        return await fs2.readFile(candidate);
+      } catch {}
+    }
+  }
+  return;
+}
+async function fetchInternalImage(href, origin, maximumResponseBody) {
+  try {
+    const res = await fetch(new URL(href, origin), {
+      redirect: "follow",
+      headers: { "x-pnext-internal-image": "1" }
+    });
+    if (!res.body) {
+      console.error("internal image response is empty for", href);
+      throw new ImageError(400, '"url" parameter is valid but internal response is invalid');
+    }
+    const buffer = await readBodyWithLimit(res.body, maximumResponseBody, () => {
+      console.error("internal image response exceeded maximum size for", href);
+      throw new ImageError(413, '"url" parameter is valid but internal response is invalid');
+    });
+    if (buffer.byteLength === 0) {
+      console.error("internal image response is empty for", href);
+      throw new ImageError(400, '"url" parameter is valid but internal response is invalid');
+    }
+    return {
+      buffer,
+      contentType: res.headers.get("Content-Type"),
+      cacheControl: res.headers.get("Cache-Control"),
+      etag: extractEtag(res.headers.get("ETag"), buffer)
+    };
+  } catch (err) {
+    if (err instanceof ImageError)
+      throw err;
+    console.error("upstream image response failed for", href, err);
+    throw new ImageError(500, '"url" parameter is valid but upstream response is invalid');
+  }
+}
+
+// src/compat/image-optimizer/optimize.ts
+var sharpPromise;
+function loadSharp() {
+  if (!sharpPromise) {
+    sharpPromise = import("sharp").then((m) => m.default ?? m).catch(() => {
+      return;
+    });
+  }
+  return sharpPromise;
+}
+var warnedOnce = new Set;
+function warnOnce(message) {
+  if (warnedOnce.has(message))
+    return;
+  warnedOnce.add(message);
+  console.warn(message);
+}
+function badRequest(message) {
+  return new Response(message, { status: 400, headers: { "content-type": "text/plain" } });
+}
+function errorResponse(error) {
+  if (error instanceof ImageError) {
+    return new Response(error.message, {
+      status: error.statusCode,
+      headers: { "content-type": "text/plain" }
+    });
+  }
+  console.error("image optimizer failed", error);
+  return new Response("Internal Server Error", { status: 500 });
+}
+function getMaxAge(cacheControl) {
+  if (!cacheControl)
+    return 0;
+  for (const directive of cacheControl.split(",")) {
+    const [key = "", rawValue] = directive.trim().split("=", 2);
+    if (key.toLowerCase() !== "s-maxage" && key.toLowerCase() !== "max-age")
+      continue;
+    let value = (rawValue ?? "").toLowerCase();
+    if (value.startsWith('"') && value.endsWith('"'))
+      value = value.slice(1, -1);
+    const n = parseInt(value, 10);
+    if (!isNaN(n))
+      return n;
+  }
+  return 0;
+}
+function getSupportedMimeType(formats, accept) {
+  for (const format of formats) {
+    if (accept.includes(format))
+      return format;
+  }
+  return "";
+}
+function getFileNameWithExtension(url, contentType) {
+  const [urlWithoutQueryParams = url] = url.split("?", 1);
+  const fileNameWithExtension = urlWithoutQueryParams.split("/").pop();
+  if (!contentType || !fileNameWithExtension)
+    return "image.bin";
+  const [fileName = "image"] = fileNameWithExtension.split(".", 1);
+  const extension = extensionForType(contentType) ?? "bin";
+  return `${fileName}.${extension}`;
+}
+function contentDispositionHeader(type, fileName) {
+  if (/^[\x20-\x7e]*$/.test(fileName) && !fileName.includes('"')) {
+    return `${type}; filename="${fileName}"`;
+  }
+  return `${type}; filename*=UTF-8''${encodeURIComponent(fileName)}`;
+}
+function validateParams(request, searchParams, config, basePath) {
+  const url = searchParams.get("url");
+  const w = searchParams.get("w");
+  const q = searchParams.get("q");
+  if (!url)
+    return { errorMessage: '"url" parameter is required' };
+  if (url.length > 3072)
+    return { errorMessage: '"url" parameter is too long' };
+  if (url.startsWith("//")) {
+    return { errorMessage: '"url" parameter cannot be a protocol-relative URL (//)' };
+  }
+  let href;
+  let isAbsolute;
+  if (url.startsWith("/")) {
+    href = url;
+    isAbsolute = false;
+    let pathname = url.split("?", 1)[0] ?? url;
+    try {
+      pathname = decodeURIComponent(pathname);
+    } catch {}
+    if (/\/_next\/image($|\/)/.test(pathname)) {
+      return { errorMessage: '"url" parameter cannot be recursive' };
+    }
+    if (!hasLocalMatch(config.localPatterns, new URL(url, "http://n"))) {
+      return { errorMessage: '"url" parameter is not allowed' };
+    }
+  } else {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return { errorMessage: '"url" parameter is invalid' };
+    }
+    href = parsed.toString();
+    isAbsolute = true;
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      return { errorMessage: '"url" parameter is invalid' };
+    }
+    if (!hasRemoteMatch(config.domains, config.remotePatterns, parsed)) {
+      return { errorMessage: '"url" parameter is not allowed' };
+    }
+  }
+  if (!w)
+    return { errorMessage: '"w" parameter (width) is required' };
+  if (!/^[0-9]+$/.test(w)) {
+    return { errorMessage: '"w" parameter (width) must be an integer greater than 0' };
+  }
+  if (!q)
+    return { errorMessage: '"q" parameter (quality) is required' };
+  if (!/^[0-9]+$/.test(q)) {
+    return { errorMessage: '"q" parameter (quality) must be an integer between 1 and 100' };
+  }
+  const width = parseInt(w, 10);
+  if (width <= 0 || isNaN(width)) {
+    return { errorMessage: '"w" parameter (width) must be an integer greater than 0' };
+  }
+  const sizes = [...config.deviceSizes, ...config.imageSizes];
+  if (!sizes.includes(width)) {
+    return { errorMessage: `"w" parameter (width) of ${width} is not allowed` };
+  }
+  const quality = parseInt(q, 10);
+  if (isNaN(quality) || quality < 1 || quality > 100) {
+    return { errorMessage: '"q" parameter (quality) must be an integer between 1 and 100' };
+  }
+  if (config.qualities && !config.qualities.includes(quality)) {
+    return { errorMessage: `"q" parameter (quality) of ${q} is not allowed` };
+  }
+  const mimeType = getSupportedMimeType(config.formats, request.headers.get("accept") ?? "");
+  const isStatic = url.startsWith(`${basePath}/_next/static/media`) || url.startsWith(`${basePath}/_next/static/immutable/media`);
+  return { href, isAbsolute, isStatic, width, quality, mimeType };
+}
+async function optimizeImage(buffer, contentType, width, quality) {
+  const sharp = await loadSharp();
+  if (!sharp)
+    throw new Error("sharp is not available");
+  let transformer = sharp(buffer).timeout({ seconds: 7 }).rotate().resize(width, undefined, { withoutEnlargement: true });
+  if (contentType === AVIF) {
+    transformer = transformer.avif({ quality: Math.max(quality - 20, 1), effort: 3 });
+  } else if (contentType === WEBP) {
+    transformer = transformer.webp({ quality });
+  } else if (contentType === PNG) {
+    transformer = transformer.png({ quality });
+  } else if (contentType === JPEG) {
+    transformer = transformer.jpeg({ quality, mozjpeg: true });
+  }
+  return transformer.toBuffer();
+}
+async function generateImage(upstream, params, config) {
+  const { href, width, quality, mimeType } = params;
+  const upstreamBuffer = upstream.buffer;
+  const upstreamEtag = upstream.etag;
+  const maxAge = Math.max(config.minimumCacheTTL, getMaxAge(upstream.cacheControl));
+  const upstreamType = detectContentType(upstreamBuffer);
+  if (!upstreamType || !upstreamType.startsWith("image/") || upstreamType.includes(",")) {
+    console.error("The requested resource isn't a valid image for", href, "received", upstreamType);
+    throw new ImageError(400, "The requested resource isn't a valid image.");
+  }
+  if (upstreamType.startsWith("image/svg") && !config.dangerouslyAllowSVG) {
+    console.error(`The requested resource "${href}" has type "${upstreamType}" but dangerouslyAllowSVG is disabled. Consider adding the "unoptimized" property to the <Image>.`);
+    throw new ImageError(400, '"url" parameter is valid but image type is not allowed');
+  }
+  if (ANIMATABLE_TYPES.includes(upstreamType) && isAnimated(upstreamBuffer)) {
+    warnOnce(`The requested resource "${href}" is an animated image so it will not be optimized. Consider adding the "unoptimized" property to the <Image>.`);
+    return {
+      buffer: upstreamBuffer,
+      contentType: upstreamType,
+      maxAge,
+      etag: upstreamEtag,
+      upstreamEtag
+    };
+  }
+  if (BYPASS_TYPES.includes(upstreamType)) {
+    return {
+      buffer: upstreamBuffer,
+      contentType: upstreamType,
+      maxAge,
+      etag: upstreamEtag,
+      upstreamEtag
+    };
+  }
+  let contentType;
+  if (mimeType) {
+    contentType = mimeType;
+  } else if (extensionForType(upstreamType) && upstreamType !== WEBP && upstreamType !== AVIF) {
+    contentType = upstreamType;
+  } else {
+    contentType = JPEG;
+  }
+  try {
+    const optimizedBuffer = await optimizeImage(upstreamBuffer, contentType, width, quality);
+    return {
+      buffer: optimizedBuffer,
+      contentType,
+      maxAge,
+      etag: getHash([optimizedBuffer]),
+      upstreamEtag
+    };
+  } catch {
+    return {
+      buffer: upstreamBuffer,
+      contentType: upstreamType,
+      maxAge: config.minimumCacheTTL,
+      etag: upstreamEtag,
+      upstreamEtag
+    };
+  }
+}
+function resolveOptimizerConfig() {
+  const base = getImagesConfig();
+  const raw = getNextConfig().images ?? {};
+  return {
+    ...base,
+    maximumDiskCacheSize: typeof raw.maximumDiskCacheSize === "number" ? raw.maximumDiskCacheSize : undefined
+  };
+}
+function diskCacheEnabled(config) {
+  if (config.customCacheHandler && hasCacheHandler())
+    return false;
+  if (config.maximumDiskCacheSize === 0)
+    return false;
+  const experimental = getNextConfig().experimental ?? {};
+  return experimental.isrFlushToDisk !== false;
+}
+async function fetchUpstream(params, config, coreConfig, origin) {
+  if (params.isAbsolute) {
+    return fetchExternalImage(params.href, config.dangerouslyAllowLocalIP, config.maximumResponseBody, config.maximumRedirects);
+  }
+  const publicFile = await readPublicFile([
+    path2.join(coreConfig.outPath, "public"),
+    coreConfig.publicPath,
+    path2.join(coreConfig.root, "public")
+  ], params.href);
+  if (publicFile) {
+    return {
+      buffer: publicFile,
+      contentType: null,
+      cacheControl: null,
+      etag: getHash([publicFile])
+    };
+  }
+  return fetchInternalImage(params.href, origin, config.maximumResponseBody);
+}
+async function generateAndStore(cacheKey, params, config, coreConfig, origin) {
+  const upstream = await fetchUpstream(params, config, coreConfig, origin);
+  const image = await generateImage(upstream, params, config);
+  const entry = {
+    buffer: image.buffer,
+    etag: image.etag,
+    upstreamEtag: image.upstreamEtag,
+    extension: extensionForType(image.contentType) ?? "bin",
+    maxAge: image.maxAge,
+    expireAt: Math.max(image.maxAge, config.minimumCacheTTL) * 1000 + Date.now(),
+    contentType: image.contentType
+  };
+  if (config.customCacheHandler && hasCacheHandler()) {
+    const revalidate = Math.max(image.maxAge, config.minimumCacheTTL);
+    await cacheHandlerSet(cacheKey, {
+      kind: "IMAGE",
+      buffer: entry.buffer.toString("base64"),
+      etag: entry.etag,
+      upstreamEtag: entry.upstreamEtag,
+      extension: entry.extension,
+      revalidate
+    }, { kind: "IMAGE" });
+  } else if (diskCacheEnabled(config)) {
+    await writeCacheEntry(imageCacheDir(coreConfig.root), cacheKey, entry, config.maximumDiskCacheSize);
+  }
+  return entry;
+}
+var inFlight = new Map;
+var refreshing = new Set;
+async function readCache(cacheKey, config, coreConfig) {
+  if (config.customCacheHandler && hasCacheHandler()) {
+    const cached = await cacheHandlerGet(cacheKey, { kind: "IMAGE" });
+    const value = cached?.value;
+    if (value?.kind !== "IMAGE" || typeof value.buffer !== "string")
+      return;
+    const revalidate = typeof value.revalidate === "number" ? value.revalidate : config.minimumCacheTTL;
+    const lastModified = cached?.lastModified ?? Date.now();
+    const expireAt = Math.max(revalidate, config.minimumCacheTTL) * 1000 + lastModified;
+    return {
+      buffer: Buffer.from(value.buffer, "base64"),
+      etag: typeof value.etag === "string" ? value.etag : getHash([value.buffer]),
+      upstreamEtag: typeof value.upstreamEtag === "string" ? value.upstreamEtag : "",
+      extension: typeof value.extension === "string" ? value.extension : "bin",
+      maxAge: revalidate,
+      expireAt,
+      isStale: expireAt < Date.now()
+    };
+  }
+  if (!diskCacheEnabled(config))
+    return;
+  const entry = await readCacheEntry(imageCacheDir(coreConfig.root), cacheKey);
+  if (!entry)
+    return;
+  return { ...entry, isStale: Date.now() > entry.expireAt };
+}
+function buildResponse(request, params, config, buffer, contentType, etag, maxAge, xCache) {
+  const headers = new Headers;
+  headers.set("Vary", "Accept");
+  headers.set("Cache-Control", params.isStatic ? "public, max-age=315360000, immutable" : `public, max-age=${maxAge}, must-revalidate`);
+  headers.set("ETag", etag);
+  const ifNoneMatch = request.headers.get("if-none-match");
+  if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === `"${etag}"`)) {
+    headers.set("X-Nextjs-Cache", xCache);
+    return new Response(null, { status: 304, headers });
+  }
+  headers.set("Content-Type", contentType);
+  const fileName = getFileNameWithExtension(params.href, contentType);
+  headers.set("Content-Disposition", contentDispositionHeader(config.contentDispositionType, fileName));
+  headers.set("Content-Security-Policy", config.contentSecurityPolicy);
+  headers.set("X-Nextjs-Cache", xCache);
+  headers.set("Content-Length", String(buffer.byteLength));
+  if (request.method === "HEAD")
+    return new Response(null, { status: 200, headers });
+  return new Response(new Uint8Array(buffer), { status: 200, headers });
+}
+async function serveImageOptimizer(request, coreConfig) {
+  const config = resolveOptimizerConfig();
+  const url = new URL(request.url);
+  const basePath = "";
+  const paramsResult = validateParams(request, url.searchParams, config, basePath);
+  if ("errorMessage" in paramsResult)
+    return badRequest(paramsResult.errorMessage);
+  const params = paramsResult;
+  const cacheKey = getHash([
+    IMAGE_CACHE_VERSION,
+    params.href,
+    params.width,
+    params.quality,
+    params.mimeType
+  ]);
+  const origin = url.origin;
+  try {
+    const cached = await readCache(cacheKey, config, coreConfig);
+    if (cached && !cached.isStale) {
+      return buildResponse(request, params, config, cached.buffer, typeForExtension(cached.extension) ?? "application/octet-stream", cached.etag, cached.maxAge, "HIT");
+    }
+    if (cached) {
+      if (!refreshing.has(cacheKey)) {
+        refreshing.add(cacheKey);
+        generateAndStore(cacheKey, params, config, coreConfig, origin).catch(() => {
+          return;
+        }).finally(() => refreshing.delete(cacheKey));
+      }
+      return buildResponse(request, params, config, cached.buffer, typeForExtension(cached.extension) ?? "application/octet-stream", cached.etag, cached.maxAge, "STALE");
+    }
+    let pending = inFlight.get(cacheKey);
+    if (!pending) {
+      pending = generateAndStore(cacheKey, params, config, coreConfig, origin);
+      inFlight.set(cacheKey, pending);
+      pending.catch(() => {
+        return;
+      }).finally(() => inFlight.delete(cacheKey));
+    }
+    const entry = await pending;
+    return buildResponse(request, params, config, entry.buffer, entry.contentType, entry.etag, entry.maxAge, "MISS");
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+
+// src/compat/next/image/optimizer.ts
+var BLUR_QUALITY = 70;
+var sharpPromise2;
+function loadSharp2() {
+  if (!sharpPromise2) {
+    sharpPromise2 = import("sharp").then((m) => m.default ?? m).catch(() => {
+      return;
+    });
+  }
+  return sharpPromise2;
+}
+function isImageOptimizerRequest(url, config) {
+  return url.pathname === config.path || url.pathname === `${config.path}/`;
+}
+var VALID_BLUR_EXT = new Set(["jpeg", "jpg", "png", "webp", "avif"]);
+function isAnimated2(buffer) {
+  if (buffer.length > 16 && buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") {
+    return buffer.includes(Buffer.from("ANIM", "ascii"));
+  }
+  if (buffer.length > 6 && buffer.toString("ascii", 0, 3) === "GIF") {
+    let frames = 0;
+    for (let i = 6;i < buffer.length; i++) {
+      if (buffer[i] === 44)
+        frames++;
+      if (frames > 1)
+        return true;
+    }
+    return false;
+  }
+  if (buffer.length > 16 && buffer.toString("ascii", 4, 8) === "ftyp") {
+    return buffer.toString("ascii", 8, 200).includes("avis");
+  }
+  return false;
+}
+async function generateBlurDataURL(buffer, ext, blurWidth, blurHeight) {
+  const extension = ext === "jpg" ? "jpeg" : ext;
+  if (!VALID_BLUR_EXT.has(extension) || isAnimated2(buffer))
+    return;
+  const sharp = await loadSharp2();
+  if (!sharp)
+    return;
+  try {
+    const pipeline = sharp(buffer).resize({ width: blurWidth, height: blurHeight });
+    let out;
+    if (extension === "png")
+      out = pipeline.png({ quality: BLUR_QUALITY });
+    else if (extension === "webp")
+      out = pipeline.webp({ quality: BLUR_QUALITY });
+    else if (extension === "avif")
+      out = pipeline.avif({ quality: BLUR_QUALITY });
+    else
+      out = pipeline.jpeg({ quality: BLUR_QUALITY, mozjpeg: true });
+    const resized = await out.toBuffer();
+    return `data:image/${extension};base64,${resized.toString("base64")}`;
+  } catch {
+    return;
+  }
+}
+
+export { serveImageOptimizer, isImageOptimizerRequest, generateBlurDataURL };