kindflow 0.1.0

package/web/standalone/apps/web/node_modules/next/dist/client/components/hooks-server-context.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DynamicServerError: null,
+    isDynamicServerError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DynamicServerError: function() {
+        return DynamicServerError;
+    },
+    isDynamicServerError: function() {
+        return isDynamicServerError;
+    }
+});
+const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
+class DynamicServerError extends Error {
+    constructor(description){
+        super(`Dynamic server usage: ${description}`), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+    }
+}
+function isDynamicServerError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
+        return false;
+    }
+    return err.digest === DYNAMIC_ERROR_CODE;
+}
+
+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=hooks-server-context.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/http-access-fallback/error-boundary.js

@@ -0,0 +1,125 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HTTPAccessFallbackBoundary", {
+    enumerable: true,
+    get: function() {
+        return HTTPAccessFallbackBoundary;
+    }
+});
+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 _navigationuntracked = require("../navigation-untracked");
+const _httpaccessfallback = require("./http-access-fallback");
+const _warnonce = require("../../../shared/lib/utils/warn-once");
+const _approutercontextsharedruntime = require("../../../shared/lib/app-router-context.shared-runtime");
+class HTTPAccessFallbackErrorBoundary extends _react.default.Component {
+    constructor(props){
+        super(props);
+        this.state = {
+            triggeredStatus: undefined,
+            previousPathname: props.pathname
+        };
+    }
+    componentDidCatch() {
+        if (process.env.NODE_ENV === 'development' && this.props.missingSlots && this.props.missingSlots.size > 0 && // A missing children slot is the typical not-found case, so no need to warn
+        !this.props.missingSlots.has('children')) {
+            let warningMessage = 'No default component was found for a parallel route rendered on this page. Falling back to nearest NotFound boundary.\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/routing/parallel-routes#defaultjs\n\n';
+            const formattedSlots = Array.from(this.props.missingSlots).sort((a, b)=>a.localeCompare(b)).map((slot)=>`@${slot}`).join(', ');
+            warningMessage += 'Missing slots: ' + formattedSlots;
+            (0, _warnonce.warnOnce)(warningMessage);
+        }
+    }
+    static getDerivedStateFromError(error) {
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(error)) {
+            const httpStatus = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(error);
+            return {
+                triggeredStatus: httpStatus
+            };
+        }
+        // Re-throw if error is not for 404
+        throw error;
+    }
+    static getDerivedStateFromProps(props, state) {
+        /**
+     * Handles reset of the error boundary when a navigation happens.
+     * Ensures the error boundary does not stay enabled when navigating to a new page.
+     * Approach of setState in render is safe as it checks the previous pathname and then overrides
+     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
+     */ if (props.pathname !== state.previousPathname && state.triggeredStatus) {
+            return {
+                triggeredStatus: undefined,
+                previousPathname: props.pathname
+            };
+        }
+        return {
+            triggeredStatus: state.triggeredStatus,
+            previousPathname: props.pathname
+        };
+    }
+    render() {
+        const { notFound, forbidden, unauthorized, children } = this.props;
+        const { triggeredStatus } = this.state;
+        const errorComponents = {
+            [_httpaccessfallback.HTTPAccessErrorStatus.NOT_FOUND]: notFound,
+            [_httpaccessfallback.HTTPAccessErrorStatus.FORBIDDEN]: forbidden,
+            [_httpaccessfallback.HTTPAccessErrorStatus.UNAUTHORIZED]: unauthorized
+        };
+        if (triggeredStatus) {
+            const isNotFound = triggeredStatus === _httpaccessfallback.HTTPAccessErrorStatus.NOT_FOUND && notFound;
+            const isForbidden = triggeredStatus === _httpaccessfallback.HTTPAccessErrorStatus.FORBIDDEN && forbidden;
+            const isUnauthorized = triggeredStatus === _httpaccessfallback.HTTPAccessErrorStatus.UNAUTHORIZED && unauthorized;
+            // If there's no matched boundary in this layer, keep throwing the error by rendering the children
+            if (!(isNotFound || isForbidden || isUnauthorized)) {
+                return children;
+            }
+            return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                        name: "robots",
+                        content: "noindex"
+                    }),
+                    process.env.NODE_ENV === 'development' && /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                        name: "boundary-next-error",
+                        content: (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(triggeredStatus)
+                    }),
+                    errorComponents[triggeredStatus]
+                ]
+            });
+        }
+        return children;
+    }
+}
+function HTTPAccessFallbackBoundary({ notFound, forbidden, unauthorized, children }) {
+    // When we're rendering the missing params shell, this will return null. This
+    // is because we won't be rendering any not found boundaries or error
+    // boundaries for the missing params shell. When this runs on the client
+    // (where these error can occur), we will get the correct pathname.
+    const pathname = (0, _navigationuntracked.useUntrackedPathname)();
+    const missingSlots = (0, _react.useContext)(_approutercontextsharedruntime.MissingSlotContext);
+    const hasErrorFallback = !!(notFound || forbidden || unauthorized);
+    if (hasErrorFallback) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(HTTPAccessFallbackErrorBoundary, {
+            pathname: pathname,
+            notFound: notFound,
+            forbidden: forbidden,
+            unauthorized: unauthorized,
+            missingSlots: missingSlots,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+        children: children
+    });
+}
+
+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=error-boundary.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/http-access-fallback/http-access-fallback.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HTTPAccessErrorStatus: null,
+    HTTP_ERROR_FALLBACK_ERROR_CODE: null,
+    getAccessFallbackErrorTypeByStatus: null,
+    getAccessFallbackHTTPStatus: null,
+    isHTTPAccessFallbackError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HTTPAccessErrorStatus: function() {
+        return HTTPAccessErrorStatus;
+    },
+    HTTP_ERROR_FALLBACK_ERROR_CODE: function() {
+        return HTTP_ERROR_FALLBACK_ERROR_CODE;
+    },
+    getAccessFallbackErrorTypeByStatus: function() {
+        return getAccessFallbackErrorTypeByStatus;
+    },
+    getAccessFallbackHTTPStatus: function() {
+        return getAccessFallbackHTTPStatus;
+    },
+    isHTTPAccessFallbackError: function() {
+        return isHTTPAccessFallbackError;
+    }
+});
+const HTTPAccessErrorStatus = {
+    NOT_FOUND: 404,
+    FORBIDDEN: 403,
+    UNAUTHORIZED: 401
+};
+const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
+const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK';
+function isHTTPAccessFallbackError(error) {
+    if (typeof error !== 'object' || error === null || !('digest' in error) || typeof error.digest !== 'string') {
+        return false;
+    }
+    const [prefix, httpStatus] = error.digest.split(';');
+    return prefix === HTTP_ERROR_FALLBACK_ERROR_CODE && ALLOWED_CODES.has(Number(httpStatus));
+}
+function getAccessFallbackHTTPStatus(error) {
+    const httpStatus = error.digest.split(';')[1];
+    return Number(httpStatus);
+}
+function getAccessFallbackErrorTypeByStatus(status) {
+    switch(status){
+        case 401:
+            return 'unauthorized';
+        case 403:
+            return 'forbidden';
+        case 404:
+            return 'not-found';
+        default:
+            return;
+    }
+}
+
+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=http-access-fallback.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/is-next-router-error.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isNextRouterError", {
+    enumerable: true,
+    get: function() {
+        return isNextRouterError;
+    }
+});
+const _httpaccessfallback = require("./http-access-fallback/http-access-fallback");
+const _redirecterror = require("./redirect-error");
+function isNextRouterError(error) {
+    return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error);
+}
+
+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=is-next-router-error.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/links.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    IDLE_LINK_STATUS: null,
+    PENDING_LINK_STATUS: null,
+    getLinkForCurrentNavigation: null,
+    mountFormInstance: null,
+    mountLinkInstance: null,
+    onLinkVisibilityChanged: null,
+    onNavigationIntent: null,
+    pingVisibleLinks: null,
+    setLinkForCurrentNavigation: null,
+    unmountLinkForCurrentNavigation: null,
+    unmountPrefetchableInstance: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    IDLE_LINK_STATUS: function() {
+        return IDLE_LINK_STATUS;
+    },
+    PENDING_LINK_STATUS: function() {
+        return PENDING_LINK_STATUS;
+    },
+    getLinkForCurrentNavigation: function() {
+        return getLinkForCurrentNavigation;
+    },
+    mountFormInstance: function() {
+        return mountFormInstance;
+    },
+    mountLinkInstance: function() {
+        return mountLinkInstance;
+    },
+    onLinkVisibilityChanged: function() {
+        return onLinkVisibilityChanged;
+    },
+    onNavigationIntent: function() {
+        return onNavigationIntent;
+    },
+    pingVisibleLinks: function() {
+        return pingVisibleLinks;
+    },
+    setLinkForCurrentNavigation: function() {
+        return setLinkForCurrentNavigation;
+    },
+    unmountLinkForCurrentNavigation: function() {
+        return unmountLinkForCurrentNavigation;
+    },
+    unmountPrefetchableInstance: function() {
+        return unmountPrefetchableInstance;
+    }
+});
+const _types = require("./segment-cache/types");
+const _cachekey = require("./segment-cache/cache-key");
+const _scheduler = require("./segment-cache/scheduler");
+const _react = require("react");
+// Tracks the most recently navigated link instance. When null, indicates
+// the current navigation was not initiated by a link click.
+let linkForMostRecentNavigation = null;
+const PENDING_LINK_STATUS = {
+    pending: true
+};
+const IDLE_LINK_STATUS = {
+    pending: false
+};
+function setLinkForCurrentNavigation(link) {
+    (0, _react.startTransition)(()=>{
+        linkForMostRecentNavigation?.setOptimisticLinkStatus(IDLE_LINK_STATUS);
+        link?.setOptimisticLinkStatus(PENDING_LINK_STATUS);
+        linkForMostRecentNavigation = link;
+    });
+}
+function unmountLinkForCurrentNavigation(link) {
+    if (linkForMostRecentNavigation === link) {
+        linkForMostRecentNavigation = null;
+    }
+}
+function getLinkForCurrentNavigation() {
+    return linkForMostRecentNavigation;
+}
+// Use a WeakMap to associate a Link instance with its DOM element. This is
+// used by the IntersectionObserver to track the link's visibility.
+const prefetchable = typeof WeakMap === 'function' ? new WeakMap() : new Map();
+// A Set of the currently visible links. We re-prefetch visible links after a
+// cache invalidation, or when the current URL changes. It's a separate data
+// structure from the WeakMap above because only the visible links need to
+// be enumerated.
+const prefetchableAndVisible = new Set();
+// A single IntersectionObserver instance shared by all <Link> components.
+const observer = typeof IntersectionObserver === 'function' ? new IntersectionObserver(handleIntersect, {
+    rootMargin: '200px'
+}) : null;
+function observeVisibility(element, instance) {
+    const existingInstance = prefetchable.get(element);
+    if (existingInstance !== undefined) {
+        // This shouldn't happen because each <Link> component should have its own
+        // anchor tag instance, but it's defensive coding to avoid a memory leak in
+        // case there's a logical error somewhere else.
+        unmountPrefetchableInstance(element);
+    }
+    // Only track prefetchable links that have a valid prefetch URL
+    prefetchable.set(element, instance);
+    if (observer !== null) {
+        observer.observe(element);
+    }
+}
+function coercePrefetchableUrl(href) {
+    if (typeof window !== 'undefined') {
+        const { createPrefetchURL } = require('./app-router-utils');
+        try {
+            return createPrefetchURL(href);
+        } catch  {
+            // createPrefetchURL sometimes throws an error if an invalid URL is
+            // provided, though I'm not sure if it's actually necessary.
+            // TODO: Consider removing the throw from the inner function, or change it
+            // to reportError. Or maybe the error isn't even necessary for automatic
+            // prefetches, just navigations.
+            const reportErrorFn = typeof reportError === 'function' ? reportError : console.error;
+            reportErrorFn(`Cannot prefetch '${href}' because it cannot be converted to a URL.`);
+            return null;
+        }
+    } else {
+        return null;
+    }
+}
+function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus) {
+    if (prefetchEnabled) {
+        const prefetchURL = coercePrefetchableUrl(href);
+        if (prefetchURL !== null) {
+            const instance = {
+                router,
+                fetchStrategy,
+                isVisible: false,
+                prefetchTask: null,
+                prefetchHref: prefetchURL.href,
+                setOptimisticLinkStatus
+            };
+            // We only observe the link's visibility if it's prefetchable. For
+            // example, this excludes links to external URLs.
+            observeVisibility(element, instance);
+            return instance;
+        }
+    }
+    // If the link is not prefetchable, we still create an instance so we can
+    // track its optimistic state (i.e. useLinkStatus).
+    const instance = {
+        router,
+        fetchStrategy,
+        isVisible: false,
+        prefetchTask: null,
+        prefetchHref: null,
+        setOptimisticLinkStatus
+    };
+    return instance;
+}
+function mountFormInstance(element, href, router, fetchStrategy) {
+    const prefetchURL = coercePrefetchableUrl(href);
+    if (prefetchURL === null) {
+        // This href is not prefetchable, so we don't track it.
+        // TODO: We currently observe/unobserve a form every time its href changes.
+        // For Links, this isn't a big deal because the href doesn't usually change,
+        // but for forms it's extremely common. We should optimize this.
+        return;
+    }
+    const instance = {
+        router,
+        fetchStrategy,
+        isVisible: false,
+        prefetchTask: null,
+        prefetchHref: prefetchURL.href,
+        setOptimisticLinkStatus: null
+    };
+    observeVisibility(element, instance);
+}
+function unmountPrefetchableInstance(element) {
+    const instance = prefetchable.get(element);
+    if (instance !== undefined) {
+        prefetchable.delete(element);
+        prefetchableAndVisible.delete(instance);
+        const prefetchTask = instance.prefetchTask;
+        if (prefetchTask !== null) {
+            (0, _scheduler.cancelPrefetchTask)(prefetchTask);
+        }
+    }
+    if (observer !== null) {
+        observer.unobserve(element);
+    }
+}
+function handleIntersect(entries) {
+    for (const entry of entries){
+        // Some extremely old browsers or polyfills don't reliably support
+        // isIntersecting so we check intersectionRatio instead. (Do we care? Not
+        // really. But whatever this is fine.)
+        const isVisible = entry.intersectionRatio > 0;
+        onLinkVisibilityChanged(entry.target, isVisible);
+    }
+}
+function onLinkVisibilityChanged(element, isVisible) {
+    if (process.env.NODE_ENV !== 'production') {
+        // Prefetching on viewport is disabled in development for performance
+        // reasons, because it requires compiling the target page.
+        // TODO: Investigate re-enabling this.
+        return;
+    }
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    instance.isVisible = isVisible;
+    if (isVisible) {
+        prefetchableAndVisible.add(instance);
+    } else {
+        prefetchableAndVisible.delete(instance);
+    }
+    rescheduleLinkPrefetch(instance, _types.PrefetchPriority.Default);
+}
+function onNavigationIntent(element, unstable_upgradeToDynamicPrefetch) {
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    // Prefetch the link on hover/touchstart.
+    if (instance !== undefined) {
+        if (process.env.__NEXT_DYNAMIC_ON_HOVER && unstable_upgradeToDynamicPrefetch) {
+            // Switch to a full prefetch
+            instance.fetchStrategy = _types.FetchStrategy.Full;
+        }
+        rescheduleLinkPrefetch(instance, _types.PrefetchPriority.Intent);
+    }
+}
+function rescheduleLinkPrefetch(instance, priority) {
+    // Ensures that app-router-instance is not compiled in the server bundle
+    if (typeof window !== 'undefined') {
+        const existingPrefetchTask = instance.prefetchTask;
+        if (!instance.isVisible) {
+            // Cancel any in-progress prefetch task. (If it already finished then this
+            // is a no-op.)
+            if (existingPrefetchTask !== null) {
+                (0, _scheduler.cancelPrefetchTask)(existingPrefetchTask);
+            }
+            // We don't need to reset the prefetchTask to null upon cancellation; an
+            // old task object can be rescheduled with reschedulePrefetchTask. This is a
+            // micro-optimization but also makes the code simpler (don't need to
+            // worry about whether an old task object is stale).
+            return;
+        }
+        const { getCurrentAppRouterState } = require('./app-router-instance');
+        const appRouterState = getCurrentAppRouterState();
+        if (appRouterState !== null) {
+            const treeAtTimeOfPrefetch = appRouterState.tree;
+            if (existingPrefetchTask === null) {
+                // Initiate a prefetch task.
+                const nextUrl = appRouterState.nextUrl;
+                const cacheKey = (0, _cachekey.createCacheKey)(instance.prefetchHref, nextUrl);
+                instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, instance.fetchStrategy, priority, null);
+            } else {
+                // We already have an old task object that we can reschedule. This is
+                // effectively the same as canceling the old task and creating a new one.
+                (0, _scheduler.reschedulePrefetchTask)(existingPrefetchTask, treeAtTimeOfPrefetch, instance.fetchStrategy, priority);
+            }
+        }
+    }
+}
+function pingVisibleLinks(nextUrl, tree) {
+    // For each currently visible link, cancel the existing prefetch task (if it
+    // exists) and schedule a new one. This is effectively the same as if all the
+    // visible links left and then re-entered the viewport.
+    //
+    // This is called when the Next-Url or the base tree changes, since those
+    // may affect the result of a prefetch task. It's also called after a
+    // cache invalidation.
+    for (const instance of prefetchableAndVisible){
+        const task = instance.prefetchTask;
+        if (task !== null && !(0, _scheduler.isPrefetchTaskDirty)(task, nextUrl, tree)) {
+            continue;
+        }
+        // Something changed. Cancel the existing prefetch task and schedule a
+        // new one.
+        if (task !== null) {
+            (0, _scheduler.cancelPrefetchTask)(task);
+        }
+        const cacheKey = (0, _cachekey.createCacheKey)(instance.prefetchHref, nextUrl);
+        instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, tree, instance.fetchStrategy, _types.PrefetchPriority.Default, null);
+    }
+}
+
+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=links.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/match-segments.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "matchSegment", {
+    enumerable: true,
+    get: function() {
+        return matchSegment;
+    }
+});
+const matchSegment = (existingSegment, segment)=>{
+    // segment is either Array or string
+    if (typeof existingSegment === 'string') {
+        if (typeof segment === 'string') {
+            // Common case: segment is just a string
+            return existingSegment === segment;
+        }
+        return false;
+    }
+    if (typeof segment === 'string') {
+        return false;
+    }
+    return existingSegment[0] === segment[0] && existingSegment[1] === segment[1];
+};
+
+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=match-segments.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/components/nav-failure-handler.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handleHardNavError: null,
+    useNavFailureHandler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handleHardNavError: function() {
+        return handleHardNavError;
+    },
+    useNavFailureHandler: function() {
+        return useNavFailureHandler;
+    }
+});
+const _react = require("react");
+const _createhreffromurl = require("./router-reducer/create-href-from-url");
+function handleHardNavError(error) {
+    if (error && typeof window !== 'undefined' && window.next.__pendingUrl && (0, _createhreffromurl.createHrefFromUrl)(new URL(window.location.href)) !== (0, _createhreffromurl.createHrefFromUrl)(window.next.__pendingUrl)) {
+        console.error(`Error occurred during navigation, falling back to hard navigation`, error);
+        window.location.href = window.next.__pendingUrl.toString();
+        return true;
+    }
+    return false;
+}
+function useNavFailureHandler() {
+    if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+        // this if is only for DCE of the feature flag not conditional
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, _react.useEffect)(()=>{
+            const uncaughtExceptionHandler = (evt)=>{
+                const error = 'reason' in evt ? evt.reason : evt.error;
+                // if we have an unhandled exception/rejection during
+                // a navigation we fall back to a hard navigation to
+                // attempt recovering to a good state
+                handleHardNavError(error);
+            };
+            window.addEventListener('unhandledrejection', uncaughtExceptionHandler);
+            window.addEventListener('error', uncaughtExceptionHandler);
+            return ()=>{
+                window.removeEventListener('error', uncaughtExceptionHandler);
+                window.removeEventListener('unhandledrejection', uncaughtExceptionHandler);
+            };
+        }, []);
+    }
+}
+
+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=nav-failure-handler.js.map