@common.js/next-intl 4.13.1

package/dist/esm/development/extractor/utils.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    compareReferences: function() {
+        return compareReferences;
+    },
+    getDefaultProjectRoot: function() {
+        return getDefaultProjectRoot;
+    },
+    getSortedMessages: function() {
+        return getSortedMessages;
+    },
+    hasLocalesToExtract: function() {
+        return hasLocalesToExtract;
+    },
+    isForbiddenObjectKey: function() {
+        return isForbiddenObjectKey;
+    },
+    localeCompare: function() {
+        return localeCompare;
+    },
+    normalizePathToPosix: function() {
+        return normalizePathToPosix;
+    },
+    setNestedProperty: function() {
+        return setNestedProperty;
+    }
+});
+var _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+var _utilsJs = require("../plugin/utils.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function normalizePathToPosix(filePath) {
+    // `path.relative` uses OS-specific separators. For stable `.po` references we
+    // always use POSIX separators, regardless of the OS that ran extraction.
+    return _path.default.posix.normalize(filePath.split(_path.default.win32.sep).join(_path.default.posix.sep));
+}
+var FORBIDDEN_OBJECT_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+]);
+function isForbiddenObjectKey(key) {
+    return FORBIDDEN_OBJECT_KEYS.has(key);
+}
+function hasLocalesToExtract(config) {
+    var locales = config.extract.locales;
+    return locales === "infer" || locales.length > 0;
+}
+// Essentialls lodash/set, but we avoid this dependency
+function setNestedProperty(obj, keyPath, value) {
+    var keys = keyPath.split(".");
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            if (isForbiddenObjectKey(key)) {
+                throw new Error("Invalid message id segment: ".concat(key));
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var current = obj;
+    for(var i = 0; i < keys.length - 1; i++){
+        var key1 = keys[i];
+        if (!Object.prototype.hasOwnProperty.call(current, key1) || typeof current[key1] !== "object" || current[key1] === null) {
+            current[key1] = Object.create(null);
+        }
+        current = current[key1];
+    }
+    current[keys[keys.length - 1]] = value;
+}
+function getSortedMessages(messages) {
+    var warnedMissingReferenceIds = new Set();
+    return messages.toSorted(function(messageA, messageB) {
+        var refA = messageA.references[0];
+        var refB = messageB.references[0];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (refA == null) {
+            warnAboutMissingReference(messageA.id, warnedMissingReferenceIds);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (refB == null) {
+            warnAboutMissingReference(messageB.id, warnedMissingReferenceIds);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (refA == null || refB == null) {
+            return 0;
+        }
+        // Sort by path, then line. Same path+line: preserve original order
+        return compareReferences(refA, refB);
+    });
+}
+function warnAboutMissingReference(id, warnedMissingReferenceIds) {
+    if (warnedMissingReferenceIds.has(id)) return;
+    warnedMissingReferenceIds.add(id);
+    (0, _utilsJs.warn)("Missing file reference for extracted message: ".concat(id));
+}
+function localeCompare(a, b) {
+    return a.localeCompare(b, "en");
+}
+function compareReferences(refA, refB) {
+    var pathCompare = localeCompare(refA.path, refB.path);
+    if (pathCompare !== 0) return pathCompare;
+    var _line, _line1;
+    return ((_line = refA.line) !== null && _line !== void 0 ? _line : 0) - ((_line1 = refB.line) !== null && _line1 !== void 0 ? _line1 : 0);
+}
+function getDefaultProjectRoot() {
+    return process.cwd();
+}

package/dist/esm/development/extractor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    unstable_extractMessages: function() {
+        return _extractMessagesJs.default;
+    },
+    defineCodec: function() {
+        return _extractorCodecJs.defineCodec;
+    }
+});
+var _extractMessagesJs = /*#__PURE__*/ _interopRequireDefault(require("./extractor/extractMessages.js"));
+var _extractorCodecJs = require("./extractor/format/ExtractorCodec.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/esm/development/index.react-client.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useFormatter: function() {
+        return _indexJs.useFormatter;
+    },
+    useTranslations: function() {
+        return _indexJs.useTranslations;
+    },
+    NextIntlClientProvider: function() {
+        return _nextIntlClientProviderJs.default;
+    },
+    IntlProvider: function() {
+        return _react.IntlProvider;
+    },
+    useExtracted: function() {
+        return _react["_useExtracted"];
+    },
+    useLocale: function() {
+        return _react.useLocale;
+    },
+    useMessages: function() {
+        return _react.useMessages;
+    },
+    useNow: function() {
+        return _react.useNow;
+    },
+    useTimeZone: function() {
+        return _react.useTimeZone;
+    }
+});
+var _indexJs = require("./react-client/index.js");
+var _nextIntlClientProviderJs = /*#__PURE__*/ _interopRequireDefault(require("./shared/NextIntlClientProvider.js"));
+var _react = require("use-intl/react");
+_exportStar(require("use-intl/core"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/esm/development/index.react-server.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useLocale: function() {
+        return _useLocaleJs.default;
+    },
+    useTranslations: function() {
+        return _useTranslationsJs.default;
+    },
+    useFormatter: function() {
+        return _useFormatterJs.default;
+    },
+    useNow: function() {
+        return _useNowJs.default;
+    },
+    useTimeZone: function() {
+        return _useTimeZoneJs.default;
+    },
+    useMessages: function() {
+        return _useMessagesJs.default;
+    },
+    NextIntlClientProvider: function() {
+        return _nextIntlClientProviderServerJs.default;
+    },
+    useExtracted: function() {
+        return _useExtractedJs.default;
+    }
+});
+var _useLocaleJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useLocale.js"));
+var _useTranslationsJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useTranslations.js"));
+var _useFormatterJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useFormatter.js"));
+var _useNowJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useNow.js"));
+var _useTimeZoneJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useTimeZone.js"));
+var _useMessagesJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useMessages.js"));
+var _nextIntlClientProviderServerJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/NextIntlClientProviderServer.js"));
+var _useExtractedJs = /*#__PURE__*/ _interopRequireDefault(require("./react-server/useExtracted.js"));
+_exportStar(require("use-intl/core"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/esm/development/middleware/getAlternateLinksHeaderValue.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getAlternateLinksHeaderValue;
+    }
+});
+var _utilsJs = require("../shared/utils.js");
+var _utilsJs1 = require("./utils.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+/**
+ * See https://developers.google.com/search/docs/specialty/international/localized-versions
+ */ function getAlternateLinksHeaderValue(param) {
+    var internalTemplateName = param.internalTemplateName, localizedPathnames = param.localizedPathnames, request = param.request, resolvedLocale = param.resolvedLocale, routing = param.routing;
+    var getAlternateEntry = function getAlternateEntry(url, locale) {
+        url.pathname = (0, _utilsJs.normalizeTrailingSlash)(url.pathname);
+        if (request.nextUrl.basePath) {
+            url = new URL(url);
+            url.pathname = (0, _utilsJs1.applyBasePath)(url.pathname, request.nextUrl.basePath);
+        }
+        return "<".concat(url.toString(), '>; rel="alternate"; hreflang="').concat(locale, '"');
+    };
+    var getLocalizedPathname = function getLocalizedPathname(pathname, locale) {
+        if (localizedPathnames && typeof localizedPathnames === "object") {
+            var sourceTemplate = localizedPathnames[resolvedLocale];
+            var _locale;
+            return (0, _utilsJs1.formatTemplatePathname)(pathname, sourceTemplate !== null && sourceTemplate !== void 0 ? sourceTemplate : internalTemplateName, (_locale = localizedPathnames[locale]) !== null && _locale !== void 0 ? _locale : internalTemplateName);
+        } else {
+            return pathname;
+        }
+    };
+    var normalizedUrl = request.nextUrl.clone();
+    var host = (0, _utilsJs1.getHost)(request.headers);
+    if (host) {
+        normalizedUrl.port = "";
+        normalizedUrl.host = host;
+    }
+    var ref;
+    normalizedUrl.protocol = (ref = request.headers.get("x-forwarded-proto")) !== null && ref !== void 0 ? ref : normalizedUrl.protocol;
+    normalizedUrl.pathname = (0, _utilsJs1.getNormalizedPathname)(normalizedUrl.pathname, routing.locales, routing.localePrefix);
+    var links = (0, _utilsJs1.getLocalePrefixes)(routing.locales, routing.localePrefix, false).flatMap(function(param) {
+        var _param = _slicedToArray(param, 2), locale = _param[0], prefix = _param[1];
+        var prefixPathname = function prefixPathname(pathname) {
+            if (pathname === "/") {
+                return prefix;
+            } else {
+                return prefix + pathname;
+            }
+        };
+        var url;
+        if (routing.domains) {
+            var domainConfigs = routing.domains.filter(function(cur) {
+                return (0, _utilsJs1.isLocaleSupportedOnDomain)(locale, cur);
+            });
+            return domainConfigs.map(function(domainConfig) {
+                url = new URL(normalizedUrl);
+                url.port = "";
+                url.host = domainConfig.domain;
+                // Important: Use `normalizedUrl` here, as `url` potentially uses
+                // a `basePath` that automatically gets applied to the pathname
+                url.pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+                // Use domain-specific localePrefix mode if available
+                var domainMode = domainConfig.localePrefix || routing.localePrefix.mode;
+                if (locale !== domainConfig.defaultLocale || domainMode === "always") {
+                    url.pathname = prefixPathname(url.pathname);
+                }
+                return getAlternateEntry(url, locale);
+            });
+        } else {
+            var pathname;
+            if (localizedPathnames && typeof localizedPathnames === "object") {
+                pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+            } else {
+                pathname = normalizedUrl.pathname;
+            }
+            if (locale !== routing.defaultLocale || routing.localePrefix.mode === "always") {
+                pathname = prefixPathname(pathname);
+            }
+            url = new URL(pathname, normalizedUrl);
+        }
+        return getAlternateEntry(url, locale);
+    });
+    // Add x-default entry
+    var shouldAddXDefault = // For domain-based routing there is no reasonable x-default
+    !routing.domains || routing.domains.length === 0;
+    if (shouldAddXDefault) {
+        var localizedPathname = getLocalizedPathname(normalizedUrl.pathname, routing.defaultLocale);
+        if (localizedPathname) {
+            var url = new URL(localizedPathname, normalizedUrl);
+            links.push(getAlternateEntry(url, "x-default"));
+        }
+    }
+    return links.join(", ");
+}

package/dist/esm/development/middleware/middleware.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createMiddleware;
+    }
+});
+var _server = require("next/server");
+var _configJs = require("../routing/config.js");
+var _constantsJs = require("../shared/constants.js");
+var _utilsJs = require("../shared/utils.js");
+var _getAlternateLinksHeaderValueJs = /*#__PURE__*/ _interopRequireDefault(require("./getAlternateLinksHeaderValue.js"));
+var _resolveLocaleJs = /*#__PURE__*/ _interopRequireDefault(require("./resolveLocale.js"));
+var _syncCookieJs = /*#__PURE__*/ _interopRequireDefault(require("./syncCookie.js"));
+var _utilsJs1 = require("./utils.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function createMiddleware(routing) {
+    var resolvedRouting = (0, _configJs.receiveRoutingConfig)(routing);
+    return function middleware(request) {
+        var next = function next(url) {
+            var urlObj = new URL(url, request.url);
+            if (request.nextUrl.basePath) {
+                urlObj.pathname = (0, _utilsJs1.applyBasePath)(urlObj.pathname, request.nextUrl.basePath);
+            }
+            var headers = new Headers(request.headers);
+            headers.set(_constantsJs.HEADER_LOCALE_NAME, locale);
+            var isRewriteNecessary = (0, _utilsJs.normalizeTrailingSlash)(request.nextUrl.pathname) !== (0, _utilsJs.normalizeTrailingSlash)(urlObj.pathname);
+            if (isRewriteNecessary) {
+                return _server.NextResponse.rewrite(urlObj, {
+                    request: {
+                        headers: headers
+                    }
+                });
+            } else {
+                return _server.NextResponse.next({
+                    request: {
+                        headers: headers
+                    }
+                });
+            }
+        };
+        var redirect = function redirect(url, redirectDomain) {
+            var urlObj = new URL(url, request.url);
+            urlObj.pathname = (0, _utilsJs.normalizeTrailingSlash)(urlObj.pathname);
+            if (domainsConfig.length > 0 && !redirectDomain && domain) {
+                var bestMatchingDomain = (0, _utilsJs1.getBestMatchingDomain)(domain, locale, domainsConfig);
+                if (bestMatchingDomain) {
+                    redirectDomain = bestMatchingDomain.domain;
+                    var redirectDomainMode = bestMatchingDomain.localePrefix || resolvedRouting.localePrefix.mode;
+                    if (bestMatchingDomain.defaultLocale === locale && redirectDomainMode === "as-needed") {
+                        urlObj.pathname = (0, _utilsJs1.getNormalizedPathname)(urlObj.pathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+                    }
+                }
+            }
+            if (redirectDomain) {
+                urlObj.host = redirectDomain;
+                if (request.headers.get("x-forwarded-host")) {
+                    var ref;
+                    urlObj.protocol = (ref = request.headers.get("x-forwarded-proto")) !== null && ref !== void 0 ? ref : request.nextUrl.protocol;
+                    var redirectDomainPort = redirectDomain.split(":")[1];
+                    var ref1;
+                    urlObj.port = (ref1 = redirectDomainPort !== null && redirectDomainPort !== void 0 ? redirectDomainPort : request.headers.get("x-forwarded-port")) !== null && ref1 !== void 0 ? ref1 : "";
+                }
+            }
+            if (request.nextUrl.basePath) {
+                urlObj.pathname = (0, _utilsJs1.applyBasePath)(urlObj.pathname, request.nextUrl.basePath);
+            }
+            hasRedirected = true;
+            return _server.NextResponse.redirect(urlObj.toString());
+        };
+        var ref;
+        var unsafeExternalPathname;
+        try {
+            // Resolve potential foreign symbols (e.g. /ja/%E7%B4%84 → /ja/約))
+            unsafeExternalPathname = decodeURI(request.nextUrl.pathname);
+        } catch (e) {
+            // In case an invalid pathname is encountered, forward
+            // it to Next.js which in turn responds with a 400
+            return _server.NextResponse.next();
+        }
+        // Sanitize malicious URIs to prevent open redirect attacks due to
+        // decodeURI doesn't escape encoded backslashes ('%5C' & '%5c')
+        var externalPathname = (0, _utilsJs1.sanitizePathname)(unsafeExternalPathname);
+        var ref1 = (0, _resolveLocaleJs.default)(resolvedRouting, request.headers, request.cookies, externalPathname), domain = ref1.domain, locale = ref1.locale;
+        var hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === resolvedRouting.defaultLocale;
+        var domainsConfig = ((ref = resolvedRouting.domains) === null || ref === void 0 ? void 0 : ref.filter(function(curDomain) {
+            return (0, _utilsJs1.isLocaleSupportedOnDomain)(locale, curDomain);
+        })) || [];
+        var hasUnknownHost = resolvedRouting.domains != null && !domain;
+        var unprefixedExternalPathname = (0, _utilsJs1.getNormalizedPathname)(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+        var pathnameMatch = (0, _utilsJs1.getPathnameMatch)(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix, domain);
+        var hasLocalePrefix = pathnameMatch != null;
+        // Use domain-specific localePrefix mode if available, otherwise use global mode
+        var effectiveLocalePrefixMode = (domain === null || domain === void 0 ? void 0 : domain.localePrefix) || resolvedRouting.localePrefix.mode;
+        var isUnprefixedRouting = effectiveLocalePrefixMode === "never" || hasMatchedDefaultLocale && effectiveLocalePrefixMode === "as-needed";
+        var response;
+        var internalTemplateName;
+        var hasRedirected;
+        var unprefixedInternalPathname = unprefixedExternalPathname;
+        var pathnames = resolvedRouting.pathnames;
+        if (pathnames) {
+            var resolvedTemplateLocale;
+            var ref2;
+            ref2 = _slicedToArray((0, _utilsJs1.getInternalTemplate)(pathnames, unprefixedExternalPathname, locale), 2), resolvedTemplateLocale = ref2[0], internalTemplateName = ref2[1], ref2;
+            if (internalTemplateName) {
+                var pathnameConfig = pathnames[internalTemplateName];
+                var localeTemplate = (0, _utilsJs.getLocalizedTemplate)(pathnameConfig, locale, internalTemplateName);
+                if ((0, _utilsJs.matchesPathname)(localeTemplate, unprefixedExternalPathname)) {
+                    unprefixedInternalPathname = (0, _utilsJs1.formatTemplatePathname)(unprefixedExternalPathname, localeTemplate, internalTemplateName);
+                } else {
+                    var sourceTemplate;
+                    if (resolvedTemplateLocale) {
+                        // A localized pathname from another locale has matched
+                        sourceTemplate = (0, _utilsJs.getLocalizedTemplate)(pathnameConfig, resolvedTemplateLocale, internalTemplateName);
+                    } else {
+                        // An internal pathname has matched that
+                        // doesn't have a localized pathname
+                        sourceTemplate = internalTemplateName;
+                    }
+                    var localePrefix = isUnprefixedRouting ? undefined : (0, _utilsJs.getLocalePrefix)(locale, resolvedRouting.localePrefix);
+                    var template = (0, _utilsJs1.formatTemplatePathname)(unprefixedExternalPathname, sourceTemplate, localeTemplate);
+                    response = redirect((0, _utilsJs1.formatPathname)(template, localePrefix, request.nextUrl.search));
+                }
+            }
+        }
+        if (!response) {
+            if (unprefixedInternalPathname === "/" && !hasLocalePrefix) {
+                if (isUnprefixedRouting) {
+                    response = next((0, _utilsJs1.formatPathname)(unprefixedInternalPathname, (0, _utilsJs1.getLocaleAsPrefix)(locale), request.nextUrl.search));
+                } else {
+                    response = redirect((0, _utilsJs1.formatPathname)(unprefixedExternalPathname, (0, _utilsJs.getLocalePrefix)(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+                }
+            } else {
+                var internalHref = (0, _utilsJs1.formatPathname)(unprefixedInternalPathname, (0, _utilsJs1.getLocaleAsPrefix)(locale), request.nextUrl.search);
+                if (hasLocalePrefix) {
+                    var externalHref = (0, _utilsJs1.formatPathname)(unprefixedExternalPathname, pathnameMatch.prefix, request.nextUrl.search);
+                    if (effectiveLocalePrefixMode === "never") {
+                        response = redirect((0, _utilsJs1.formatPathname)(unprefixedExternalPathname, undefined, request.nextUrl.search));
+                    } else if (pathnameMatch.exact) {
+                        if (hasMatchedDefaultLocale && isUnprefixedRouting) {
+                            response = redirect((0, _utilsJs1.formatPathname)(unprefixedExternalPathname, undefined, request.nextUrl.search));
+                        } else {
+                            if (resolvedRouting.domains) {
+                                var pathDomain = (0, _utilsJs1.getBestMatchingDomain)(domain, pathnameMatch.locale, domainsConfig);
+                                if ((domain === null || domain === void 0 ? void 0 : domain.domain) !== (pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain) && !hasUnknownHost) {
+                                    response = redirect(externalHref, pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain);
+                                } else {
+                                    response = next(internalHref);
+                                }
+                            } else {
+                                response = next(internalHref);
+                            }
+                        }
+                    } else {
+                        response = redirect(externalHref);
+                    }
+                } else {
+                    if (isUnprefixedRouting) {
+                        response = next(internalHref);
+                    } else {
+                        response = redirect((0, _utilsJs1.formatPathname)(unprefixedExternalPathname, (0, _utilsJs.getLocalePrefix)(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+                    }
+                }
+            }
+        }
+        (0, _syncCookieJs.default)(request, response, locale, resolvedRouting, domain);
+        if (!hasRedirected && effectiveLocalePrefixMode !== "never" && resolvedRouting.alternateLinks && resolvedRouting.locales.length > 1) {
+            response.headers.set("Link", (0, _getAlternateLinksHeaderValueJs.default)({
+                routing: resolvedRouting,
+                internalTemplateName: internalTemplateName,
+                localizedPathnames: internalTemplateName != null && pathnames ? pathnames[internalTemplateName] : undefined,
+                request: request,
+                resolvedLocale: locale
+            }));
+        }
+        return response;
+    };
+}