@common.js/next-intl 4.13.1

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

@@ -0,0 +1,150 @@
+"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, {
+    default: function() {
+        return resolveLocale;
+    },
+    getAcceptLanguageLocale: function() {
+        return getAcceptLanguageLocale;
+    }
+});
+var _intlLocalematcher = require("@formatjs/intl-localematcher");
+var _negotiator = /*#__PURE__*/ _interopRequireDefault(require("negotiator"));
+var _utilsJs = require("./utils.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function findDomainFromHost(requestHeaders, domains) {
+    var host = (0, _utilsJs.getHost)(requestHeaders);
+    if (host) {
+        return domains.find(function(cur) {
+            return cur.domain === host;
+        });
+    }
+    return undefined;
+}
+function orderLocales(locales) {
+    // Workaround for https://github.com/formatjs/formatjs/issues/4469
+    return locales.slice().sort(function(a, b) {
+        return b.length - a.length;
+    });
+}
+function mapToProvidedLocale(locales, locale) {
+    return locales.find(function(cur) {
+        return cur.toLowerCase() === locale.toLowerCase();
+    });
+}
+function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
+    var locale;
+    var languages = new _negotiator.default({
+        headers: {
+            "accept-language": requestHeaders.get("accept-language") || undefined
+        }
+    }).languages();
+    try {
+        var orderedLocales = orderLocales(locales);
+        locale = mapToProvidedLocale(locales, (0, _intlLocalematcher.match)(languages, orderedLocales, defaultLocale));
+    } catch (e) {
+    // Invalid language
+    }
+    return locale;
+}
+function getLocaleFromCookie(routing, requestCookies) {
+    if (routing.localeCookie && requestCookies.has(routing.localeCookie.name)) {
+        var ref;
+        var value = (ref = requestCookies.get(routing.localeCookie.name)) === null || ref === void 0 ? void 0 : ref.value;
+        if (value && routing.locales.includes(value)) {
+            return value;
+        }
+    }
+}
+function resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname) {
+    var locale;
+    // Prio 1: Use route prefix
+    if (pathname) {
+        var ref;
+        locale = (ref = (0, _utilsJs.getPathnameMatch)(pathname, routing.locales, routing.localePrefix)) === null || ref === void 0 ? void 0 : ref.locale;
+    }
+    // Prio 2: Use existing cookie
+    if (!locale && routing.localeDetection) {
+        locale = getLocaleFromCookie(routing, requestCookies);
+    }
+    // Prio 3: Use the `accept-language` header
+    if (!locale && routing.localeDetection) {
+        locale = getAcceptLanguageLocale(requestHeaders, routing.locales, routing.defaultLocale);
+    }
+    // Prio 4: Use default locale
+    if (!locale) {
+        locale = routing.defaultLocale;
+    }
+    return locale;
+}
+function resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname) {
+    var domains = routing.domains;
+    var domain = findDomainFromHost(requestHeaders, domains);
+    if (!domain) {
+        return {
+            locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+        };
+    }
+    var locale;
+    // Prio 1: Use route prefix
+    if (pathname) {
+        var ref;
+        var prefixLocale = (ref = (0, _utilsJs.getPathnameMatch)(pathname, routing.locales, routing.localePrefix, domain)) === null || ref === void 0 ? void 0 : ref.locale;
+        if (prefixLocale) {
+            if ((0, _utilsJs.isLocaleSupportedOnDomain)(prefixLocale, domain)) {
+                locale = prefixLocale;
+            } else {
+                // Causes a redirect to a domain that supports the locale
+                return {
+                    locale: prefixLocale,
+                    domain: domain
+                };
+            }
+        }
+    }
+    // Prio 2: Use existing cookie
+    if (!locale && routing.localeDetection) {
+        var cookieLocale = getLocaleFromCookie(routing, requestCookies);
+        if (cookieLocale) {
+            if ((0, _utilsJs.isLocaleSupportedOnDomain)(cookieLocale, domain)) {
+                locale = cookieLocale;
+            }
+        }
+    }
+    // Prio 3: Use the `accept-language` header
+    if (!locale && routing.localeDetection) {
+        var headerLocale = getAcceptLanguageLocale(requestHeaders, domain.locales, domain.defaultLocale);
+        if (headerLocale) {
+            locale = headerLocale;
+        }
+    }
+    // Prio 4: Use default locale
+    if (!locale) {
+        locale = domain.defaultLocale;
+    }
+    return {
+        locale: locale,
+        domain: domain
+    };
+}
+function resolveLocale(routing, requestHeaders, requestCookies, pathname) {
+    if (routing.domains) {
+        return resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname);
+    } else {
+        return {
+            locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+        };
+    }
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return syncCookie;
+    }
+});
+var _resolveLocaleJs = require("./resolveLocale.js");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function syncCookie(request, response, locale, routing, domain) {
+    var ref;
+    if (!routing.localeCookie) return;
+    var _localeCookie = routing.localeCookie, name = _localeCookie.name, rest = _objectWithoutProperties(_localeCookie, [
+        "name"
+    ]);
+    var hasLocaleCookie = request.cookies.has(name);
+    var hasOutdatedCookie = hasLocaleCookie && ((ref = request.cookies.get(name)) === null || ref === void 0 ? void 0 : ref.value) !== locale;
+    if (hasOutdatedCookie) {
+        response.cookies.set(name, locale, _objectSpread({
+            path: request.nextUrl.basePath || undefined
+        }, rest));
+    } else if (!hasLocaleCookie) {
+        var acceptLanguageLocale = (0, _resolveLocaleJs.getAcceptLanguageLocale)(request.headers, (domain === null || domain === void 0 ? void 0 : domain.locales) || routing.locales, routing.defaultLocale);
+        if (acceptLanguageLocale !== locale) {
+            response.cookies.set(name, locale, _objectSpread({
+                path: request.nextUrl.basePath || undefined
+            }, rest));
+        }
+    }
+}

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

@@ -0,0 +1,403 @@
+"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, {
+    applyBasePath: function() {
+        return applyBasePath;
+    },
+    formatPathname: function() {
+        return formatPathname;
+    },
+    formatPathnameTemplate: function() {
+        return formatPathnameTemplate;
+    },
+    formatTemplatePathname: function() {
+        return formatTemplatePathname;
+    },
+    getBestMatchingDomain: function() {
+        return getBestMatchingDomain;
+    },
+    getHost: function() {
+        return getHost;
+    },
+    getInternalTemplate: function() {
+        return getInternalTemplate;
+    },
+    getLocaleAsPrefix: function() {
+        return getLocaleAsPrefix;
+    },
+    getLocalePrefixes: function() {
+        return getLocalePrefixes;
+    },
+    getNormalizedPathname: function() {
+        return getNormalizedPathname;
+    },
+    getPathnameMatch: function() {
+        return getPathnameMatch;
+    },
+    getRouteParams: function() {
+        return getRouteParams;
+    },
+    isLocaleSupportedOnDomain: function() {
+        return isLocaleSupportedOnDomain;
+    },
+    sanitizePathname: function() {
+        return sanitizePathname;
+    }
+});
+var _utilsJs = require("../shared/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();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+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 getInternalTemplate(pathnames, pathname, locale) {
+    var sortedPathnames = (0, _utilsJs.getSortedPathnames)(Object.keys(pathnames));
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var internalPathname = _step.value;
+            var localizedPathnamesOrPathname = pathnames[internalPathname];
+            if (typeof localizedPathnamesOrPathname === "string") {
+                var localizedPathname = localizedPathnamesOrPathname;
+                if ((0, _utilsJs.matchesPathname)(localizedPathname, pathname)) {
+                    return {
+                        v: [
+                            undefined,
+                            internalPathname
+                        ]
+                    };
+                }
+            } else {
+                // Prefer the entry with the current locale in case multiple
+                // localized pathnames match the current pathname
+                var sortedEntries = Object.entries(localizedPathnamesOrPathname);
+                var curLocaleIndex = sortedEntries.findIndex(function(param) {
+                    var _param = _slicedToArray(param, 1), entryLocale = _param[0];
+                    return entryLocale === locale;
+                });
+                if (curLocaleIndex > 0) {
+                    sortedEntries.unshift(sortedEntries.splice(curLocaleIndex, 1)[0]);
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = sortedEntries[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step1.value, 1), entryLocale = _value[0];
+                        var localizedTemplate = (0, _utilsJs.getLocalizedTemplate)(pathnames[internalPathname], entryLocale, internalPathname);
+                        if ((0, _utilsJs.matchesPathname)(localizedTemplate, pathname)) {
+                            return {
+                                v: [
+                                    entryLocale,
+                                    internalPathname
+                                ]
+                            };
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        };
+        // Try to find a localized pathname that matches
+        for(var _iterator = sortedPathnames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _ret = _loop();
+            if (_typeof(_ret) === "object") return _ret.v;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        // Try to find an internal pathname that matches (this can be the case
+        // if all localized pathnames are different from the internal pathnames)
+        for(var _iterator1 = Object.keys(pathnames)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var internalPathname = _step1.value;
+            if ((0, _utilsJs.matchesPathname)(internalPathname, pathname)) {
+                return [
+                    undefined,
+                    internalPathname
+                ];
+            }
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    // No match
+    return [
+        undefined,
+        undefined
+    ];
+}
+function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, prefix) {
+    var params = getRouteParams(sourceTemplate, sourcePathname);
+    var targetPathname = "";
+    targetPathname += formatPathnameTemplate(targetTemplate, params);
+    // A pathname with an optional catchall like `/categories/[[...slug]]`
+    // should be normalized to `/categories` if the catchall is not present
+    // and no trailing slash is configured
+    targetPathname = (0, _utilsJs.normalizeTrailingSlash)(targetPathname);
+    return targetPathname;
+}
+/**
+ * Removes potential prefixes from the pathname.
+ */ function getNormalizedPathname(pathname, locales, localePrefix) {
+    // Add trailing slash for consistent handling
+    // both for the root as well as nested paths
+    if (!pathname.endsWith("/")) {
+        pathname += "/";
+    }
+    var localePrefixes = getLocalePrefixes(locales, localePrefix);
+    var regex = new RegExp("^(".concat(localePrefixes.map(function(param) {
+        var _param = _slicedToArray(param, 2), prefix = _param[1];
+        return prefix.replaceAll("/", "\\/");
+    }).join("|"), ")/(.*)"), "i");
+    var match = pathname.match(regex);
+    var result = match ? "/" + match[2] : pathname;
+    if (result !== "/") {
+        result = (0, _utilsJs.normalizeTrailingSlash)(result);
+    }
+    return result;
+}
+function getLocalePrefixes(locales, localePrefix) {
+    var sort = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+    var prefixes = locales.map(function(locale) {
+        return [
+            locale,
+            (0, _utilsJs.getLocalePrefix)(locale, localePrefix)
+        ];
+    });
+    if (sort) {
+        // More specific ones first
+        prefixes.sort(function(a, b) {
+            return b[1].length - a[1].length;
+        });
+    }
+    return prefixes;
+}
+function getPathnameMatch(pathname, locales, localePrefix, domain) {
+    var localePrefixes = getLocalePrefixes(locales, localePrefix);
+    // Sort to prioritize domain locales
+    if (domain) {
+        localePrefixes.sort(function(param, param1) {
+            var _param = _slicedToArray(param, 1), localeA = _param[0], _param1 = _slicedToArray(param1, 1), localeB = _param1[0];
+            if (localeA === domain.defaultLocale) return -1;
+            if (localeB === domain.defaultLocale) return 1;
+            var isLocaleAInDomain = domain.locales.includes(localeA);
+            var isLocaleBInDomain = domain.locales.includes(localeB);
+            if (isLocaleAInDomain && !isLocaleBInDomain) return -1;
+            if (!isLocaleAInDomain && isLocaleBInDomain) return 1;
+            return 0;
+        });
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = localePrefixes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), locale = _value[0], prefix = _value[1];
+            var exact = void 0, matches = void 0;
+            if (pathname === prefix || pathname.startsWith(prefix + "/")) {
+                exact = matches = true;
+            } else {
+                var normalizedPathname = pathname.toLowerCase();
+                var normalizedPrefix = prefix.toLowerCase();
+                if (normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(normalizedPrefix + "/")) {
+                    exact = false;
+                    matches = true;
+                }
+            }
+            if (matches) {
+                return {
+                    locale: locale,
+                    prefix: prefix,
+                    matchedPrefix: pathname.slice(0, prefix.length),
+                    exact: exact
+                };
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function getRouteParams(template, pathname) {
+    var normalizedPathname = (0, _utilsJs.normalizeTrailingSlash)(pathname);
+    var normalizedTemplate = (0, _utilsJs.normalizeTrailingSlash)(template);
+    var regex = (0, _utilsJs.templateToRegex)(normalizedTemplate);
+    var match = regex.exec(normalizedPathname);
+    if (!match) return undefined;
+    var params = {};
+    var ref;
+    var keys = (ref = normalizedTemplate.match(/\[([^\]]+)\]/g)) !== null && ref !== void 0 ? ref : [];
+    for(var i = 1; i < match.length; i++){
+        var rawKey = keys[i - 1];
+        if (!rawKey) continue;
+        var key = rawKey.replace(/[[\]]/g, "");
+        var _i;
+        var value = (_i = match[i]) !== null && _i !== void 0 ? _i : "";
+        params[key] = value;
+    }
+    return params;
+}
+function formatPathnameTemplate(template, params) {
+    if (!params) return template;
+    // Simplify syntax for optional catchall ('[[...slug]]') so
+    // we can replace the value with simple interpolation
+    template = template.replace(/\[\[/g, "[").replace(/\]\]/g, "]");
+    var result = template;
+    Object.entries(params).forEach(function(param) {
+        var _param = _slicedToArray(param, 2), key = _param[0], value = _param[1];
+        result = result.replace("[".concat(key, "]"), value);
+    });
+    return result;
+}
+function formatPathname(pathname, prefix, search) {
+    var result = pathname;
+    if (prefix) {
+        result = (0, _utilsJs.prefixPathname)(prefix, result);
+    }
+    if (search) {
+        result += search;
+    }
+    return result;
+}
+function getHost(requestHeaders) {
+    var ref, ref1;
+    return (ref1 = (ref = requestHeaders.get("x-forwarded-host")) !== null && ref !== void 0 ? ref : requestHeaders.get("host")) !== null && ref1 !== void 0 ? ref1 : undefined;
+}
+function isLocaleSupportedOnDomain(locale, domain) {
+    return domain.defaultLocale === locale || domain.locales.includes(locale);
+}
+function getBestMatchingDomain(curHostDomain, locale, domainsConfig) {
+    var domainConfig;
+    // Prio 1: Stay on current domain
+    if (curHostDomain && isLocaleSupportedOnDomain(locale, curHostDomain)) {
+        domainConfig = curHostDomain;
+    }
+    // Prio 2: Use alternative domain with matching default locale
+    if (!domainConfig) {
+        domainConfig = domainsConfig.find(function(cur) {
+            return cur.defaultLocale === locale;
+        });
+    }
+    // Prio 3: Use alternative domain that supports the locale
+    if (!domainConfig) {
+        domainConfig = domainsConfig.find(function(cur) {
+            return cur.locales.includes(locale);
+        });
+    }
+    return domainConfig;
+}
+function applyBasePath(pathname, basePath) {
+    return (0, _utilsJs.normalizeTrailingSlash)(basePath + pathname);
+}
+function getLocaleAsPrefix(locale) {
+    return "/".concat(locale);
+}
+function sanitizePathname(pathname) {
+    // Sanitize malicious URIs, e.g.:
+    // '/en/\\example.org'  → '/en/%5Cexample.org'     (backslash → %5C)
+    // '/en/\t/example.org' → '/en/example.org'        (WHATWG-stripped TAB)
+    // '/en/\n/example.org' → '/en/example.org'        (WHATWG-stripped LF)
+    // '/en/\r/example.org' → '/en/example.org'        (WHATWG-stripped CR)
+    // '/en////example.org' → '/en/example.org'        (consecutive slashes)
+    //
+    // U+0009/000A/000D are silently stripped by the WHATWG URL parser
+    // (https://url.spec.whatwg.org/#concept-url-parser). Without removing
+    // them here, a decoded TAB in a segment separator position causes
+    // new URL("/\t/host", base) to collapse to "//host" → open redirect.
+    return pathname.replace(/\\/g, "%5C").replace(/[\t\n\r]/g, "").replace(/\/+/g, "/");
+}

package/dist/esm/development/middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _middlewareJs.default;
+    }
+});
+var _middlewareJs = /*#__PURE__*/ _interopRequireDefault(require("./middleware/middleware.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}