@opennextjs/aws 3.2.0 → 3.2.2

package/dist/core/require-hooks.js

@@ -3,7 +3,7 @@
 // Individually compiled modules are as defined for the compilation in bundles/webpack/packages/*.
 import { error } from "../adapters/logger.js";
 // This module will only be loaded once per process.
-const mod = require("module");
+const mod = require("node:module");
 const resolveFilename = mod._resolveFilename;
 const hookPropertyMapApp = new Map();
 const hookPropertyMapPage = new Map();
@@ -17,7 +17,7 @@ export function overrideHooks(config) {
         throw e;
     }
 }
-function addHookAliases(aliases = [], type) {
+function addHookAliases(aliases, type) {
     for (const [key, value] of aliases) {
         type === "app"
             ? hookPropertyMapApp.set(key, value)
@@ -68,12 +68,12 @@ function overrideDefault() {
 const toResolveMap = (map) => Object.entries(map).map(([key, value]) => [key, require.resolve(value)]);
 // Override built-in React packages if necessary
 function overrideReact(config) {
-    addHookAliases([["react", require.resolve(`react`)]], "page");
+    addHookAliases([["react", require.resolve("react")]], "page");
     // ignore: react/jsx-dev-runtime is not available on older version of Next.js ie. v13.1.6
     // react/jsx-runtime is not available on newer version of Next.js ie. v13.4.10-canary.3
     try {
-        addHookAliases([["react/jsx-runtime", require.resolve(`react/jsx-runtime`)]], "page");
-        addHookAliases([["react/jsx-dev-runtime", require.resolve(`react/jsx-dev-runtime`)]], "page");
+        addHookAliases([["react/jsx-runtime", require.resolve("react/jsx-runtime")]], "page");
+        addHookAliases([["react/jsx-dev-runtime", require.resolve("react/jsx-dev-runtime")]], "page");
     }
     catch (e) { }
     if (config.experimental.appDir) {
@@ -90,13 +90,14 @@ function isApp() {
         process.env.__NEXT_PRIVATE_PREBUNDLED_REACT === "experimental");
 }
 export function applyOverride() {
-    mod._resolveFilename = function (originalResolveFilename, requestMapApp, requestMapPage, request, parent, isMain, options) {
+    mod._resolveFilename = ((originalResolveFilename, requestMapApp, requestMapPage, request, parent, isMain, options) => {
         const hookResolved = isApp()
             ? requestMapApp.get(request)
             : requestMapPage.get(request);
+        // biome-ignore lint/style/noParameterAssign:
         if (hookResolved)
             request = hookResolved;
         return originalResolveFilename.call(mod, request, parent, isMain, options);
         // We use `bind` here to avoid referencing outside variables to create potential memory leaks.
-    }.bind(null, resolveFilename, hookPropertyMapApp, hookPropertyMapPage);
+    }).bind(null, resolveFilename, hookPropertyMapApp, hookPropertyMapPage);
 }

package/dist/core/resolve.d.ts

@@ -1,5 +1,6 @@
-import type { BaseEventOrResult, Converter, DefaultOverrideOptions, ImageLoader, InternalEvent, InternalResult, LazyLoadedOverride, OriginResolver, OverrideOptions, Warmer, Wrapper } from "../types/open-next.js";
-import type { TagCache } from "../overrides/tagCache/types.js";
+import type { BaseEventOrResult, DefaultOverrideOptions, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
+import type { Converter, TagCache, Wrapper } from "../types/overrides";
+type RemoveUndefined<T> = T extends undefined ? never : T;
 export declare function resolveConverter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(converter: DefaultOverrideOptions<E, R>["converter"]): Promise<Converter<E, R>>;
 export declare function resolveWrapper<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(wrapper: DefaultOverrideOptions<E, R>["wrapper"]): Promise<Wrapper<E, R>>;
 /**
@@ -15,26 +16,31 @@ export declare function resolveTagCache(tagCache: OverrideOptions["tagCache"]):
  * @returns
  * @__PURE__
  */
-export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../overrides/queue/types.js").Queue>;
+export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../types/overrides").Queue>;
 /**
  *
  * @param incrementalCache
  * @returns
  * @__PURE__
  */
-export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../overrides/incrementalCache/types.js").IncrementalCache>;
+export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../types/overrides").IncrementalCache>;
 /**
  * @param imageLoader
  * @returns
  * @__PURE__
  */
-export declare function resolveImageLoader(imageLoader: LazyLoadedOverride<ImageLoader> | string): Promise<ImageLoader>;
+export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"]): Promise<import("../types/overrides").ImageLoader>;
 /**
  * @returns
  * @__PURE__
  */
-export declare function resolveOriginResolver(originResolver?: LazyLoadedOverride<OriginResolver> | string): Promise<OriginResolver>;
+export declare function resolveOriginResolver(originResolver: RemoveUndefined<OpenNextConfig["middleware"]>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
 /**
  * @__PURE__
  */
-export declare function resolveWarmerInvoke(warmer?: LazyLoadedOverride<Warmer> | "aws-lambda"): Promise<Warmer>;
+export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"]): Promise<import("../types/overrides").Warmer>;
+/**
+ * @__PURE__
+ */
+export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+export {};

package/dist/core/resolve.js

@@ -2,22 +2,18 @@ export async function resolveConverter(converter) {
     if (typeof converter === "function") {
         return converter();
     }
-    else {
-        const m_1 = await import(`../overrides/converters/aws-apigw-v2.js`);
-        // @ts-expect-error
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/converters/aws-apigw-v2.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 export async function resolveWrapper(wrapper) {
     if (typeof wrapper === "function") {
         return wrapper();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/wrappers/aws-lambda.js");
-        // @ts-expect-error
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/wrappers/aws-lambda.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 /**
  *
@@ -29,11 +25,9 @@ export async function resolveTagCache(tagCache) {
     if (typeof tagCache === "function") {
         return tagCache();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/tagCache/dynamodb.js");
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/tagCache/dynamodb.js");
+    return m_1.default;
 }
 /**
  *
@@ -45,10 +39,8 @@ export async function resolveQueue(queue) {
     if (typeof queue === "function") {
         return queue();
     }
-    else {
-        const m_1 = await import("../overrides/queue/sqs.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/queue/sqs.js");
+    return m_1.default;
 }
 /**
  *
@@ -60,10 +52,8 @@ export async function resolveIncrementalCache(incrementalCache) {
     if (typeof incrementalCache === "function") {
         return incrementalCache();
     }
-    else {
-        const m_1 = await import("../overrides/incrementalCache/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/incrementalCache/s3.js");
+    return m_1.default;
 }
 /**
  * @param imageLoader
@@ -74,10 +64,8 @@ export async function resolveImageLoader(imageLoader) {
     if (typeof imageLoader === "function") {
         return imageLoader();
     }
-    else {
-        const m_1 = await import("../overrides/imageLoader/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/imageLoader/s3.js");
+    return m_1.default;
 }
 /**
  * @returns
@@ -87,10 +75,8 @@ export async function resolveOriginResolver(originResolver) {
     if (typeof originResolver === "function") {
         return originResolver();
     }
-    else {
-        const m_1 = await import("../overrides/originResolver/pattern-env.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/originResolver/pattern-env.js");
+    return m_1.default;
 }
 /**
  * @__PURE__
@@ -99,8 +85,16 @@ export async function resolveWarmerInvoke(warmer) {
     if (typeof warmer === "function") {
         return warmer();
     }
-    else {
-        const m_1 = await import("../overrides/warmer/aws-lambda.js");
-        return m_1.default;
+    const m_1 = await import("../overrides/warmer/aws-lambda.js");
+    return m_1.default;
+}
+/**
+ * @__PURE__
+ */
+export async function resolveProxyRequest(proxyRequest) {
+    if (typeof proxyRequest === "function") {
+        return proxyRequest();
     }
+    const m_1 = await import("../overrides/proxyExternalRequest/node.js");
+    return m_1.default;
 }

package/dist/core/routing/cacheInterceptor.js

@@ -31,7 +31,7 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else if (finalRevalidate !== CACHE_ONE_YEAR) {
+    if (finalRevalidate !== CACHE_ONE_YEAR) {
         const sMaxAge = Math.max(finalRevalidate - age, 1);
         debug("sMaxAge", {
             finalRevalidate,
@@ -58,13 +58,11 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else {
-        return {
-            "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-            "x-opennext-cache": "HIT",
-            etag,
-        };
-    }
+    return {
+        "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+        "x-opennext-cache": "HIT",
+        etag,
+    };
 }
 async function generateResult(event, localizedPath, cachedValue, lastModified) {
     debug("Returning result from experimental cache");
@@ -73,19 +71,19 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     let isDataRequest = false;
     switch (cachedValue.type) {
         case "app":
-            isDataRequest = Boolean(event.headers["rsc"]);
+            isDataRequest = Boolean(event.headers.rsc);
             body = isDataRequest ? cachedValue.rsc : cachedValue.html;
             type = isDataRequest ? "text/x-component" : "text/html; charset=utf-8";
             break;
         case "page":
-            isDataRequest = Boolean(event.query["__nextDataReq"]);
+            isDataRequest = Boolean(event.query.__nextDataReq);
             body = isDataRequest
                 ? JSON.stringify(cachedValue.json)
                 : cachedValue.html;
             type = isDataRequest ? "application/json" : "text/html; charset=utf-8";
             break;
     }
-    const cacheControl = await computeCacheControl(localizedPath, body, event.headers["host"], cachedValue.revalidate, lastModified);
+    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
         statusCode: 200,
@@ -130,12 +128,12 @@ export async function cacheInterceptor(event) {
                     return event;
                 }
             }
-            const host = event.headers["host"];
+            const host = event.headers.host;
             switch (cachedData.value?.type) {
                 case "app":
                 case "page":
                     return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified);
-                case "redirect":
+                case "redirect": {
                     const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified);
                     return {
                         type: "core",
@@ -148,6 +146,7 @@ export async function cacheInterceptor(event) {
                         },
                         isBase64Encoded: false,
                     };
+                }
                 default:
                     return event;
             }

package/dist/core/routing/i18n/accept-header.js

@@ -11,6 +11,7 @@ function parse(raw, preferences, options) {
             lowers.set(lower, { orig: preference, pos: pos++ });
             if (options.prefixMatch) {
                 const parts = lower.split("-");
+                // biome-ignore lint/style/noCommaOperator:
                 while ((parts.pop(), parts.length > 0)) {
                     const joined = parts.join("-");
                     if (!lowers.has(joined)) {
@@ -32,7 +33,7 @@ function parse(raw, preferences, options) {
         if (params.length > 2) {
             throw new Error(`Invalid ${options.type} header`);
         }
-        let token = params[0].toLowerCase();
+        const token = params[0].toLowerCase();
         if (!token) {
             throw new Error(`Invalid ${options.type} header`);
         }
@@ -47,7 +48,7 @@ function parse(raw, preferences, options) {
             if (!value || (key !== "q" && key !== "Q")) {
                 throw new Error(`Invalid ${options.type} header`);
             }
-            const score = parseFloat(value);
+            const score = Number.parseFloat(value);
             if (score === 0) {
                 continue;
             }

package/dist/core/routing/matcher.d.ts

@@ -1,14 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
 import type { InternalEvent, InternalResult } from "../../types/open-next";
-export declare function addNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
+export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
         rawPath: string;
         url: string;
         method: string;
-        body?: Buffer | undefined;
+        body?: Buffer;
         headers: Record<string, string>;
         query: Record<string, string | string[]>;
         cookies: Record<string, string>;

package/dist/core/routing/matcher.js

@@ -59,30 +59,22 @@ const computeParamHas = (headers, cookies, query) => (has) => {
     }
 };
 function convertMatch(match, toDestination, destination) {
-    if (match) {
-        const { params } = match;
-        const isUsingParams = Object.keys(params).length > 0;
-        if (isUsingParams) {
-            return toDestination(params);
-        }
-        else {
-            return destination;
-        }
-    }
-    else {
+    if (!match) {
         return destination;
     }
+    const { params } = match;
+    const isUsingParams = Object.keys(params).length > 0;
+    return isUsingParams ? toDestination(params) : destination;
 }
-export function addNextConfigHeaders(event, configHeaders) {
-    const addedHeaders = {};
-    if (!configHeaders)
-        return addedHeaders;
-    const { rawPath, headers, query, cookies } = event;
-    const matcher = routeHasMatcher(headers, cookies, query);
+export function getNextConfigHeaders(event, configHeaders) {
+    if (!configHeaders) {
+        return {};
+    }
+    const matcher = routeHasMatcher(event.headers, event.cookies, event.query);
     const requestHeaders = {};
     const localizedRawPath = localizePath(event);
     for (const { headers, has, missing, regex, source, locale, } of configHeaders) {
-        const path = locale === false ? rawPath : localizedRawPath;
+        const path = locale === false ? event.rawPath : localizedRawPath;
         if (new RegExp(regex).test(path) &&
             checkHas(matcher, has) &&
             checkHas(matcher, missing, true)) {
@@ -95,7 +87,7 @@ export function addNextConfigHeaders(event, configHeaders) {
                     requestHeaders[key] = value;
                 }
                 catch {
-                    debug("Error matching header ", h.key, " with value ", h.value);
+                    debug(`Error matching header ${h.key} with value ${h.value}`);
                     requestHeaders[h.key] = h.value;
                 }
             });
@@ -122,24 +114,30 @@ export function handleRewrites(event, rewrites) {
         const { pathname, protocol, hostname, queryString } = getUrlParts(rewrite.destination, isExternalRewrite);
         // We need to use a localized path if the rewrite is not locale specific
         const pathToUse = rewrite.locale === false ? rawPath : localizedRawPath;
+        // We need to encode the "+" character with its UTF-8 equivalent "%20" to avoid 2 issues:
+        // 1. The compile function from path-to-regexp will throw an error if it finds a "+" character.
+        // https://github.com/pillarjs/path-to-regexp?tab=readme-ov-file#unexpected--or-
+        // 2. The convertToQueryString function will replace the "+" character with %2B instead of %20.
+        // %2B does not get interpreted as a space in the URL thus breaking the query string.
+        const encodePlusQueryString = queryString.replaceAll("+", "%20");
         debug("urlParts", { pathname, protocol, hostname, queryString });
         const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
         const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
-        const toDestinationQuery = compile(escapeRegex(queryString ?? "") ?? "");
-        let params = {
+        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
+        const params = {
             // params for the source
             ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
             // params for the missing
             ...rewrite.missing?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
-        let rewrittenQuery = queryString;
+        let rewrittenQuery = encodePlusQueryString;
         let rewrittenHost = hostname;
         let rewrittenPath = pathname;
         if (isUsingParams) {
@@ -149,7 +147,7 @@ export function handleRewrites(event, rewrites) {
         }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
-            : `/${rewrittenPath}`;
+            : `${rewrittenPath}`;
         // Should we merge the query params or use only the ones from the rewrite?
         finalQuery = {
             ...query,
@@ -194,7 +192,7 @@ function handleTrailingSlashRedirect(event) {
         };
         // eslint-disable-next-line sonarjs/elseif-without-else
     }
-    else if (!NextConfig.trailingSlash &&
+    if (!NextConfig.trailingSlash &&
         event.rawPath.endsWith("/") &&
         event.rawPath !== "/") {
         const headersLocation = event.url.split("?");
@@ -208,8 +206,7 @@ function handleTrailingSlashRedirect(event) {
             isBase64Encoded: false,
         };
     }
-    else
-        return false;
+    return false;
 }
 export function handleRedirects(event, redirects) {
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
@@ -244,8 +241,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        let newPath = rawPath.replace(dataPattern, "").replace(/\.json$/, "");
-        newPath = newPath === "/index" ? "/" : newPath;
+        const newPath = rawPath
+            .slice(dataPattern.length, -".json".length)
+            .replace(/^\/index$/, "/");
         query.__nextDataReq = "1";
         return {
             ...internalEvent,
@@ -266,7 +264,7 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
         return routeRegexExp.test(rawPath);
     });
     const locales = NextConfig.i18n?.locales;
-    const routesAlreadyHaveLocale = (locales !== undefined && locales.includes(rawPath.split("/")[1])) ||
+    const routesAlreadyHaveLocale = locales?.includes(rawPath.split("/")[1]) ||
         // If we don't use locales, we don't need to add the default locale
         locales === undefined;
     const localizedPath = routesAlreadyHaveLocale

package/dist/core/routing/middleware.js

@@ -21,32 +21,36 @@ function defaultMiddlewareLoader() {
 // @returns undefined | res.end()
 //    if res.end() is return, the parent needs to return and not process next server
 export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
-    const { query } = internalEvent;
-    const normalizedPath = localizePath(internalEvent);
+    const headers = internalEvent.headers;
+    // We bypass the middleware if the request is internal
+    if (headers["x-isr"])
+        return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
+    const normalizedPath = localizePath(internalEvent);
     const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
     if (!hasMatch)
         return internalEvent;
-    // We bypass the middleware if the request is internal
-    if (internalEvent.headers["x-isr"])
-        return internalEvent;
-    const host = internalEvent.headers.host
-        ? `https://${internalEvent.headers.host}`
+    // Retrieve the protocol:
+    // - In lambda, the url only contains the rawPath and the query - default to https
+    // - In cloudflare, the protocol is usually http in dev and https in production
+    const protocol = internalEvent.url.startsWith("http://") ? "http:" : "https:";
+    const host = headers.host
+        ? `${protocol}//${headers.host}`
         : "http://localhost:3000";
     const initialUrl = new URL(normalizedPath, host);
-    initialUrl.search = convertToQueryString(query);
+    initialUrl.search = convertToQueryString(internalEvent.query);
     const url = initialUrl.toString();
-    // console.log("url", url, normalizedPath);
     const middleware = await middlewareLoader();
     const result = await middleware.default({
+        // `geo` is pre Next 15.
         geo: {
-            city: internalEvent.headers["x-open-next-city"],
-            country: internalEvent.headers["x-open-next-country"],
-            region: internalEvent.headers["x-open-next-region"],
-            latitude: internalEvent.headers["x-open-next-latitude"],
-            longitude: internalEvent.headers["x-open-next-longitude"],
+            city: headers["x-open-next-city"],
+            country: headers["x-open-next-country"],
+            region: headers["x-open-next-region"],
+            latitude: headers["x-open-next-latitude"],
+            longitude: headers["x-open-next-longitude"],
         },
-        headers: internalEvent.headers,
+        headers,
         method: internalEvent.method || "GET",
         nextConfig: {
             basePath: NextConfig.basePath,
@@ -96,7 +100,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         resHeaders.location =
             responseHeaders
                 .get("location")
-                ?.replace("http://localhost:3000", `https://${internalEvent.headers.host}`) ?? resHeaders.location;
+                ?.replace("http://localhost:3000", `${protocol}//${internalEvent.headers.host}`) ?? resHeaders.location;
         // res.setHeader("Location", location);
         return {
             body: emptyReadableStream(),
@@ -124,9 +128,9 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
             const rewriteUrlObject = new URL(rewriteUrl);
             newUrl = rewriteUrlObject.pathname;
             // Reset the query params if the middleware is a rewrite
-            if (middlewareQueryString["__nextDataReq"]) {
+            if (middlewareQueryString.__nextDataReq) {
                 middlewareQueryString = {
-                    __nextDataReq: middlewareQueryString["__nextDataReq"],
+                    __nextDataReq: middlewareQueryString.__nextDataReq,
                 };
             }
             else {

package/dist/core/routing/util.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage, StreamCreator } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
@@ -59,16 +56,6 @@ export declare function unescapeRegex(str: string): string;
  * @__PURE__
  */
 export declare function convertBodyToReadableStream(method: string, body?: string | Buffer): ReadableStream<any> | undefined;
-/**
- *
- * @__PURE__
- */
-export declare function proxyRequest(internalEvent: InternalEvent, res: OpenNextNodeResponse): Promise<void>;
-declare global {
-    var openNextDebug: boolean;
-    var openNextVersion: string;
-    var lastModified: Record<string, number>;
-}
 /**
  *
  * @__PURE__