@opennextjs/aws 3.1.4

package/dist/core/requestHandler.js

@@ -0,0 +1,162 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { IncomingMessage, } from "../http/index.js";
+import { DetachedPromiseRunner } from "../utils/promise";
+import { debug, error, warn } from "../adapters/logger";
+import { patchAsyncStorage } from "./patchAsyncStorage";
+import { convertRes, createServerResponse, proxyRequest } from "./routing/util";
+import routingHandler from "./routingHandler";
+import { requestHandler, setNextjsPrebundledReact } from "./util";
+// This is used to identify requests in the cache
+globalThis.__als = new AsyncLocalStorage();
+patchAsyncStorage();
+export async function openNextHandler(internalEvent, responseStreaming) {
+    if (internalEvent.headers["x-forwarded-host"]) {
+        internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
+    }
+    debug("internalEvent", internalEvent);
+    //#override withRouting
+    let preprocessResult = {
+        internalEvent: internalEvent,
+        isExternalRewrite: false,
+        origin: false,
+        isISR: false,
+    };
+    try {
+        preprocessResult = await routingHandler(internalEvent);
+    }
+    catch (e) {
+        warn("Routing failed.", e);
+    }
+    //#endOverride
+    const headers = "type" in preprocessResult
+        ? preprocessResult.headers
+        : preprocessResult.internalEvent.headers;
+    const overwrittenResponseHeaders = Object.entries("type" in preprocessResult
+        ? preprocessResult.headers
+        : preprocessResult.internalEvent.headers).reduce((acc, [key, value]) => {
+        if (!key.startsWith("x-middleware-response-")) {
+            return acc;
+        }
+        else {
+            const newKey = key.replace("x-middleware-response-", "");
+            delete headers[key];
+            headers[newKey] = value;
+            return { ...acc, [newKey]: value };
+        }
+    }, {});
+    if ("type" in preprocessResult) {
+        // // res is used only in the streaming case
+        if (responseStreaming) {
+            const res = createServerResponse(internalEvent, headers, responseStreaming);
+            res.statusCode = preprocessResult.statusCode;
+            res.flushHeaders();
+            const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
+            for await (const chunk of bodyToConsume) {
+                res.write(chunk);
+            }
+            res.end();
+            preprocessResult.body = bodyToReturn;
+        }
+        return preprocessResult;
+    }
+    else {
+        const preprocessedEvent = preprocessResult.internalEvent;
+        debug("preprocessedEvent", preprocessedEvent);
+        const reqProps = {
+            method: preprocessedEvent.method,
+            url: preprocessedEvent.url,
+            //WORKAROUND: We pass this header to the serverless function to mimic a prefetch request which will not trigger revalidation since we handle revalidation differently
+            // There is 3 way we can handle revalidation:
+            // 1. We could just let the revalidation go as normal, but due to race condtions the revalidation will be unreliable
+            // 2. We could alter the lastModified time of our cache to make next believe that the cache is fresh, but this could cause issues with stale data since the cdn will cache the stale data as if it was fresh
+            // 3. OUR CHOICE: We could pass a purpose prefetch header to the serverless function to make next believe that the request is a prefetch request and not trigger revalidation (This could potentially break in the future if next changes the behavior of prefetch requests)
+            headers: { ...headers, purpose: "prefetch" },
+            body: preprocessedEvent.body,
+            remoteAddress: preprocessedEvent.remoteAddress,
+        };
+        const requestId = Math.random().toString(36);
+        const pendingPromiseRunner = new DetachedPromiseRunner();
+        const isISRRevalidation = headers["x-isr"] === "1";
+        const mergeHeadersPriority = globalThis.openNextConfig.dangerous
+            ?.headersAndCookiesPriority
+            ? globalThis.openNextConfig.dangerous.headersAndCookiesPriority(preprocessedEvent)
+            : "middleware";
+        const internalResult = await globalThis.__als.run({
+            requestId,
+            pendingPromiseRunner,
+            isISRRevalidation,
+            mergeHeadersPriority,
+        }, async () => {
+            const preprocessedResult = preprocessResult;
+            const req = new IncomingMessage(reqProps);
+            const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
+            await processRequest(req, res, preprocessedEvent, preprocessedResult.isExternalRewrite);
+            const { statusCode, headers, isBase64Encoded, body } = convertRes(res);
+            const internalResult = {
+                type: internalEvent.type,
+                statusCode,
+                headers,
+                body,
+                isBase64Encoded,
+            };
+            // reset lastModified. We need to do this to avoid memory leaks
+            delete globalThis.lastModified[requestId];
+            await pendingPromiseRunner.await();
+            return internalResult;
+        });
+        return internalResult;
+    }
+}
+async function processRequest(req, res, internalEvent, isExternalRewrite) {
+    // @ts-ignore
+    // Next.js doesn't parse body if the property exists
+    // https://github.com/dougmoscrop/serverless-http/issues/227
+    delete req.body;
+    try {
+        // `serverHandler` is replaced at build time depending on user's
+        // nextjs version to patch Nextjs 13.4.x and future breaking changes.
+        const { rawPath } = internalEvent;
+        if (isExternalRewrite) {
+            return proxyRequest(internalEvent, res);
+        }
+        else {
+            //#override applyNextjsPrebundledReact
+            setNextjsPrebundledReact(rawPath);
+            //#endOverride
+            // Next Server
+            await requestHandler(req, res);
+        }
+    }
+    catch (e) {
+        // This might fail when using bundled next, importing won't do the trick either
+        if (e.constructor.name === "NoFallbackError") {
+            // Do we need to handle _not-found
+            // Ideally this should never get triggered and be intercepted by the routing handler
+            await tryRenderError("404", res, internalEvent);
+        }
+        else {
+            error("NextJS request failed.", e);
+            await tryRenderError("500", res, internalEvent);
+        }
+    }
+}
+async function tryRenderError(type, res, internalEvent) {
+    try {
+        const _req = new IncomingMessage({
+            method: "GET",
+            url: `/${type}`,
+            headers: internalEvent.headers,
+            body: internalEvent.body,
+            remoteAddress: internalEvent.remoteAddress,
+        });
+        await requestHandler(_req, res);
+    }
+    catch (e) {
+        error("NextJS request failed.", e);
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+            message: "Server failed to respond.",
+            details: e,
+        }, null, 2));
+    }
+}

package/dist/core/require-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from "../types/next-types.js";
+export declare function overrideHooks(config: NextConfig): void;
+export declare function applyOverride(): void;

package/dist/core/require-hooks.js

@@ -0,0 +1,102 @@
+// Synchronously inject a require hook for webpack and webpack/. It's required to use the internal ncc webpack version.
+// This is needed for userland plugins to attach to the same webpack instance as Next.js'.
+// 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 resolveFilename = mod._resolveFilename;
+const hookPropertyMapApp = new Map();
+const hookPropertyMapPage = new Map();
+export function overrideHooks(config) {
+    try {
+        overrideDefault();
+        overrideReact(config);
+    }
+    catch (e) {
+        error("Failed to override Next.js require hooks.", e);
+        throw e;
+    }
+}
+function addHookAliases(aliases = [], type) {
+    for (const [key, value] of aliases) {
+        type === "app"
+            ? hookPropertyMapApp.set(key, value)
+            : hookPropertyMapPage.set(key, value);
+    }
+}
+const baseOverrides = {
+    react: "next/dist/compiled/react",
+    "react/package.json": "next/dist/compiled/react/package.json",
+    "react/jsx-runtime": "next/dist/compiled/react/jsx-runtime",
+    "react/jsx-dev-runtime": "next/dist/compiled/react/jsx-dev-runtime",
+    "react-dom": "next/dist/compiled/react-dom/server-rendering-stub",
+    "react-dom/package.json": "next/dist/compiled/react-dom/package.json",
+    "react-dom/client": "next/dist/compiled/react-dom/client",
+    "react-dom/server": "next/dist/compiled/react-dom/server",
+    "react-dom/server.browser": "next/dist/compiled/react-dom/server.browser",
+    "react-dom/server.edge": "next/dist/compiled/react-dom/server.edge",
+    "react-server-dom-webpack/client": "next/dist/compiled/react-server-dom-webpack/client",
+    "react-server-dom-webpack/client.edge": "next/dist/compiled/react-server-dom-webpack/client.edge",
+    "react-server-dom-webpack/server.edge": "next/dist/compiled/react-server-dom-webpack/server.edge",
+    "react-server-dom-webpack/server.node": "next/dist/compiled/react-server-dom-webpack/server.node",
+};
+const experimentalOverrides = {
+    react: "next/dist/compiled/react-experimental",
+    "react/jsx-runtime": "next/dist/compiled/react-experimental/jsx-runtime",
+    "react/jsx-dev-runtime": "next/dist/compiled/react-experimental/jsx-dev-runtime",
+    "react-dom": "next/dist/compiled/react-dom-experimental/server-rendering-stub",
+    "react/package.json": "next/dist/compiled/react-experimental/package.json",
+    "react-dom/package.json": "next/dist/compiled/react-dom-experimental/package.json",
+    "react-dom/client": "next/dist/compiled/react-dom-experimental/client",
+    "react-dom/server": "next/dist/compiled/react-dom-experimental/server",
+    "react-dom/server.browser": "next/dist/compiled/react-dom-experimental/server.browser",
+    "react-dom/server.edge": "next/dist/compiled/react-dom-experimental/server.edge",
+    "react-server-dom-webpack/client": "next/dist/compiled/react-server-dom-webpack-experimental/client",
+    "react-server-dom-webpack/client.edge": "next/dist/compiled/react-server-dom-webpack-experimental/client.edge",
+    "react-server-dom-webpack/server.edge": "next/dist/compiled/react-server-dom-webpack-experimental/server.edge",
+    "react-server-dom-webpack/server.node": "next/dist/compiled/react-server-dom-webpack-experimental/server.node",
+};
+// Add default aliases
+function overrideDefault() {
+    addHookAliases([
+        // Use `require.resolve` explicitly to make them statically analyzable
+        // styled-jsx needs to be resolved as the external dependency.
+        ["styled-jsx", require.resolve("styled-jsx")],
+        ["styled-jsx/style", require.resolve("styled-jsx/style")],
+    ], "app");
+}
+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");
+    // 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");
+    }
+    catch (e) { }
+    if (config.experimental.appDir) {
+        if (config.experimental.serverActions) {
+            addHookAliases(toResolveMap(experimentalOverrides), "app");
+        }
+        else {
+            addHookAliases(toResolveMap(baseOverrides), "app");
+        }
+    }
+}
+function isApp() {
+    return (process.env.__NEXT_PRIVATE_PREBUNDLED_REACT === "next" ||
+        process.env.__NEXT_PRIVATE_PREBUNDLED_REACT === "experimental");
+}
+export function applyOverride() {
+    mod._resolveFilename = function (originalResolveFilename, requestMapApp, requestMapPage, request, parent, isMain, options) {
+        const hookResolved = isApp()
+            ? requestMapApp.get(request)
+            : requestMapPage.get(request);
+        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);
+}

package/dist/core/resolve.d.ts

@@ -0,0 +1,31 @@
+import { BaseEventOrResult, Converter, DefaultOverrideOptions, ImageLoader, InternalEvent, InternalResult, LazyLoadedOverride, OverrideOptions, Wrapper } from "../types/open-next.js";
+import { TagCache } from "../cache/tag/types.js";
+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>>;
+/**
+ *
+ * @param tagCache
+ * @returns
+ * @__PURE__
+ */
+export declare function resolveTagCache(tagCache: OverrideOptions["tagCache"]): Promise<TagCache>;
+/**
+ *
+ * @param queue
+ * @returns
+ * @__PURE__
+ */
+export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../queue/types.js").Queue>;
+/**
+ *
+ * @param incrementalCache
+ * @returns
+ * @__PURE__
+ */
+export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../cache/incremental/types.js").IncrementalCache>;
+/**
+ * @param imageLoader
+ * @returns
+ * @__PURE__
+ */
+export declare function resolveImageLoader(imageLoader: LazyLoadedOverride<ImageLoader> | string): Promise<ImageLoader>;

package/dist/core/resolve.js

@@ -0,0 +1,81 @@
+export async function resolveConverter(converter) {
+    if (typeof converter === "function") {
+        return converter();
+    }
+    else {
+        const m_1 = await import(`../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("../wrappers/aws-lambda.js");
+        // @ts-expect-error
+        return m_1.default;
+    }
+}
+/**
+ *
+ * @param tagCache
+ * @returns
+ * @__PURE__
+ */
+export async function resolveTagCache(tagCache) {
+    if (typeof tagCache === "function") {
+        return tagCache();
+    }
+    else {
+        // This will be replaced by the bundler
+        const m_1 = await import("../cache/tag/dynamodb.js");
+        return m_1.default;
+    }
+}
+/**
+ *
+ * @param queue
+ * @returns
+ * @__PURE__
+ */
+export async function resolveQueue(queue) {
+    if (typeof queue === "function") {
+        return queue();
+    }
+    else {
+        const m_1 = await import("../queue/sqs.js");
+        return m_1.default;
+    }
+}
+/**
+ *
+ * @param incrementalCache
+ * @returns
+ * @__PURE__
+ */
+export async function resolveIncrementalCache(incrementalCache) {
+    if (typeof incrementalCache === "function") {
+        return incrementalCache();
+    }
+    else {
+        const m_1 = await import("../cache/incremental/s3.js");
+        return m_1.default;
+    }
+}
+/**
+ * @param imageLoader
+ * @returns
+ * @__PURE__
+ */
+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;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { InternalEvent, InternalResult } from "../../types/open-next";
+export declare function cacheInterceptor(event: InternalEvent): Promise<InternalEvent | InternalResult>;

package/dist/core/routing/cacheInterceptor.js

@@ -0,0 +1,162 @@
+import { createHash } from "node:crypto";
+import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
+import { emptyReadableStream, toReadableStream } from "../../utils/stream";
+import { debug } from "../../adapters/logger";
+import { localizePath } from "./i18n";
+import { generateMessageGroupId } from "./util";
+const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
+const CACHE_ONE_MONTH = 60 * 60 * 24 * 30;
+async function computeCacheControl(path, body, host, revalidate, lastModified) {
+    let finalRevalidate = CACHE_ONE_YEAR;
+    const existingRoute = Object.entries(PrerenderManifest.routes).find((p) => p[0] === path)?.[1];
+    if (revalidate === undefined && existingRoute) {
+        finalRevalidate =
+            existingRoute.initialRevalidateSeconds === false
+                ? CACHE_ONE_YEAR
+                : existingRoute.initialRevalidateSeconds;
+        // eslint-disable-next-line sonarjs/elseif-without-else
+    }
+    else if (revalidate !== undefined) {
+        finalRevalidate = revalidate === false ? CACHE_ONE_YEAR : revalidate;
+    }
+    // calculate age
+    const age = Math.round((Date.now() - (lastModified ?? 0)) / 1000);
+    const hash = (str) => createHash("md5").update(str).digest("hex");
+    const etag = hash(body);
+    if (revalidate === 0) {
+        // This one should never happen
+        return {
+            "cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+            "x-opennext-cache": "ERROR",
+            etag,
+        };
+    }
+    else if (finalRevalidate !== CACHE_ONE_YEAR) {
+        const sMaxAge = Math.max(finalRevalidate - age, 1);
+        debug("sMaxAge", {
+            finalRevalidate,
+            age,
+            lastModified,
+            revalidate,
+        });
+        const isStale = sMaxAge === 1;
+        if (isStale) {
+            let url = NextConfig.trailingSlash ? `${path}/` : path;
+            if (NextConfig.basePath) {
+                // We need to add the basePath to the url
+                url = `${NextConfig.basePath}${url}`;
+            }
+            await globalThis.queue.send({
+                MessageBody: { host, url },
+                MessageDeduplicationId: hash(`${path}-${lastModified}-${etag}`),
+                MessageGroupId: generateMessageGroupId(path),
+            });
+        }
+        return {
+            "cache-control": `s-maxage=${sMaxAge}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+            "x-opennext-cache": isStale ? "STALE" : "HIT",
+            etag,
+        };
+    }
+    else {
+        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");
+    let body = "";
+    let type = "application/octet-stream";
+    let isDataRequest = false;
+    switch (cachedValue.type) {
+        case "app":
+            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"]);
+            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);
+    return {
+        type: "core",
+        statusCode: 200,
+        body: toReadableStream(body, false),
+        isBase64Encoded: false,
+        headers: {
+            ...cacheControl,
+            "content-type": type,
+            ...cachedValue.meta?.headers,
+        },
+    };
+}
+export async function cacheInterceptor(event) {
+    if (Boolean(event.headers["next-action"]) ||
+        Boolean(event.headers["x-prerender-revalidate"]))
+        return event;
+    // We localize the path in case i18n is enabled
+    let localizedPath = localizePath(event);
+    // If using basePath we need to remove it from the path
+    if (NextConfig.basePath) {
+        localizedPath = localizedPath.replace(NextConfig.basePath, "");
+    }
+    // We also need to remove trailing slash
+    localizedPath = localizedPath.replace(/\/$/, "");
+    // If empty path, it means we want index
+    if (localizedPath === "") {
+        localizedPath = "index";
+    }
+    debug("Checking cache for", localizedPath, PrerenderManifest);
+    const isISR = Object.keys(PrerenderManifest.routes).includes(localizedPath) ||
+        Object.values(PrerenderManifest.dynamicRoutes).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
+    debug("isISR", isISR);
+    if (isISR) {
+        try {
+            const cachedData = await globalThis.incrementalCache.get(localizedPath);
+            debug("cached data in interceptor", cachedData);
+            if (cachedData.value?.type === "app") {
+                // We need to check the tag cache now
+                const _lastModified = await globalThis.tagCache.getLastModified(localizedPath, cachedData.lastModified);
+                if (_lastModified === -1) {
+                    // If some tags are stale we need to force revalidation
+                    return event;
+                }
+            }
+            const host = event.headers["host"];
+            switch (cachedData.value?.type) {
+                case "app":
+                case "page":
+                    return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified);
+                case "redirect":
+                    const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified);
+                    return {
+                        type: "core",
+                        statusCode: cachedData.value.meta?.status ?? 307,
+                        body: emptyReadableStream(),
+                        headers: {
+                            ...(cachedData.value.meta?.headers ??
+                                {}),
+                            ...cacheControl,
+                        },
+                        isBase64Encoded: false,
+                    };
+                default:
+                    return event;
+            }
+        }
+        catch (e) {
+            debug("Error while fetching cache", e);
+            // In case of error we fallback to the server
+            return event;
+        }
+    }
+    return event;
+}

package/dist/core/routing/i18n/accept-header.d.ts

@@ -0,0 +1 @@
+export declare function acceptLanguage(header?: string, preferences?: string[]): string | undefined;

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

@@ -0,0 +1,101 @@
+// Copied from Next.js source code
+// https://github.com/vercel/next.js/blob/canary/packages/next/src/server/accept-header.ts
+function parse(raw, preferences, options) {
+    const lowers = new Map();
+    const header = raw.replace(/[ \t]/g, "");
+    if (preferences) {
+        let pos = 0;
+        for (const preference of preferences) {
+            const lower = preference.toLowerCase();
+            lowers.set(lower, { orig: preference, pos: pos++ });
+            if (options.prefixMatch) {
+                const parts = lower.split("-");
+                while ((parts.pop(), parts.length > 0)) {
+                    const joined = parts.join("-");
+                    if (!lowers.has(joined)) {
+                        lowers.set(joined, { orig: preference, pos: pos++ });
+                    }
+                }
+            }
+        }
+    }
+    const parts = header.split(",");
+    const selections = [];
+    const map = new Set();
+    for (let i = 0; i < parts.length; ++i) {
+        const part = parts[i];
+        if (!part) {
+            continue;
+        }
+        const params = part.split(";");
+        if (params.length > 2) {
+            throw new Error(`Invalid ${options.type} header`);
+        }
+        let token = params[0].toLowerCase();
+        if (!token) {
+            throw new Error(`Invalid ${options.type} header`);
+        }
+        const selection = { token, pos: i, q: 1 };
+        if (preferences && lowers.has(token)) {
+            selection.pref = lowers.get(token).pos;
+        }
+        map.add(selection.token);
+        if (params.length === 2) {
+            const q = params[1];
+            const [key, value] = q.split("=");
+            if (!value || (key !== "q" && key !== "Q")) {
+                throw new Error(`Invalid ${options.type} header`);
+            }
+            const score = parseFloat(value);
+            if (score === 0) {
+                continue;
+            }
+            if (Number.isFinite(score) && score <= 1 && score >= 0.001) {
+                selection.q = score;
+            }
+        }
+        selections.push(selection);
+    }
+    selections.sort((a, b) => {
+        if (b.q !== a.q) {
+            return b.q - a.q;
+        }
+        if (b.pref !== a.pref) {
+            if (a.pref === undefined) {
+                return 1;
+            }
+            if (b.pref === undefined) {
+                return -1;
+            }
+            return a.pref - b.pref;
+        }
+        return a.pos - b.pos;
+    });
+    const values = selections.map((selection) => selection.token);
+    if (!preferences || !preferences.length) {
+        return values;
+    }
+    const preferred = [];
+    for (const selection of values) {
+        if (selection === "*") {
+            for (const [preference, value] of lowers) {
+                if (!map.has(preference)) {
+                    preferred.push(value.orig);
+                }
+            }
+        }
+        else {
+            const lower = selection.toLowerCase();
+            if (lowers.has(lower)) {
+                preferred.push(lowers.get(lower).orig);
+            }
+        }
+    }
+    return preferred;
+}
+export function acceptLanguage(header = "", preferences) {
+    return (parse(header, preferences, {
+        type: "accept-language",
+        prefixMatch: true,
+    })[0] || undefined);
+}

package/dist/core/routing/i18n/index.d.ts

@@ -0,0 +1,2 @@
+import { InternalEvent } from "../../../types/open-next";
+export declare function localizePath(internalEvent: InternalEvent): string;