@appwarden/middleware 3.11.5 → 3.12.0

package/README.md

@@ -4,7 +4,7 @@
 [![GitHub](https://img.shields.io/badge/GitHub-appwarden%2Fmiddleware-181717?logo=github&logoColor=white)](https://github.com/appwarden/middleware)
 [![npm version](https://img.shields.io/npm/v/@appwarden/middleware.svg)](https://www.npmjs.com/package/@appwarden/middleware)
 [![npm provenance](https://img.shields.io/badge/npm-provenance-green)](https://docs.npmjs.com/generating-provenance-statements)
-![Test Coverage](https://img.shields.io/badge/coverage-93.08%25-brightgreen)
+![Test Coverage](https://img.shields.io/badge/coverage-95.28%25-brightgreen)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 ## Core Features

package/{chunk-5HCAAVK5.js → chunk-6YCNCR22.js}

@@ -1,11 +1,9 @@
-import {
-  UseCSPInputSchema
-} from "./chunk-ZTVJBORU.js";
 import {
   AppwardenApiHostnameSchema,
   AppwardenApiTokenSchema,
-  BooleanSchema
-} from "./chunk-WEM7GS4M.js";
+  BooleanSchema,
+  UseCSPInputSchema
+} from "./chunk-Z7P4QVEY.js";
 
 // src/schemas/use-appwarden.ts
 import { z } from "zod";

package/{chunk-R7TXTHSG.js → chunk-EXGUJ5XK.js}

@@ -1,6 +1,13 @@
 import {
+  MemoryCache,
+  debug,
+  printMessage
+} from "./chunk-HTSD4WPC.js";
+import {
+  APPWARDEN_CACHE_KEY,
+  APPWARDEN_TEST_ROUTE,
   LockValue
-} from "./chunk-WEM7GS4M.js";
+} from "./chunk-Z7P4QVEY.js";
 
 // src/utils/cloudflare/cloudflare-cache.ts
 var store = {
@@ -38,51 +45,6 @@ var updateCacheValue = async (context, cacheKey, value, ttl) => {
 };
 var clearCache = (context, cacheKey) => context.cache.delete(cacheKey);
 
-// src/utils/cloudflare/csp-keywords.ts
-var CSP_KEYWORDS = [
-  "self",
-  "none",
-  "unsafe-inline",
-  "unsafe-eval",
-  "unsafe-hashes",
-  "strict-dynamic",
-  "report-sample",
-  "unsafe-allow-redirects",
-  "wasm-unsafe-eval",
-  "trusted-types-eval",
-  "report-sha256",
-  "report-sha384",
-  "report-sha512",
-  "unsafe-webtransport-hashes"
-];
-var CSP_KEYWORDS_SET = new Set(CSP_KEYWORDS);
-var isCSPKeyword = (value) => {
-  return CSP_KEYWORDS_SET.has(value.toLowerCase());
-};
-var isQuoted = (value) => {
-  return value.startsWith("'") && value.endsWith("'");
-};
-var autoQuoteCSPKeyword = (value) => {
-  const trimmed = value.trim();
-  if (isQuoted(trimmed)) {
-    return trimmed;
-  }
-  if (isCSPKeyword(trimmed)) {
-    return `'${trimmed}'`;
-  }
-  return trimmed;
-};
-var autoQuoteCSPDirectiveValue = (value) => {
-  return value.trim().split(/\s+/).filter(Boolean).map(autoQuoteCSPKeyword).join(" ");
-};
-var autoQuoteCSPDirectiveArray = (values) => {
-  return values.map(autoQuoteCSPKeyword);
-};
-
-// src/utils/print-message.ts
-var addSlashes = (str) => str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\u0000/g, "\\0").replace(/<\/script>/gi, "<\\/script>");
-var printMessage = (message) => `[@appwarden/middleware] ${addSlashes(message)}`;
-
 // src/utils/cloudflare/delete-edge-value.ts
 var deleteEdgeValue = async (context) => {
   try {
@@ -105,39 +67,6 @@ var deleteEdgeValue = async (context) => {
   }
 };
 
-// src/utils/errors.ts
-var errorsMap = {
-  mode: '`CSP_MODE` must be one of "disabled", "report-only", or "enforced"',
-  directives: {
-    ["DirectivesRequired" /* DirectivesRequired */]: '`CSP_DIRECTIVES` must be provided when `CSP_MODE` is "report-only" or "enforced"',
-    ["DirectivesBadParse" /* DirectivesBadParse */]: "Failed to parse `CSP_DIRECTIVES`. Is it a valid JSON string?"
-  },
-  appwardenApiToken: "Please provide a valid `appwardenApiToken`. Learn more at https://appwarden.com/docs/guides/api-token-management."
-};
-var getErrors = (error) => {
-  const matches = [];
-  const errors = [...Object.entries(error.flatten().fieldErrors)];
-  for (const issue of error.issues) {
-    errors.push(
-      ...Object.entries(
-        "returnTypeError" in issue ? issue.returnTypeError.flatten().fieldErrors : {}
-      )
-    );
-  }
-  for (const [field, maybeSchemaErrorKey] of errors) {
-    let match = errorsMap[field];
-    if (match) {
-      if (match instanceof Object) {
-        if (maybeSchemaErrorKey) {
-          match = match[maybeSchemaErrorKey[0]];
-        }
-      }
-      matches.push(match);
-    }
-  }
-  return matches;
-};
-
 // src/utils/cloudflare/get-lock-value.ts
 var getLockValue = async (context) => {
   try {
@@ -181,56 +110,6 @@ var getLockValue = async (context) => {
   }
 };
 
-// src/utils/cloudflare/insert-errors-logs.ts
-var insertErrorLogs = async (context, error) => {
-  const errors = getErrors(error);
-  for (const err of errors) {
-    console.log(printMessage(err));
-  }
-  return new HTMLRewriter().on("body", {
-    element: (elem) => {
-      elem.append(
-        `<script>
-            ${errors.map((err) => `console.error(\`${printMessage(err)}\`)`).join("\n")}
-          </script>`,
-        { html: true }
-      );
-    }
-  }).transform(await fetch(context.request.clone()));
-};
-
-// src/utils/cloudflare/make-csp-header.ts
-var addNonce = (value, cspNonce) => value.replace("{{nonce}}", `'nonce-${cspNonce}'`);
-var makeCSPHeader = (cspNonce, directives, mode) => {
-  const namesSeen = /* @__PURE__ */ new Set(), result = [];
-  Object.entries(directives ?? {}).forEach(([originalName, value]) => {
-    const name = originalName.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-    if (namesSeen.has(name)) {
-      throw new Error(`${originalName} is specified more than once`);
-    }
-    namesSeen.add(name);
-    let directiveValue;
-    if (Array.isArray(value)) {
-      directiveValue = autoQuoteCSPDirectiveArray(value).join(" ");
-    } else if (value === true) {
-      directiveValue = "";
-    } else if (typeof value === "string") {
-      directiveValue = autoQuoteCSPDirectiveValue(value);
-    } else {
-      return;
-    }
-    if (directiveValue) {
-      result.push(`${name} ${addNonce(directiveValue, cspNonce)}`);
-    } else {
-      result.push(name);
-    }
-  });
-  return [
-    mode === "enforced" ? "Content-Security-Policy" : "Content-Security-Policy-Report-Only",
-    result.join("; ")
-  ];
-};
-
 // src/utils/cloudflare/sync-edge-value.ts
 var APIError = class extends Error {
   constructor(message) {
@@ -287,19 +166,72 @@ var syncEdgeValue = async (context) => {
   }
 };
 
+// src/core/check-lock-status.ts
+var createContext = async (config) => {
+  const requestUrl = new URL(config.request.url);
+  const keyName = APPWARDEN_CACHE_KEY;
+  const provider = "cloudflare-cache";
+  const debugFn = debug(config.debug ?? false);
+  const edgeCache = store.json(
+    {
+      serviceOrigin: requestUrl.origin,
+      cache: await caches.open("appwarden:lock"),
+      debug: debugFn
+    },
+    keyName
+  );
+  return {
+    keyName,
+    request: config.request,
+    edgeCache,
+    requestUrl,
+    provider,
+    debug: debugFn,
+    lockPageSlug: config.lockPageSlug,
+    appwardenApiToken: config.appwardenApiToken,
+    appwardenApiHostname: config.appwardenApiHostname,
+    waitUntil: config.waitUntil
+  };
+};
+var resolveLockStatus = async (context) => {
+  const { lockValue, shouldDeleteEdgeValue } = await getLockValue(context);
+  if (shouldDeleteEdgeValue) {
+    context.debug("Deleting corrupted cache value");
+    await deleteEdgeValue(context);
+  }
+  const isTestRoute = context.requestUrl.pathname === APPWARDEN_TEST_ROUTE;
+  const isTestLock = isTestRoute && !MemoryCache.isTestExpired(lockValue) && !!lockValue;
+  return {
+    isLocked: !!lockValue?.isLocked || isTestLock,
+    isTestLock,
+    lockValue,
+    wasDeleted: shouldDeleteEdgeValue ?? false
+  };
+};
+var checkLockStatus = async (config) => {
+  const context = await createContext(config);
+  let { isLocked, isTestLock, lockValue, wasDeleted } = await resolveLockStatus(context);
+  const isExpired = MemoryCache.isExpired(lockValue);
+  if (!isExpired && !wasDeleted && lockValue) {
+    context.debug("Lock value resolved from cache");
+  }
+  if (isExpired || wasDeleted) {
+    if (!lockValue || wasDeleted || lockValue.isLocked) {
+      context.debug(
+        "No fresh cached lock status available - syncing with API synchronously"
+      );
+      await syncEdgeValue(context);
+      ({ isLocked, isTestLock } = await resolveLockStatus(context));
+    } else {
+      context.debug(
+        "Cached lock status expired but last known state unlocked - syncing with API in background"
+      );
+      config.waitUntil(syncEdgeValue(context));
+    }
+  }
+  return { isLocked, isTestLock };
+};
+
 export {
-  printMessage,
-  getErrors,
-  store,
-  CSP_KEYWORDS,
-  isCSPKeyword,
-  isQuoted,
-  autoQuoteCSPKeyword,
-  autoQuoteCSPDirectiveValue,
-  autoQuoteCSPDirectiveArray,
-  deleteEdgeValue,
-  getLockValue,
-  insertErrorLogs,
-  makeCSPHeader,
-  syncEdgeValue
+  checkLockStatus
 };

package/chunk-G6BMPIYD.js

@@ -0,0 +1,11 @@
+// src/utils/get-now.ts
+var getNowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var getElapsedMs = (startTime) => Math.round(getNowMs() - startTime);
+var logElapsed = (debug, startTime) => {
+  debug(`Middleware executed in ${getElapsedMs(startTime)}ms`);
+};
+
+export {
+  getNowMs,
+  logElapsed
+};

package/chunk-HTSD4WPC.js

@@ -0,0 +1,378 @@
+import {
+  APPWARDEN_HEARTBEAT_ROUTE,
+  HEARTBEAT_CONFIG_ERROR_MAX_CODE_LENGTH,
+  HEARTBEAT_CONFIG_ERROR_MAX_COUNT,
+  HEARTBEAT_CONFIG_ERROR_MAX_MESSAGE_LENGTH,
+  HEARTBEAT_CONFIG_ERROR_MAX_PATH_DEPTH,
+  HEARTBEAT_CONFIG_ERROR_MAX_PATH_SEGMENT_LENGTH,
+  HEARTBEAT_CONTRACT_VERSION,
+  LOCKDOWN_TEST_EXPIRY_MS
+} from "./chunk-Z7P4QVEY.js";
+
+// src/utils/build-lock-page-url.ts
+function normalizeLockPageSlug(lockPageSlug) {
+  return lockPageSlug.startsWith("/") ? lockPageSlug : `/${lockPageSlug}`;
+}
+function buildLockPageUrl(lockPageSlug, requestUrl) {
+  const normalizedSlug = normalizeLockPageSlug(lockPageSlug);
+  return new URL(normalizedSlug, requestUrl);
+}
+function normalizeTrailingSlash(path) {
+  if (path === "/") return path;
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function isOnLockPage(lockPageSlug, requestUrl) {
+  const normalizedSlug = normalizeTrailingSlash(
+    normalizeLockPageSlug(lockPageSlug)
+  );
+  const url = typeof requestUrl === "string" ? new URL(requestUrl) : requestUrl;
+  const normalizedPathname = normalizeTrailingSlash(url.pathname);
+  return normalizedPathname === normalizedSlug;
+}
+
+// src/utils/create-redirect.ts
+var TEMPORARY_REDIRECT_STATUS = 302;
+var createRedirect = (url) => {
+  return new Response(null, {
+    status: TEMPORARY_REDIRECT_STATUS,
+    headers: {
+      Location: url.toString()
+    }
+  });
+};
+
+// src/utils/print-message.ts
+var addSlashes = (str) => str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\u0000/g, "\\0").replace(/<\/script>/gi, "<\\/script>");
+var printMessage = (message) => `[@appwarden/middleware] ${addSlashes(message)}`;
+
+// src/utils/debug.ts
+var debug = (isDebug) => (...msg) => {
+  if (!isDebug) return;
+  const parts = msg.map((m) => {
+    let content;
+    if (m instanceof Error) {
+      content = m.stack ?? m.message;
+    } else if (typeof m === "object" && m !== null) {
+      try {
+        content = JSON.stringify(m);
+      } catch {
+        try {
+          content = String(m);
+        } catch {
+          content = "[Unserializable value]";
+        }
+      }
+    } else {
+      content = String(m);
+    }
+    return content;
+  });
+  const message = parts.join(" ");
+  console.log(printMessage(message));
+};
+
+// src/utils/memory-cache.ts
+var MemoryCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(options) {
+    this.maxSize = options.maxSize;
+  }
+  get(key) {
+    let item;
+    if (this.cache.has(key)) {
+      item = this.cache.get(key);
+      this.cache.delete(key);
+      if (item !== void 0) {
+        this.cache.set(key, item);
+      }
+    }
+    return item;
+  }
+  put(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  getValues() {
+    return this.cache;
+  }
+  // the default value will be expired here
+  static isExpired = (lockValue) => {
+    if (!lockValue) {
+      return true;
+    }
+    return Date.now() > lockValue.lastCheck + 3e4;
+  };
+  static isTestExpired = (lockValue) => {
+    if (!lockValue) {
+      return true;
+    }
+    return Date.now() > lockValue.isLockedTest + LOCKDOWN_TEST_EXPIRY_MS;
+  };
+};
+
+// src/version.ts
+var MIDDLEWARE_VERSION = "3.11.6";
+
+// src/utils/heartbeat.ts
+function createSanitizedMessage(code, path) {
+  const fieldName = path.length > 0 ? path[path.length - 1] : "field";
+  switch (code) {
+    case "invalid_type":
+      return `Invalid type for ${fieldName}`;
+    case "invalid_literal":
+      return `Invalid value for ${fieldName}`;
+    case "unrecognized_keys":
+      return `Unrecognized keys in ${fieldName}`;
+    case "invalid_union":
+      return `Invalid union value for ${fieldName}`;
+    case "invalid_enum_value":
+      return `Invalid enum value for ${fieldName}`;
+    case "invalid_arguments":
+      return `Invalid arguments for ${fieldName}`;
+    case "invalid_return_type":
+      return `Invalid return type for ${fieldName}`;
+    case "invalid_date":
+      return `Invalid date for ${fieldName}`;
+    case "invalid_string":
+      return `Invalid string format for ${fieldName}`;
+    case "too_small":
+      return `Value too small for ${fieldName}`;
+    case "too_big":
+      return `Value too large for ${fieldName}`;
+    case "invalid_intersection_types":
+      return `Invalid intersection types for ${fieldName}`;
+    case "not_multiple_of":
+      return `Value not a multiple of required value for ${fieldName}`;
+    case "not_finite":
+      return `Value must be finite for ${fieldName}`;
+    case "custom":
+      return `Validation failed for ${fieldName}`;
+    default:
+      return `Validation error for ${fieldName}`;
+  }
+}
+function sanitizePath(path) {
+  const truncatedPath = path.slice(0, HEARTBEAT_CONFIG_ERROR_MAX_PATH_DEPTH);
+  return truncatedPath.map((segment) => {
+    if (typeof segment === "string" && segment.length > HEARTBEAT_CONFIG_ERROR_MAX_PATH_SEGMENT_LENGTH) {
+      return segment.substring(
+        0,
+        HEARTBEAT_CONFIG_ERROR_MAX_PATH_SEGMENT_LENGTH - 3
+      ) + "...";
+    }
+    return segment;
+  });
+}
+function truncateMessage(message) {
+  if (message.length <= HEARTBEAT_CONFIG_ERROR_MAX_MESSAGE_LENGTH) {
+    return message;
+  }
+  return message.substring(0, HEARTBEAT_CONFIG_ERROR_MAX_MESSAGE_LENGTH - 3) + "...";
+}
+function createHeartbeatConfigError(path, code, message) {
+  return {
+    path: sanitizePath(path),
+    code: code.substring(0, HEARTBEAT_CONFIG_ERROR_MAX_CODE_LENGTH),
+    message: truncateMessage(message)
+  };
+}
+function normalizeHeartbeatConfigErrors(configErrors) {
+  return configErrors.slice(0, HEARTBEAT_CONFIG_ERROR_MAX_COUNT).map(
+    (configError) => createHeartbeatConfigError(
+      configError.path,
+      configError.code,
+      configError.message
+    )
+  );
+}
+function sanitizeConfigErrors(error) {
+  if (!error) {
+    return [];
+  }
+  const errors = [];
+  const issues = error.issues.slice(0, HEARTBEAT_CONFIG_ERROR_MAX_COUNT);
+  for (const issue of issues) {
+    const sanitizedPath = sanitizePath(issue.path);
+    const message = truncateMessage(
+      createSanitizedMessage(issue.code, sanitizedPath)
+    );
+    errors.push({
+      path: sanitizedPath,
+      code: issue.code,
+      message
+    });
+  }
+  return errors;
+}
+function createHeartbeatResponseBody(service, configErrors = []) {
+  return {
+    app: "appwarden",
+    kind: "heartbeat",
+    status: "ok",
+    contractVersion: HEARTBEAT_CONTRACT_VERSION,
+    service,
+    version: MIDDLEWARE_VERSION,
+    configErrors: normalizeHeartbeatConfigErrors(configErrors)
+  };
+}
+function createHeartbeatResponse(service, configErrors = []) {
+  const body = createHeartbeatResponseBody(service, configErrors);
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "x-appwarden-heartbeat": "1",
+      "x-appwarden-contract-version": String(HEARTBEAT_CONTRACT_VERSION),
+      "x-appwarden-service": service,
+      "x-appwarden-version": MIDDLEWARE_VERSION
+    }
+  });
+}
+function isHeartbeatRoute(url) {
+  return url.pathname === APPWARDEN_HEARTBEAT_ROUTE;
+}
+function isHeartbeatRequest(request, url) {
+  return request.method === "GET" && isHeartbeatRoute(url);
+}
+function handleHeartbeatRequest(request, service, configErrors = []) {
+  return createHeartbeatResponse(service, configErrors);
+}
+
+// src/utils/request-checks.ts
+function isHTMLResponse(response) {
+  return response.headers.get("Content-Type")?.includes("text/html") ?? false;
+}
+function isHTMLRequest(request) {
+  const accept = request.headers.get("accept");
+  if (!accept) {
+    return false;
+  }
+  const normalizedAccept = accept.toLowerCase();
+  const isWildcardOnlyAccept = (value) => {
+    const mediaRanges2 = value.split(",");
+    let hasNonEmptyRange = false;
+    for (const range of mediaRanges2) {
+      const [typeSubtype] = range.split(";");
+      const trimmed = typeSubtype.trim();
+      if (!trimmed) {
+        continue;
+      }
+      hasNonEmptyRange = true;
+      if (trimmed !== "*/*" && trimmed !== "*") {
+        return false;
+      }
+    }
+    return hasNonEmptyRange;
+  };
+  if (isWildcardOnlyAccept(normalizedAccept)) {
+    return false;
+  }
+  const mediaRanges = normalizedAccept.split(",");
+  for (const range of mediaRanges) {
+    const [typeSubtype] = range.split(";");
+    const token = typeSubtype.trim();
+    if (token === "text/html") {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/utils/cloudflare/csp-keywords.ts
+var CSP_KEYWORDS = [
+  "self",
+  "none",
+  "unsafe-inline",
+  "unsafe-eval",
+  "unsafe-hashes",
+  "strict-dynamic",
+  "report-sample",
+  "unsafe-allow-redirects",
+  "wasm-unsafe-eval",
+  "trusted-types-eval",
+  "report-sha256",
+  "report-sha384",
+  "report-sha512",
+  "unsafe-webtransport-hashes"
+];
+var CSP_KEYWORDS_SET = new Set(CSP_KEYWORDS);
+var isCSPKeyword = (value) => {
+  return CSP_KEYWORDS_SET.has(value.toLowerCase());
+};
+var isQuoted = (value) => {
+  return value.startsWith("'") && value.endsWith("'");
+};
+var autoQuoteCSPKeyword = (value) => {
+  const trimmed = value.trim();
+  if (isQuoted(trimmed)) {
+    return trimmed;
+  }
+  if (isCSPKeyword(trimmed)) {
+    return `'${trimmed}'`;
+  }
+  return trimmed;
+};
+var autoQuoteCSPDirectiveValue = (value) => {
+  return value.trim().split(/\s+/).filter(Boolean).map(autoQuoteCSPKeyword).join(" ");
+};
+var autoQuoteCSPDirectiveArray = (values) => {
+  return values.map(autoQuoteCSPKeyword);
+};
+
+// src/utils/cloudflare/make-csp-header.ts
+var addNonce = (value, cspNonce) => value.replace("{{nonce}}", `'nonce-${cspNonce}'`);
+var makeCSPHeader = (cspNonce, directives, mode) => {
+  const namesSeen = /* @__PURE__ */ new Set(), result = [];
+  Object.entries(directives ?? {}).forEach(([originalName, value]) => {
+    const name = originalName.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+    if (namesSeen.has(name)) {
+      throw new Error(`${originalName} is specified more than once`);
+    }
+    namesSeen.add(name);
+    let directiveValue;
+    if (Array.isArray(value)) {
+      directiveValue = autoQuoteCSPDirectiveArray(value).join(" ");
+    } else if (value === true) {
+      directiveValue = "";
+    } else if (typeof value === "string") {
+      directiveValue = autoQuoteCSPDirectiveValue(value);
+    } else {
+      return;
+    }
+    if (directiveValue) {
+      result.push(`${name} ${addNonce(directiveValue, cspNonce)}`);
+    } else {
+      result.push(name);
+    }
+  });
+  return [
+    mode === "enforced" ? "Content-Security-Policy" : "Content-Security-Policy-Report-Only",
+    result.join("; ")
+  ];
+};
+
+export {
+  buildLockPageUrl,
+  isOnLockPage,
+  TEMPORARY_REDIRECT_STATUS,
+  createRedirect,
+  printMessage,
+  debug,
+  MemoryCache,
+  createHeartbeatConfigError,
+  sanitizeConfigErrors,
+  isHeartbeatRequest,
+  handleHeartbeatRequest,
+  isHTMLResponse,
+  isHTMLRequest,
+  makeCSPHeader
+};

package/chunk-HUWGPM4M.js

@@ -0,0 +1,9 @@
+// src/utils/to-next-response.ts
+import { NextResponse } from "next/server";
+var toNextResponse = (response) => {
+  return new NextResponse(response.body, response);
+};
+
+export {
+  toNextResponse
+};

package/{chunk-WBWF3PPX.js → chunk-ILIYP3TG.js}

@@ -1,12 +1,10 @@
 import {
-  isHTMLResponse
-} from "./chunk-AY4ZKZTF.js";
+  isHTMLResponse,
+  makeCSPHeader
+} from "./chunk-HTSD4WPC.js";
 import {
   UseCSPInputSchema
-} from "./chunk-ZTVJBORU.js";
-import {
-  makeCSPHeader
-} from "./chunk-R7TXTHSG.js";
+} from "./chunk-Z7P4QVEY.js";
 
 // src/middlewares/use-content-security-policy.ts
 var AppendAttribute = (attribute, nonce) => ({