@nogataka/cc-search 0.1.0

package/dist/standalone/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/dist/standalone/node_modules/next/dist/client/components/links.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    IDLE_LINK_STATUS: null,
+    PENDING_LINK_STATUS: 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;
+    },
+    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 _approuterinstance = require("./app-router-instance");
+const _approuter = require("./app-router");
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _segmentcache = require("./segment-cache");
+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 == null ? void 0 : linkForMostRecentNavigation.setOptimisticLinkStatus(IDLE_LINK_STATUS);
+        link == null ? void 0 : link.setOptimisticLinkStatus(PENDING_LINK_STATUS);
+        linkForMostRecentNavigation = link;
+    });
+}
+function unmountLinkForCurrentNavigation(link) {
+    if (linkForMostRecentNavigation === link) {
+        linkForMostRecentNavigation = null;
+    }
+}
+// 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) {
+    try {
+        return (0, _approuter.createPrefetchURL)(href);
+    } catch (e) {
+        // 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;
+    }
+}
+function mountLinkInstance(element, href, router, kind, prefetchEnabled, setOptimisticLinkStatus) {
+    if (prefetchEnabled) {
+        const prefetchURL = coercePrefetchableUrl(href);
+        if (prefetchURL !== null) {
+            const instance = {
+                router,
+                kind,
+                isVisible: false,
+                wasHoveredOrTouched: false,
+                prefetchTask: null,
+                cacheVersion: -1,
+                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,
+        kind,
+        isVisible: false,
+        wasHoveredOrTouched: false,
+        prefetchTask: null,
+        cacheVersion: -1,
+        prefetchHref: null,
+        setOptimisticLinkStatus
+    };
+    return instance;
+}
+function mountFormInstance(element, href, router, kind) {
+    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,
+        kind,
+        isVisible: false,
+        wasHoveredOrTouched: false,
+        prefetchTask: null,
+        cacheVersion: -1,
+        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, _segmentcache.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);
+}
+function onNavigationIntent(element, unstable_upgradeToDynamicPrefetch) {
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    // Prefetch the link on hover/touchstart.
+    if (instance !== undefined) {
+        instance.wasHoveredOrTouched = true;
+        if (process.env.__NEXT_DYNAMIC_ON_HOVER && unstable_upgradeToDynamicPrefetch) {
+            // Switch to a full, dynamic prefetch
+            instance.kind = _routerreducertypes.PrefetchKind.FULL;
+        }
+        rescheduleLinkPrefetch(instance);
+    }
+}
+function rescheduleLinkPrefetch(instance) {
+    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, _segmentcache.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;
+    }
+    if (!process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
+        // The old prefetch implementation does not have different priority levels.
+        // Just schedule a new prefetch task.
+        prefetchWithOldCacheImplementation(instance);
+        return;
+    }
+    // In the Segment Cache implementation, we assign a higher priority level to
+    // links that were at one point hovered or touched. Since the queue is last-
+    // in-first-out, the highest priority Link is whichever one was hovered last.
+    //
+    // We also increase the relative priority of links whenever they re-enter the
+    // viewport, as if they were being scheduled for the first time.
+    const priority = instance.wasHoveredOrTouched ? _segmentcache.PrefetchPriority.Intent : _segmentcache.PrefetchPriority.Default;
+    const appRouterState = (0, _approuterinstance.getCurrentAppRouterState)();
+    if (appRouterState !== null) {
+        const treeAtTimeOfPrefetch = appRouterState.tree;
+        if (existingPrefetchTask === null) {
+            // Initiate a prefetch task.
+            const nextUrl = appRouterState.nextUrl;
+            const cacheKey = (0, _segmentcache.createCacheKey)(instance.prefetchHref, nextUrl);
+            instance.prefetchTask = (0, _segmentcache.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, instance.kind === _routerreducertypes.PrefetchKind.FULL, priority);
+        } 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, _segmentcache.reschedulePrefetchTask)(existingPrefetchTask, treeAtTimeOfPrefetch, instance.kind === _routerreducertypes.PrefetchKind.FULL, priority);
+        }
+        // Keep track of the cache version at the time the prefetch was requested.
+        // This is used to check if the prefetch is stale.
+        instance.cacheVersion = (0, _segmentcache.getCurrentCacheVersion)();
+    }
+}
+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.
+    const currentCacheVersion = (0, _segmentcache.getCurrentCacheVersion)();
+    for (const instance of prefetchableAndVisible){
+        const task = instance.prefetchTask;
+        if (task !== null && instance.cacheVersion === currentCacheVersion && task.key.nextUrl === nextUrl && task.treeAtTimeOfPrefetch === tree) {
+            continue;
+        }
+        // Something changed. Cancel the existing prefetch task and schedule a
+        // new one.
+        if (task !== null) {
+            (0, _segmentcache.cancelPrefetchTask)(task);
+        }
+        const cacheKey = (0, _segmentcache.createCacheKey)(instance.prefetchHref, nextUrl);
+        const priority = instance.wasHoveredOrTouched ? _segmentcache.PrefetchPriority.Intent : _segmentcache.PrefetchPriority.Default;
+        instance.prefetchTask = (0, _segmentcache.schedulePrefetchTask)(cacheKey, tree, instance.kind === _routerreducertypes.PrefetchKind.FULL, priority);
+        instance.cacheVersion = (0, _segmentcache.getCurrentCacheVersion)();
+    }
+}
+function prefetchWithOldCacheImplementation(instance) {
+    // This is the path used when the Segment Cache is not enabled.
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const doPrefetch = async ()=>{
+        // note that `appRouter.prefetch()` is currently sync,
+        // so we have to wrap this call in an async function to be able to catch() errors below.
+        return instance.router.prefetch(instance.prefetchHref, {
+            kind: instance.kind
+        });
+    };
+    // Prefetch the page if asked (only in the client)
+    // We need to handle a prefetch error here since we may be
+    // loading with priority which can reject but we don't
+    // want to force navigation since this is only a prefetch
+    doPrefetch().catch((err)=>{
+        if (process.env.NODE_ENV !== 'production') {
+            // rethrow to show invalid URL errors
+            throw err;
+        }
+    });
+}
+
+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/dist/standalone/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/dist/standalone/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

package/dist/standalone/node_modules/next/dist/client/components/navigation-untracked.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useUntrackedPathname", {
+    enumerable: true,
+    get: function() {
+        return useUntrackedPathname;
+    }
+});
+const _react = require("react");
+const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
+/**
+ * This checks to see if the current render has any unknown route parameters.
+ * It's used to trigger a different render path in the error boundary.
+ *
+ * @returns true if there are any unknown route parameters, false otherwise
+ */ function hasFallbackRouteParams() {
+    if (typeof window === 'undefined') {
+        // AsyncLocalStorage should not be included in the client bundle.
+        const { workAsyncStorage } = require('../../server/app-render/work-async-storage.external');
+        const workStore = workAsyncStorage.getStore();
+        if (!workStore) return false;
+        const { fallbackRouteParams } = workStore;
+        if (!fallbackRouteParams || fallbackRouteParams.size === 0) return false;
+        return true;
+    }
+    return false;
+}
+function useUntrackedPathname() {
+    // If there are any unknown route parameters we would typically throw
+    // an error, but this internal method allows us to return a null value instead
+    // for components that do not propagate the pathname to the static shell (like
+    // the error boundary).
+    if (hasFallbackRouteParams()) {
+        return null;
+    }
+    // This shouldn't cause any issues related to conditional rendering because
+    // the environment will be consistent for the render.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+}
+
+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=navigation-untracked.js.map

package/dist/standalone/node_modules/next/dist/client/components/navigation.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ReadonlyURLSearchParams: null,
+    RedirectType: null,
+    ServerInsertedHTMLContext: null,
+    forbidden: null,
+    notFound: null,
+    permanentRedirect: null,
+    redirect: null,
+    unauthorized: null,
+    unstable_rethrow: null,
+    useParams: null,
+    usePathname: null,
+    useRouter: null,
+    useSearchParams: null,
+    useSelectedLayoutSegment: null,
+    useSelectedLayoutSegments: null,
+    useServerInsertedHTML: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReadonlyURLSearchParams: function() {
+        return _navigationreactserver.ReadonlyURLSearchParams;
+    },
+    RedirectType: function() {
+        return _navigationreactserver.RedirectType;
+    },
+    ServerInsertedHTMLContext: function() {
+        return _serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext;
+    },
+    forbidden: function() {
+        return _navigationreactserver.forbidden;
+    },
+    notFound: function() {
+        return _navigationreactserver.notFound;
+    },
+    permanentRedirect: function() {
+        return _navigationreactserver.permanentRedirect;
+    },
+    redirect: function() {
+        return _navigationreactserver.redirect;
+    },
+    unauthorized: function() {
+        return _navigationreactserver.unauthorized;
+    },
+    unstable_rethrow: function() {
+        return _navigationreactserver.unstable_rethrow;
+    },
+    useParams: function() {
+        return useParams;
+    },
+    usePathname: function() {
+        return usePathname;
+    },
+    useRouter: function() {
+        return useRouter;
+    },
+    useSearchParams: function() {
+        return useSearchParams;
+    },
+    useSelectedLayoutSegment: function() {
+        return useSelectedLayoutSegment;
+    },
+    useSelectedLayoutSegments: function() {
+        return useSelectedLayoutSegments;
+    },
+    useServerInsertedHTML: function() {
+        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
+    }
+});
+const _react = require("react");
+const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
+const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
+const _getsegmentvalue = require("./router-reducer/reducers/get-segment-value");
+const _segment = require("../../shared/lib/segment");
+const _navigationreactserver = require("./navigation.react-server");
+const _serverinsertedhtmlsharedruntime = require("../../shared/lib/server-inserted-html.shared-runtime");
+const useDynamicRouteParams = typeof window === 'undefined' ? require('../../server/app-render/dynamic-rendering').useDynamicRouteParams : undefined;
+function useSearchParams() {
+    const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
+    // In the case where this is `null`, the compat types added in
+    // `next-env.d.ts` will add a new overload that changes the return type to
+    // include `null`.
+    const readonlySearchParams = (0, _react.useMemo)(()=>{
+        if (!searchParams) {
+            // When the router is not ready in pages, we won't have the search params
+            // available.
+            return null;
+        }
+        return new _navigationreactserver.ReadonlyURLSearchParams(searchParams);
+    }, [
+        searchParams
+    ]);
+    if (typeof window === 'undefined') {
+        // AsyncLocalStorage should not be included in the client bundle.
+        const { bailoutToClientRendering } = require('./bailout-to-client-rendering');
+        // TODO-APP: handle dynamic = 'force-static' here and on the client
+        bailoutToClientRendering('useSearchParams()');
+    }
+    return readonlySearchParams;
+}
+function usePathname() {
+    useDynamicRouteParams == null ? void 0 : useDynamicRouteParams('usePathname()');
+    // In the case where this is `null`, the compat types added in `next-env.d.ts`
+    // will add a new overload that changes the return type to include `null`.
+    return (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+}
+function useRouter() {
+    const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
+    if (router === null) {
+        throw Object.defineProperty(new Error('invariant expected app router to be mounted'), "__NEXT_ERROR_CODE", {
+            value: "E238",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return router;
+}
+function useParams() {
+    useDynamicRouteParams == null ? void 0 : useDynamicRouteParams('useParams()');
+    return (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
+}
+/** Get the canonical parameters from the current level to the leaf node. */ // Client components API
+function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first, segmentPath) {
+    if (first === void 0) first = true;
+    if (segmentPath === void 0) segmentPath = [];
+    let node;
+    if (first) {
+        // Use the provided parallel route key on the first parallel route
+        node = tree[1][parallelRouteKey];
+    } else {
+        // After first parallel route prefer children, if there's no children pick the first parallel route.
+        const parallelRoutes = tree[1];
+        var _parallelRoutes_children;
+        node = (_parallelRoutes_children = parallelRoutes.children) != null ? _parallelRoutes_children : Object.values(parallelRoutes)[0];
+    }
+    if (!node) return segmentPath;
+    const segment = node[0];
+    let segmentValue = (0, _getsegmentvalue.getSegmentValue)(segment);
+    if (!segmentValue || segmentValue.startsWith(_segment.PAGE_SEGMENT_KEY)) {
+        return segmentPath;
+    }
+    segmentPath.push(segmentValue);
+    return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+}
+function useSelectedLayoutSegments(parallelRouteKey) {
+    if (parallelRouteKey === void 0) parallelRouteKey = 'children';
+    useDynamicRouteParams == null ? void 0 : useDynamicRouteParams('useSelectedLayoutSegments()');
+    const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
+    // @ts-expect-error This only happens in `pages`. Type is overwritten in navigation.d.ts
+    if (!context) return null;
+    return getSelectedLayoutSegmentPath(context.parentTree, parallelRouteKey);
+}
+function useSelectedLayoutSegment(parallelRouteKey) {
+    if (parallelRouteKey === void 0) parallelRouteKey = 'children';
+    useDynamicRouteParams == null ? void 0 : useDynamicRouteParams('useSelectedLayoutSegment()');
+    const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
+    if (!selectedLayoutSegments || selectedLayoutSegments.length === 0) {
+        return null;
+    }
+    const selectedLayoutSegment = parallelRouteKey === 'children' ? selectedLayoutSegments[0] : selectedLayoutSegments[selectedLayoutSegments.length - 1];
+    // if the default slot is showing, we return null since it's not technically "selected" (it's a fallback)
+    // and returning an internal value like `__DEFAULT__` would be confusing.
+    return selectedLayoutSegment === _segment.DEFAULT_SEGMENT_KEY ? null : selectedLayoutSegment;
+}
+
+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=navigation.js.map