@netlify/plugin-nextjs 5.10.0-fetch-patch-logs → 5.10.1

package/dist/esm-chunks/chunk-DLVROEVU.js

@@ -1,144 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  copyNextDependencies,
-  copyNextServerCode,
-  verifyHandlerDirStructure
-} from "./chunk-IJZEDP6B.js";
-import {
-  wrapTracer
-} from "./chunk-5QSXBV7L.js";
-import {
-  init_esm,
-  trace
-} from "./chunk-GNGHTHMQ.js";
-import {
-  SERVER_HANDLER_NAME
-} from "./chunk-GFYWJNQR.js";
-import {
-  require_out
-} from "./chunk-KGYJQ2U2.js";
-import {
-  __toESM
-} from "./chunk-OEQOKJGE.js";
-
-// src/build/functions/server.ts
-init_esm();
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join, relative } from "node:path";
-import { join as posixJoin } from "node:path/posix";
-var import_fast_glob = __toESM(require_out(), 1);
-var tracer = wrapTracer(trace.getTracer("Next runtime"));
-var copyHandlerDependencies = async (ctx) => {
-  await tracer.withActiveSpan("copyHandlerDependencies", async (span) => {
-    const promises = [];
-    const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
-    includedFiles.push(
-      posixJoin(ctx.relativeAppDir, ".env"),
-      posixJoin(ctx.relativeAppDir, ".env.production"),
-      posixJoin(ctx.relativeAppDir, ".env.local"),
-      posixJoin(ctx.relativeAppDir, ".env.production.local")
-    );
-    span.setAttribute("next.includedFiles", includedFiles.join(","));
-    const resolvedFiles = await Promise.all(
-      includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
-    );
-    for (const filePath of resolvedFiles.flat()) {
-      promises.push(
-        cp(
-          join(process.cwd(), filePath),
-          // the serverHandlerDir is aware of the dist dir.
-          // The distDir must not be the package path therefore we need to rely on the
-          // serverHandlerDir instead of the serverHandlerRootDir
-          // therefore we need to remove the package path from the filePath
-          join(ctx.serverHandlerDir, relative(ctx.relativeAppDir, filePath)),
-          {
-            recursive: true,
-            force: true
-          }
-        )
-      );
-    }
-    promises.push(
-      writeFile(
-        join(ctx.serverHandlerRuntimeModulesDir, "package.json"),
-        JSON.stringify({ type: "module" })
-      )
-    );
-    const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
-    for (const filePath of fileList) {
-      promises.push(
-        cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerRuntimeModulesDir, filePath), {
-          recursive: true,
-          force: true
-        })
-      );
-    }
-    await Promise.all(promises);
-  });
-};
-var writeHandlerManifest = async (ctx) => {
-  await writeFile(
-    join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.json`),
-    JSON.stringify({
-      config: {
-        name: "Next.js Server Handler",
-        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
-        nodeBundler: "none",
-        // the folders can vary in monorepos based on the folder structure of the user so we have to glob all
-        includedFiles: ["**"],
-        includedFilesBasePath: ctx.serverHandlerRootDir
-      },
-      version: 1
-    }),
-    "utf-8"
-  );
-};
-var applyTemplateVariables = (template, variables) => {
-  return Object.entries(variables).reduce((acc, [key, value]) => {
-    return acc.replaceAll(key, value);
-  }, template);
-};
-var getHandlerFile = async (ctx) => {
-  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
-  const templateVariables = {
-    "{{useRegionalBlobs}}": ctx.useRegionalBlobs.toString()
-  };
-  if (ctx.relativeAppDir.length !== 0) {
-    const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
-    templateVariables["{{cwd}}"] = posixJoin(ctx.lambdaWorkingDirectory);
-    templateVariables["{{nextServerHandler}}"] = posixJoin(ctx.nextServerHandler);
-    return applyTemplateVariables(template, templateVariables);
-  }
-  return applyTemplateVariables(
-    await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8"),
-    templateVariables
-  );
-};
-var writeHandlerFile = async (ctx) => {
-  const handler = await getHandlerFile(ctx);
-  await writeFile(join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.mjs`), handler);
-};
-var clearStaleServerHandlers = async (ctx) => {
-  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
-};
-var createServerHandler = async (ctx) => {
-  await tracer.withActiveSpan("createServerHandler", async () => {
-    await mkdir(join(ctx.serverHandlerRuntimeModulesDir), { recursive: true });
-    await copyNextServerCode(ctx);
-    await copyNextDependencies(ctx);
-    await copyHandlerDependencies(ctx);
-    await writeHandlerManifest(ctx);
-    await writeHandlerFile(ctx);
-    await verifyHandlerDirStructure(ctx);
-  });
-};
-
-export {
-  clearStaleServerHandlers,
-  createServerHandler
-};

package/dist/esm-chunks/chunk-GFYWJNQR.js

@@ -1,305 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  require_semver
-} from "./chunk-APO262HE.js";
-import {
-  __toESM
-} from "./chunk-OEQOKJGE.js";
-
-// src/build/plugin-context.ts
-var import_semver = __toESM(require_semver(), 1);
-import { existsSync, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { join, relative, resolve } from "node:path";
-import { join as posixJoin } from "node:path/posix";
-import { fileURLToPath } from "node:url";
-var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
-var PLUGIN_DIR = join(MODULE_DIR, "../..");
-var DEFAULT_PUBLISH_DIR = ".next";
-var SERVER_HANDLER_NAME = "___netlify-server-handler";
-var EDGE_HANDLER_NAME = "___netlify-edge-handler";
-var PluginContext = class {
-  featureFlags;
-  netlifyConfig;
-  pluginName;
-  pluginVersion;
-  utils;
-  constants;
-  packageJSON;
-  /** Absolute path of the next runtime plugin directory */
-  pluginDir = PLUGIN_DIR;
-  get relPublishDir() {
-    return this.constants.PUBLISH_DIR ?? join(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR);
-  }
-  /** Temporary directory for stashing the build output */
-  get tempPublishDir() {
-    return this.resolveFromPackagePath(".netlify/.next");
-  }
-  /** Absolute path of the publish directory */
-  get publishDir() {
-    return resolve(this.relPublishDir);
-  }
-  /**
-   * Relative package path in non monorepo setups this is an empty string
-   * This path is provided by Next.js RequiredServerFiles manifest
-   * @example ''
-   * @example 'apps/my-app'
-   */
-  get relativeAppDir() {
-    return this.requiredServerFiles.relativeAppDir ?? "";
-  }
-  /**
-   * The working directory inside the lambda that is used for monorepos to execute the serverless function
-   */
-  get lambdaWorkingDirectory() {
-    return join("/var/task", this.distDirParent);
-  }
-  /**
-   * Retrieves the root of the `.next/standalone` directory
-   */
-  get standaloneRootDir() {
-    return join(this.publishDir, "standalone");
-  }
-  /**
-   * The resolved relative next dist directory defaults to `.next`,
-   * but can be configured through the next.config.js. For monorepos this will include the packagePath
-   * If we need just the plain dist dir use the `nextDistDir`
-   */
-  get distDir() {
-    const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
-    return relative(process.cwd(), resolve(this.relativeAppDir, dir));
-  }
-  /** Represents the parent directory of the .next folder or custom distDir */
-  get distDirParent() {
-    return join(this.distDir, "..");
-  }
-  /** The `.next` folder or what the custom dist dir is set to */
-  get nextDistDir() {
-    return relative(this.distDirParent, this.distDir);
-  }
-  /** Retrieves the `.next/standalone/` directory monorepo aware */
-  get standaloneDir() {
-    return join(this.standaloneRootDir, this.distDirParent);
-  }
-  /**
-   * Absolute path of the directory that is published and deployed to the Netlify CDN
-   * Will be swapped with the publish directory
-   * `.netlify/static`
-   */
-  get staticDir() {
-    return this.resolveFromPackagePath(".netlify/static");
-  }
-  /**
-   * Absolute path of the directory that will be deployed to the blob store
-   * region aware: `.netlify/deploy/v1/blobs/deploy`
-   * default: `.netlify/blobs/deploy`
-   */
-  get blobDir() {
-    if (this.useRegionalBlobs) {
-      return this.resolveFromPackagePath(".netlify/deploy/v1/blobs/deploy");
-    }
-    return this.resolveFromPackagePath(".netlify/blobs/deploy");
-  }
-  get buildVersion() {
-    return this.constants.NETLIFY_BUILD_VERSION || "v0.0.0";
-  }
-  get useRegionalBlobs() {
-    const REQUIRED_BUILD_VERSION = ">=29.41.5";
-    return (0, import_semver.satisfies)(this.buildVersion, REQUIRED_BUILD_VERSION, { includePrerelease: true });
-  }
-  /**
-   * Absolute path of the directory containing the files for the serverless lambda function
-   * `.netlify/functions-internal`
-   */
-  get serverFunctionsDir() {
-    return this.resolveFromPackagePath(".netlify/functions-internal");
-  }
-  /** Absolute path of the server handler */
-  get serverHandlerRootDir() {
-    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
-  }
-  get serverHandlerDir() {
-    if (this.relativeAppDir.length === 0) {
-      return this.serverHandlerRootDir;
-    }
-    return join(this.serverHandlerRootDir, this.distDirParent);
-  }
-  get serverHandlerRuntimeModulesDir() {
-    return join(this.serverHandlerDir, ".netlify");
-  }
-  get nextServerHandler() {
-    if (this.relativeAppDir.length !== 0) {
-      return join(this.lambdaWorkingDirectory, ".netlify/dist/run/handlers/server.js");
-    }
-    return "./.netlify/dist/run/handlers/server.js";
-  }
-  /**
-   * Absolute path of the directory containing the files for deno edge functions
-   * `.netlify/edge-functions`
-   */
-  get edgeFunctionsDir() {
-    return this.resolveFromPackagePath(".netlify/edge-functions");
-  }
-  /** Absolute path of the edge handler */
-  get edgeHandlerDir() {
-    return join(this.edgeFunctionsDir, EDGE_HANDLER_NAME);
-  }
-  constructor(options) {
-    this.constants = options.constants;
-    this.featureFlags = options.featureFlags;
-    this.netlifyConfig = options.netlifyConfig;
-    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
-    this.pluginName = this.packageJSON.name;
-    this.pluginVersion = this.packageJSON.version;
-    this.utils = options.utils;
-  }
-  /** Resolves a path correctly with mono repository awareness for .netlify directories mainly  */
-  resolveFromPackagePath(...args) {
-    return resolve(this.constants.PACKAGE_PATH || "", ...args);
-  }
-  /** Resolves a path correctly from site directory */
-  resolveFromSiteDir(...args) {
-    return resolve(this.requiredServerFiles.appDir, ...args);
-  }
-  /** Get the next prerender-manifest.json */
-  async getPrerenderManifest() {
-    return JSON.parse(await readFile(join(this.publishDir, "prerender-manifest.json"), "utf-8"));
-  }
-  /**
-   * Uses various heuristics to try to find the .next dir.
-   * Works by looking for BUILD_ID, so requires the site to have been built
-   */
-  findDotNext() {
-    for (const dir of [
-      // The publish directory
-      this.publishDir,
-      // In the root
-      resolve(DEFAULT_PUBLISH_DIR),
-      // The sibling of the publish directory
-      resolve(this.publishDir, "..", DEFAULT_PUBLISH_DIR),
-      // In the package dir
-      resolve(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR)
-    ]) {
-      if (existsSync(join(dir, "BUILD_ID"))) {
-        return dir;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get Next.js middleware config from the build output
-   */
-  async getMiddlewareManifest() {
-    return JSON.parse(
-      await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
-    );
-  }
-  // don't make private as it is handy inside testing to override the config
-  _requiredServerFiles = null;
-  /** Get RequiredServerFiles manifest from build output **/
-  get requiredServerFiles() {
-    if (!this._requiredServerFiles) {
-      let requiredServerFilesJson = join(this.publishDir, "required-server-files.json");
-      if (!existsSync(requiredServerFilesJson)) {
-        const dotNext = this.findDotNext();
-        if (dotNext) {
-          requiredServerFilesJson = join(dotNext, "required-server-files.json");
-        }
-      }
-      this._requiredServerFiles = JSON.parse(
-        readFileSync(requiredServerFilesJson, "utf-8")
-      );
-    }
-    return this._requiredServerFiles;
-  }
-  #exportDetail = null;
-  /** Get metadata when output = export */
-  get exportDetail() {
-    if (this.buildConfig.output !== "export") {
-      return null;
-    }
-    if (!this.#exportDetail) {
-      const detailFile = join(
-        this.requiredServerFiles.appDir,
-        this.buildConfig.distDir,
-        "export-detail.json"
-      );
-      if (!existsSync(detailFile)) {
-        return null;
-      }
-      try {
-        this.#exportDetail = JSON.parse(readFileSync(detailFile, "utf-8"));
-      } catch {
-      }
-    }
-    return this.#exportDetail;
-  }
-  /** Get Next Config from build output **/
-  get buildConfig() {
-    return this.requiredServerFiles.config;
-  }
-  /**
-   * Get Next.js routes manifest from the build output
-   */
-  async getRoutesManifest() {
-    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
-  }
-  #nextVersion = void 0;
-  /**
-   * Get Next.js version that was used to build the site
-   */
-  get nextVersion() {
-    if (this.#nextVersion === void 0) {
-      try {
-        const serverHandlerRequire = createRequire(posixJoin(this.standaloneRootDir, ":internal:"));
-        const { version } = serverHandlerRequire("next/package.json");
-        this.#nextVersion = version;
-      } catch {
-        this.#nextVersion = null;
-      }
-    }
-    return this.#nextVersion;
-  }
-  #fallbacks = null;
-  /**
-   * Get an array of localized fallback routes
-   *
-   * Example return value for non-i18n site: `['blog/[slug]']`
-   *
-   * Example return value for i18n site: `['en/blog/[slug]', 'fr/blog/[slug]']`
-   */
-  getFallbacks(prerenderManifest) {
-    if (!this.#fallbacks) {
-      const locales = this.buildConfig.i18n?.locales ?? [""];
-      this.#fallbacks = Object.entries(prerenderManifest.dynamicRoutes).reduce(
-        (fallbacks, [route, meta]) => {
-          if (typeof meta.fallback === "string") {
-            for (const locale of locales) {
-              const localizedRoute = posixJoin(locale, route.replace(/^\/+/g, ""));
-              fallbacks.push(localizedRoute);
-            }
-          }
-          return fallbacks;
-        },
-        []
-      );
-    }
-    return this.#fallbacks;
-  }
-  /** Fails a build with a message and an optional error */
-  failBuild(message, error) {
-    return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);
-  }
-};
-
-export {
-  SERVER_HANDLER_NAME,
-  EDGE_HANDLER_NAME,
-  PluginContext
-};

package/dist/esm-chunks/chunk-HXVWGXWM.js

@@ -1,218 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  getRegionalBlobStore
-} from "./chunk-RYJYZQ4X.js";
-import {
-  getLogger
-} from "./chunk-SGXRYMYQ.js";
-import {
-  encodeBlobKey
-} from "./chunk-TYCYFZ22.js";
-
-// src/run/headers.ts
-var ALL_VARIATIONS = Symbol.for("ALL_VARIATIONS");
-var NetlifyVaryKeys = /* @__PURE__ */ new Set(["header", "language", "cookie", "query", "country"]);
-var isNetlifyVaryKey = (key) => NetlifyVaryKeys.has(key);
-var generateNetlifyVaryValues = ({
-  header,
-  language,
-  cookie,
-  query,
-  country
-}) => {
-  const values = [];
-  if (query.length !== 0) {
-    if (query.includes(ALL_VARIATIONS)) {
-      values.push(`query`);
-    } else {
-      values.push(`query=${query.join(`|`)}`);
-    }
-  }
-  if (header.length !== 0) {
-    values.push(`header=${header.join(`|`)}`);
-  }
-  if (language.length !== 0) {
-    values.push(`language=${language.join(`|`)}`);
-  }
-  if (cookie.length !== 0) {
-    values.push(`cookie=${cookie.join(`|`)}`);
-  }
-  if (country.length !== 0) {
-    values.push(`country=${country.join(`|`)}`);
-  }
-  return values.join(",");
-};
-var getHeaderValueArray = (header) => {
-  return header.split(",").map((value) => value.trim()).filter(Boolean);
-};
-var omitHeaderValues = (header, values) => {
-  const headerValues = getHeaderValueArray(header);
-  const filteredValues = headerValues.filter(
-    (value) => !values.some((val) => value.startsWith(val))
-  );
-  return filteredValues.join(", ");
-};
-var setVaryHeaders = (headers, request, { basePath, i18n }) => {
-  const netlifyVaryValues = {
-    header: ["x-nextjs-data", "x-next-debug-logging"],
-    language: [],
-    cookie: ["__prerender_bypass", "__next_preview_data"],
-    query: ["__nextDataReq"],
-    country: []
-  };
-  const vary = headers.get("vary");
-  if (vary !== null) {
-    netlifyVaryValues.header.push(...getHeaderValueArray(vary));
-  }
-  const path = new URL(request.url).pathname;
-  const locales = i18n && i18n.localeDetection !== false ? i18n.locales : [];
-  if (locales.length > 1 && (path === "/" || path === basePath)) {
-    netlifyVaryValues.language.push(...locales);
-    netlifyVaryValues.cookie.push(`NEXT_LOCALE`);
-  }
-  const userNetlifyVary = headers.get("netlify-vary");
-  if (userNetlifyVary) {
-    const directives = getHeaderValueArray(userNetlifyVary);
-    for (const directive of directives) {
-      const [key, value] = directive.split("=");
-      if (key === "query" && !value) {
-        netlifyVaryValues.query.push(ALL_VARIATIONS);
-      } else if (value && isNetlifyVaryKey(key)) {
-        netlifyVaryValues[key].push(...value.split("|"));
-      }
-    }
-  }
-  headers.set(`netlify-vary`, generateNetlifyVaryValues(netlifyVaryValues));
-};
-var adjustDateHeader = async ({
-  headers,
-  request,
-  span,
-  tracer,
-  requestContext
-}) => {
-  const key = new URL(request.url).pathname;
-  let lastModified;
-  if (requestContext.responseCacheGetLastModified) {
-    lastModified = requestContext.responseCacheGetLastModified;
-  } else {
-    span.recordException(
-      new Error("lastModified not found in requestContext, falling back to trying blobs")
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    const blobStore = getRegionalBlobStore({ consistency: "strong" });
-    const blobKey = await encodeBlobKey(key);
-    lastModified = await tracer.withActiveSpan(
-      "get cache to calculate date header",
-      async (getBlobForDateSpan) => {
-        getBlobForDateSpan.setAttributes({
-          key,
-          blobKey
-        });
-        const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
-        getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        return blob.lastModified;
-      }
-    );
-  }
-  if (!lastModified) {
-    span.recordException(
-      new Error(
-        "lastModified not found in either requestContext or blobs, date header for cached response is not set"
-      )
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    return;
-  }
-  const lastModifiedDate = new Date(lastModified);
-  headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
-  headers.set("date", lastModifiedDate.toUTCString());
-};
-function setCacheControlFromRequestContext(headers, revalidate) {
-  const cdnCacheControl = (
-    // if we are serving already stale response, instruct edge to not attempt to cache that response
-    headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : `s-maxage=${revalidate || 31536e3}, stale-while-revalidate=31536000, durable`
-  );
-  headers.set("netlify-cdn-cache-control", cdnCacheControl);
-}
-var setCacheControlHeaders = ({ headers, status }, request, requestContext, nextConfig) => {
-  if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    setCacheControlFromRequestContext(headers, requestContext.routeHandlerRevalidate);
-    return;
-  }
-  if (status === 308 && request.url.endsWith("/") !== nextConfig.trailingSlash) {
-    getLogger().withFields({ trailingSlash: nextConfig.trailingSlash, location: headers.get("location") }).log("NetlifyHeadersHandler.trailingSlashRedirect");
-  }
-  const cacheControl = headers.get("cache-control");
-  if (status === 404) {
-    if (request.url.endsWith(".php")) {
-      headers.set("cache-control", "public, max-age=0, must-revalidate");
-      headers.set("netlify-cdn-cache-control", `max-age=31536000, durable`);
-      return;
-    }
-    if (process.env.CACHE_404_PAGE && request.url.endsWith("/404") && ["GET", "HEAD"].includes(request.method)) {
-      setCacheControlFromRequestContext(headers, requestContext.pageHandlerRevalidate);
-      return;
-    }
-  }
-  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    const browserCacheControl = omitHeaderValues(cacheControl, [
-      "s-maxage",
-      "stale-while-revalidate"
-    ]);
-    const cdnCacheControl = (
-      // if we are serving already stale response, instruct edge to not attempt to cache that response
-      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : [
-        ...getHeaderValueArray(cacheControl).map(
-          (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
-        ),
-        "durable"
-      ].join(", ")
-    );
-    headers.set("cache-control", browserCacheControl || "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", cdnCacheControl);
-    return;
-  }
-  if (cacheControl === null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control") && requestContext.usedFsReadForNonFallback) {
-    headers.set("cache-control", "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", `max-age=31536000, durable`);
-  }
-};
-var setCacheTagsHeaders = (headers, requestContext) => {
-  if (requestContext.responseCacheTags && (headers.has("cache-control") || headers.has("netlify-cdn-cache-control"))) {
-    headers.set("netlify-cache-tag", requestContext.responseCacheTags.join(","));
-  }
-};
-var NEXT_CACHE_TO_CACHE_STATUS = {
-  HIT: `hit`,
-  MISS: `fwd=miss`,
-  STALE: `hit; fwd=stale`
-};
-var setCacheStatusHeader = (headers, nextCache) => {
-  if (typeof nextCache === "string") {
-    if (nextCache in NEXT_CACHE_TO_CACHE_STATUS) {
-      const cacheStatus = NEXT_CACHE_TO_CACHE_STATUS[nextCache];
-      headers.set("cache-status", `"Next.js"; ${cacheStatus}`);
-    }
-    headers.delete("x-nextjs-cache");
-  }
-};
-
-export {
-  setVaryHeaders,
-  adjustDateHeader,
-  setCacheControlHeaders,
-  setCacheTagsHeaders,
-  setCacheStatusHeader
-};