kindflow 0.1.0

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/errors/canary-only-config-error.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    CanaryOnlyConfigError: null,
+    isStableBuild: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    CanaryOnlyConfigError: function() {
+        return CanaryOnlyConfigError;
+    },
+    isStableBuild: function() {
+        return isStableBuild;
+    }
+});
+function isStableBuild() {
+    return !"16.2.1"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+}
+class CanaryOnlyConfigError extends Error {
+    constructor(arg){
+        if (typeof arg === 'object' && 'feature' in arg) {
+            super(`The experimental feature "${arg.feature}" can only be enabled when using the latest canary version of Next.js.`);
+        } else {
+            super(arg);
+        }
+        // This error is meant to interrupt the server start/build process
+        // but the stack trace isn't meaningful, as it points to internal code.
+        this.stack = undefined;
+    }
+}
+
+//# sourceMappingURL=canary-only-config-error.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/errors/code-frame.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "codeFrameColumns", {
+    enumerable: true,
+    get: function() {
+        return codeFrameColumns;
+    }
+});
+const _swc = require("../../../build/swc");
+function codeFrameColumns(file, location, options = {}) {
+    // Default to the terminal width
+    if (options.maxWidth === undefined) {
+        options.maxWidth = process.stdout.columns;
+    }
+    return (0, _swc.getBindingsSync)().codeFrameColumns(file, location, options);
+}
+
+//# sourceMappingURL=code-frame.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/errors/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MISSING_ROOT_TAGS_ERROR", {
+    enumerable: true,
+    get: function() {
+        return MISSING_ROOT_TAGS_ERROR;
+    }
+});
+const MISSING_ROOT_TAGS_ERROR = 'NEXT_MISSING_ROOT_TAGS';
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=constants.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/errors/empty-generate-static-params-error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "throwEmptyGenerateStaticParamsError", {
+    enumerable: true,
+    get: function() {
+        return throwEmptyGenerateStaticParamsError;
+    }
+});
+function throwEmptyGenerateStaticParamsError() {
+    const error = Object.defineProperty(new Error('When using Cache Components, all `generateStaticParams` functions must return at least one result. ' + 'This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\n' + 'Learn more: https://nextjs.org/docs/messages/empty-generate-static-params'), "__NEXT_ERROR_CODE", {
+        value: "E898",
+        enumerable: false,
+        configurable: true
+    });
+    error.name = 'EmptyGenerateStaticParamsError';
+    // This error is meant to interrupt the server start/build process
+    // but the stack trace isn't meaningful, as it points to internal code.
+    error.stack = undefined;
+    throw error;
+}
+
+//# sourceMappingURL=empty-generate-static-params-error.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/errors/hard-deprecated-config-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HardDeprecatedConfigError", {
+    enumerable: true,
+    get: function() {
+        return HardDeprecatedConfigError;
+    }
+});
+class HardDeprecatedConfigError extends Error {
+    constructor(message){
+        super(message);
+        // This error is meant to interrupt the server start/build process
+        // but the stack trace isn't meaningful, as it points to internal code.
+        this.stack = undefined;
+    }
+}
+
+//# sourceMappingURL=hard-deprecated-config-error.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/escape-regexp.js

@@ -0,0 +1,22 @@
+// regexp is based on https://github.com/sindresorhus/escape-string-regexp
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "escapeStringRegexp", {
+    enumerable: true,
+    get: function() {
+        return escapeStringRegexp;
+    }
+});
+const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+function escapeStringRegexp(str) {
+    // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+    if (reHasRegExp.test(str)) {
+        return str.replace(reReplaceRegExp, '\\$&');
+    }
+    return str;
+}
+
+//# sourceMappingURL=escape-regexp.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/get-hostname.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getHostname", {
+    enumerable: true,
+    get: function() {
+        return getHostname;
+    }
+});
+function getHostname(parsed, headers) {
+    // Get the hostname from the headers if it exists, otherwise use the parsed
+    // hostname.
+    let hostname;
+    if (headers?.host && !Array.isArray(headers.host)) {
+        hostname = headers.host.toString().split(':', 1)[0];
+    } else if (parsed.hostname) {
+        hostname = parsed.hostname;
+    } else return;
+    return hostname.toLowerCase();
+}
+
+//# sourceMappingURL=get-hostname.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/hash.js

@@ -0,0 +1,42 @@
+// http://www.cse.yorku.ca/~oz/hash.html
+// More specifically, 32-bit hash via djbxor
+// (ref: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765#gistcomment-3367765)
+// This is due to number type differences between rust for turbopack to js number types,
+// where rust does not have easy way to repreesnt js's 53-bit float number type for the matching
+// overflow behavior. This is more `correct` in terms of having canonical hash across different runtime / implementation
+// as can gaurantee determinstic output from 32bit hash.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    djb2Hash: null,
+    hexHash: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    djb2Hash: function() {
+        return djb2Hash;
+    },
+    hexHash: function() {
+        return hexHash;
+    }
+});
+function djb2Hash(str) {
+    let hash = 5381;
+    for(let i = 0; i < str.length; i++){
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) + hash + char & 0xffffffff;
+    }
+    return hash >>> 0;
+}
+function hexHash(str) {
+    return djb2Hash(str).toString(36).slice(0, 5);
+}
+
+//# sourceMappingURL=hash.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HeadManagerContext", {
+    enumerable: true,
+    get: function() {
+        return HeadManagerContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const HeadManagerContext = _react.default.createContext({});
+if (process.env.NODE_ENV !== 'production') {
+    HeadManagerContext.displayName = 'HeadManagerContext';
+}
+
+//# sourceMappingURL=head-manager-context.shared-runtime.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/head.js

@@ -0,0 +1,163 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    defaultHead: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    defaultHead: function() {
+        return defaultHead;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _sideeffect = /*#__PURE__*/ _interop_require_default._(require("./side-effect"));
+const _headmanagercontextsharedruntime = require("./head-manager-context.shared-runtime");
+const _warnonce = require("./utils/warn-once");
+function defaultHead() {
+    const head = [
+        /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            charSet: "utf-8"
+        }, "charset"),
+        /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            name: "viewport",
+            content: "width=device-width"
+        }, "viewport")
+    ];
+    return head;
+}
+function onlyReactElement(list, child) {
+    // React children can be "string" or "number" in this case we ignore them for backwards compat
+    if (typeof child === 'string' || typeof child === 'number') {
+        return list;
+    }
+    // Adds support for React.Fragment
+    if (child.type === _react.default.Fragment) {
+        return list.concat(// @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+        _react.default.Children.toArray(child.props.children).reduce(// @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+        (fragmentList, fragmentChild)=>{
+            if (typeof fragmentChild === 'string' || typeof fragmentChild === 'number') {
+                return fragmentList;
+            }
+            return fragmentList.concat(fragmentChild);
+        }, []));
+    }
+    return list.concat(child);
+}
+const METATYPES = [
+    'name',
+    'httpEquiv',
+    'charSet',
+    'itemProp'
+];
+/*
+ returns a function for filtering head child elements
+ which shouldn't be duplicated, like <title/>
+ Also adds support for deduplicated `key` properties
+*/ function unique() {
+    const keys = new Set();
+    const tags = new Set();
+    const metaTypes = new Set();
+    const metaCategories = {};
+    return (h)=>{
+        let isUnique = true;
+        let hasKey = false;
+        if (h.key && typeof h.key !== 'number' && h.key.indexOf('$') > 0) {
+            hasKey = true;
+            const key = h.key.slice(h.key.indexOf('$') + 1);
+            if (keys.has(key)) {
+                isUnique = false;
+            } else {
+                keys.add(key);
+            }
+        }
+        // eslint-disable-next-line default-case
+        switch(h.type){
+            case 'title':
+            case 'base':
+                if (tags.has(h.type)) {
+                    isUnique = false;
+                } else {
+                    tags.add(h.type);
+                }
+                break;
+            case 'meta':
+                for(let i = 0, len = METATYPES.length; i < len; i++){
+                    const metatype = METATYPES[i];
+                    if (!h.props.hasOwnProperty(metatype)) continue;
+                    if (metatype === 'charSet') {
+                        if (metaTypes.has(metatype)) {
+                            isUnique = false;
+                        } else {
+                            metaTypes.add(metatype);
+                        }
+                    } else {
+                        const category = h.props[metatype];
+                        const categories = metaCategories[metatype] || new Set();
+                        if ((metatype !== 'name' || !hasKey) && categories.has(category)) {
+                            isUnique = false;
+                        } else {
+                            categories.add(category);
+                            metaCategories[metatype] = categories;
+                        }
+                    }
+                }
+                break;
+        }
+        return isUnique;
+    };
+}
+/**
+ *
+ * @param headChildrenElements List of children of <Head>
+ */ function reduceComponents(headChildrenElements) {
+    return headChildrenElements.reduce(onlyReactElement, []).reverse().concat(defaultHead().reverse()).filter(unique()).reverse().map((c, i)=>{
+        const key = c.key || i;
+        if (process.env.NODE_ENV === 'development') {
+            // omit JSON-LD structured data snippets from the warning
+            if (c.type === 'script' && c.props['type'] !== 'application/ld+json') {
+                const srcMessage = c.props['src'] ? `<script> tag with src="${c.props['src']}"` : `inline <script>`;
+                (0, _warnonce.warnOnce)(`Do not add <script> tags using next/head (see ${srcMessage}). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component`);
+            } else if (c.type === 'link' && c.props['rel'] === 'stylesheet') {
+                (0, _warnonce.warnOnce)(`Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="${c.props['href']}"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component`);
+            }
+        }
+        return /*#__PURE__*/ _react.default.cloneElement(c, {
+            key
+        });
+    });
+}
+/**
+ * This component injects elements to `<head>` of your page.
+ * To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
+ */ function Head({ children }) {
+    const headManager = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_sideeffect.default, {
+        reduceComponentsToState: reduceComponents,
+        headManager: headManager,
+        children: children
+    });
+}
+const _default = Head;
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=head.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js

@@ -0,0 +1,60 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NavigationPromisesContext: null,
+    PathParamsContext: null,
+    PathnameContext: null,
+    ReadonlyURLSearchParams: null,
+    SearchParamsContext: null,
+    createDevToolsInstrumentedPromise: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NavigationPromisesContext: function() {
+        return NavigationPromisesContext;
+    },
+    PathParamsContext: function() {
+        return PathParamsContext;
+    },
+    PathnameContext: function() {
+        return PathnameContext;
+    },
+    ReadonlyURLSearchParams: function() {
+        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
+    },
+    SearchParamsContext: function() {
+        return SearchParamsContext;
+    },
+    createDevToolsInstrumentedPromise: function() {
+        return createDevToolsInstrumentedPromise;
+    }
+});
+const _react = require("react");
+const _readonlyurlsearchparams = require("../../client/components/readonly-url-search-params");
+const SearchParamsContext = (0, _react.createContext)(null);
+const PathnameContext = (0, _react.createContext)(null);
+const PathParamsContext = (0, _react.createContext)(null);
+const NavigationPromisesContext = (0, _react.createContext)(null);
+function createDevToolsInstrumentedPromise(displayName, value) {
+    const promise = Promise.resolve(value);
+    promise.status = 'fulfilled';
+    promise.value = value;
+    promise.displayName = `${displayName} (SSR)`;
+    return promise;
+}
+if (process.env.NODE_ENV !== 'production') {
+    SearchParamsContext.displayName = 'SearchParamsContext';
+    PathnameContext.displayName = 'PathnameContext';
+    PathParamsContext.displayName = 'PathParamsContext';
+    NavigationPromisesContext.displayName = 'NavigationPromisesContext';
+}
+
+//# sourceMappingURL=hooks-client-context.shared-runtime.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/html-context.shared-runtime.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HtmlContext: null,
+    useHtmlContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HtmlContext: function() {
+        return HtmlContext;
+    },
+    useHtmlContext: function() {
+        return useHtmlContext;
+    }
+});
+const _react = require("react");
+const HtmlContext = (0, _react.createContext)(undefined);
+if (process.env.NODE_ENV !== 'production') {
+    HtmlContext.displayName = 'HtmlContext';
+}
+function useHtmlContext() {
+    const context = (0, _react.useContext)(HtmlContext);
+    if (!context) {
+        throw Object.defineProperty(new Error(`<Html> should not be imported outside of pages/_document.\n` + 'Read more: https://nextjs.org/docs/messages/no-document-import-in-page'), "__NEXT_ERROR_CODE", {
+            value: "E67",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return context;
+}
+
+//# sourceMappingURL=html-context.shared-runtime.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "detectDomainLocale", {
+    enumerable: true,
+    get: function() {
+        return detectDomainLocale;
+    }
+});
+function detectDomainLocale(domainItems, hostname, detectedLocale) {
+    if (!domainItems) return;
+    if (detectedLocale) {
+        detectedLocale = detectedLocale.toLowerCase();
+    }
+    for (const item of domainItems){
+        // remove port if present
+        const domainHostname = item.domain?.split(':', 1)[0].toLowerCase();
+        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale)=>locale.toLowerCase() === detectedLocale)) {
+            return item;
+        }
+    }
+}
+
+//# sourceMappingURL=detect-domain-locale.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/i18n/get-locale-redirect.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLocaleRedirect", {
+    enumerable: true,
+    get: function() {
+        return getLocaleRedirect;
+    }
+});
+const _acceptheader = require("../../../server/accept-header");
+const _denormalizepagepath = require("../page-path/denormalize-page-path");
+const _detectdomainlocale = require("./detect-domain-locale");
+const _formaturl = require("../router/utils/format-url");
+const _getcookieparser = require("../../../server/api-utils/get-cookie-parser");
+function getLocaleFromCookie(i18n, headers = {}) {
+    const nextLocale = (0, _getcookieparser.getCookieParser)(headers || {})()?.NEXT_LOCALE?.toLowerCase();
+    return nextLocale ? i18n.locales.find((locale)=>nextLocale === locale.toLowerCase()) : undefined;
+}
+function detectLocale({ i18n, headers, domainLocale, preferredLocale, pathLocale }) {
+    return pathLocale || domainLocale?.defaultLocale || getLocaleFromCookie(i18n, headers) || preferredLocale || i18n.defaultLocale;
+}
+function getAcceptPreferredLocale(i18n, headers) {
+    if (headers?.['accept-language'] && !Array.isArray(headers['accept-language'])) {
+        try {
+            return (0, _acceptheader.acceptLanguage)(headers['accept-language'], i18n.locales);
+        } catch (err) {}
+    }
+}
+function getLocaleRedirect({ defaultLocale, domainLocale, pathLocale, headers, nextConfig, urlParsed }) {
+    if (nextConfig.i18n && nextConfig.i18n.localeDetection !== false && (0, _denormalizepagepath.denormalizePagePath)(urlParsed.pathname) === '/') {
+        const preferredLocale = getAcceptPreferredLocale(nextConfig.i18n, headers);
+        const detectedLocale = detectLocale({
+            i18n: nextConfig.i18n,
+            preferredLocale,
+            headers,
+            pathLocale,
+            domainLocale
+        });
+        const preferredDomain = (0, _detectdomainlocale.detectDomainLocale)(nextConfig.i18n.domains, undefined, preferredLocale);
+        if (domainLocale && preferredDomain) {
+            const isPDomain = preferredDomain.domain === domainLocale.domain;
+            const isPLocale = preferredDomain.defaultLocale === preferredLocale;
+            if (!isPDomain || !isPLocale) {
+                const scheme = `http${preferredDomain.http ? '' : 's'}`;
+                const rlocale = isPLocale ? '' : preferredLocale;
+                return `${scheme}://${preferredDomain.domain}/${rlocale}`;
+            }
+        }
+        if (detectedLocale.toLowerCase() !== defaultLocale.toLowerCase()) {
+            return (0, _formaturl.formatUrl)({
+                ...urlParsed,
+                pathname: `${nextConfig.basePath || ''}/${detectedLocale}${nextConfig.trailingSlash ? '/' : ''}`
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=get-locale-redirect.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeLocalePath", {
+    enumerable: true,
+    get: function() {
+        return normalizeLocalePath;
+    }
+});
+/**
+ * A cache of lowercased locales for each list of locales. This is stored as a
+ * WeakMap so if the locales are garbage collected, the cache entry will be
+ * removed as well.
+ */ const cache = new WeakMap();
+function normalizeLocalePath(pathname, locales) {
+    // If locales is undefined, return the pathname as is.
+    if (!locales) return {
+        pathname
+    };
+    // Get the cached lowercased locales or create a new cache entry.
+    let lowercasedLocales = cache.get(locales);
+    if (!lowercasedLocales) {
+        lowercasedLocales = locales.map((locale)=>locale.toLowerCase());
+        cache.set(locales, lowercasedLocales);
+    }
+    let detectedLocale;
+    // The first segment will be empty, because it has a leading `/`. If
+    // there is no further segment, there is no locale (or it's the default).
+    const segments = pathname.split('/', 2);
+    // If there's no second segment (ie, the pathname is just `/`), there's no
+    // locale.
+    if (!segments[1]) return {
+        pathname
+    };
+    // The second segment will contain the locale part if any.
+    const segment = segments[1].toLowerCase();
+    // See if the segment matches one of the locales. If it doesn't, there is
+    // no locale (or it's the default).
+    const index = lowercasedLocales.indexOf(segment);
+    if (index < 0) return {
+        pathname
+    };
+    // Return the case-sensitive locale.
+    detectedLocale = locales[index];
+    // Remove the `/${locale}` part of the pathname.
+    pathname = pathname.slice(detectedLocale.length + 1) || '/';
+    return {
+        pathname,
+        detectedLocale
+    };
+}
+
+//# sourceMappingURL=normalize-locale-path.js.map

package/web/standalone/apps/web/node_modules/next/dist/shared/lib/image-blur-svg.js

@@ -0,0 +1,22 @@
+/**
+ * A shared function, used on both client and server, to generate a SVG blur placeholder.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImageBlurSvg", {
+    enumerable: true,
+    get: function() {
+        return getImageBlurSvg;
+    }
+});
+function getImageBlurSvg({ widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit }) {
+    const std = 20;
+    const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
+    const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
+    const viewBox = svgWidth && svgHeight ? `viewBox='0 0 ${svgWidth} ${svgHeight}'` : '';
+    const preserveAspectRatio = viewBox ? 'none' : objectFit === 'contain' ? 'xMidYMid' : objectFit === 'cover' ? 'xMidYMid slice' : 'none';
+    return `%3Csvg xmlns='http://www.w3.org/2000/svg' ${viewBox}%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='${preserveAspectRatio}' style='filter: url(%23b);' href='${blurDataURL}'/%3E%3C/svg%3E`;
+}
+
+//# sourceMappingURL=image-blur-svg.js.map