@amoa/casting 0.1.3 → 0.1.4

package/dist/node_modules/next/dist/client/add-base-path.js

@@ -0,0 +1,38 @@
+import { __module as addBasePath } from '../../../../_virtual/add-base-path.js';
+import { __require as requireAddPathPrefix } from '../shared/lib/router/utils/add-path-prefix.js';
+import { __require as requireNormalizeTrailingSlash } from './normalize-trailing-slash.js';
+
+var hasRequiredAddBasePath;
+
+function requireAddBasePath () {
+	if (hasRequiredAddBasePath) return addBasePath.exports;
+	hasRequiredAddBasePath = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "addBasePath", {
+		  enumerable: true,
+		  get: function () {
+		    return addBasePath;
+		  }
+		});
+		const _addpathprefix = requireAddPathPrefix();
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function addBasePath(path, required) {
+		  return (0, _normalizetrailingslash.normalizePathTrailingSlash)(process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required ? path : (0, _addpathprefix.addPathPrefix)(path, basePath));
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (addBasePath, addBasePath.exports));
+	return addBasePath.exports;
+}
+
+export { requireAddBasePath as __require };

package/dist/node_modules/next/dist/client/add-locale.js

@@ -0,0 +1,39 @@
+import { __module as addLocale } from '../../../../_virtual/add-locale.js';
+import { __require as requireNormalizeTrailingSlash } from './normalize-trailing-slash.js';
+import { __require as requireAddLocale$1 } from '../shared/lib/router/utils/add-locale.js';
+
+var hasRequiredAddLocale;
+
+function requireAddLocale () {
+	if (hasRequiredAddLocale) return addLocale.exports;
+	hasRequiredAddLocale = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "addLocale", {
+		  enumerable: true,
+		  get: function () {
+		    return addLocale;
+		  }
+		});
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const addLocale = (path, ...args) => {
+		  if (process.env.__NEXT_I18N_SUPPORT) {
+		    return (0, _normalizetrailingslash.normalizePathTrailingSlash)(requireAddLocale$1().addLocale(path, ...args));
+		  }
+		  return path;
+		};
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (addLocale, addLocale.exports));
+	return addLocale.exports;
+}
+
+export { requireAddLocale as __require };

package/dist/node_modules/next/dist/client/components/app-router-headers.js

@@ -0,0 +1,112 @@
+import { __module as appRouterHeaders } from '../../../../../_virtual/app-router-headers.js';
+
+var hasRequiredAppRouterHeaders;
+
+function requireAppRouterHeaders () {
+	if (hasRequiredAppRouterHeaders) return appRouterHeaders.exports;
+	hasRequiredAppRouterHeaders = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		function _export(target, all) {
+		  for (var name in all) Object.defineProperty(target, name, {
+		    enumerable: true,
+		    get: all[name]
+		  });
+		}
+		_export(exports$1, {
+		  ACTION_HEADER: function () {
+		    return ACTION_HEADER;
+		  },
+		  FLIGHT_HEADERS: function () {
+		    return FLIGHT_HEADERS;
+		  },
+		  NEXT_ACTION_NOT_FOUND_HEADER: function () {
+		    return NEXT_ACTION_NOT_FOUND_HEADER;
+		  },
+		  NEXT_ACTION_REVALIDATED_HEADER: function () {
+		    return NEXT_ACTION_REVALIDATED_HEADER;
+		  },
+		  NEXT_DID_POSTPONE_HEADER: function () {
+		    return NEXT_DID_POSTPONE_HEADER;
+		  },
+		  NEXT_HMR_REFRESH_HASH_COOKIE: function () {
+		    return NEXT_HMR_REFRESH_HASH_COOKIE;
+		  },
+		  NEXT_HMR_REFRESH_HEADER: function () {
+		    return NEXT_HMR_REFRESH_HEADER;
+		  },
+		  NEXT_HTML_REQUEST_ID_HEADER: function () {
+		    return NEXT_HTML_REQUEST_ID_HEADER;
+		  },
+		  NEXT_IS_PRERENDER_HEADER: function () {
+		    return NEXT_IS_PRERENDER_HEADER;
+		  },
+		  NEXT_REQUEST_ID_HEADER: function () {
+		    return NEXT_REQUEST_ID_HEADER;
+		  },
+		  NEXT_REWRITTEN_PATH_HEADER: function () {
+		    return NEXT_REWRITTEN_PATH_HEADER;
+		  },
+		  NEXT_REWRITTEN_QUERY_HEADER: function () {
+		    return NEXT_REWRITTEN_QUERY_HEADER;
+		  },
+		  NEXT_ROUTER_PREFETCH_HEADER: function () {
+		    return NEXT_ROUTER_PREFETCH_HEADER;
+		  },
+		  NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: function () {
+		    return NEXT_ROUTER_SEGMENT_PREFETCH_HEADER;
+		  },
+		  NEXT_ROUTER_STALE_TIME_HEADER: function () {
+		    return NEXT_ROUTER_STALE_TIME_HEADER;
+		  },
+		  NEXT_ROUTER_STATE_TREE_HEADER: function () {
+		    return NEXT_ROUTER_STATE_TREE_HEADER;
+		  },
+		  NEXT_RSC_UNION_QUERY: function () {
+		    return NEXT_RSC_UNION_QUERY;
+		  },
+		  NEXT_URL: function () {
+		    return NEXT_URL;
+		  },
+		  RSC_CONTENT_TYPE_HEADER: function () {
+		    return RSC_CONTENT_TYPE_HEADER;
+		  },
+		  RSC_HEADER: function () {
+		    return RSC_HEADER;
+		  }
+		});
+		const RSC_HEADER = 'rsc';
+		const ACTION_HEADER = 'next-action';
+		const NEXT_ROUTER_STATE_TREE_HEADER = 'next-router-state-tree';
+		const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch';
+		const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch';
+		const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh';
+		const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
+		const NEXT_URL = 'next-url';
+		const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
+		const FLIGHT_HEADERS = [RSC_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_HMR_REFRESH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER];
+		const NEXT_RSC_UNION_QUERY = '_rsc';
+		const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time';
+		const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed';
+		const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path';
+		const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query';
+		const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender';
+		const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found';
+		const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id';
+		const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id';
+		const NEXT_ACTION_REVALIDATED_HEADER = 'x-action-revalidated';
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (appRouterHeaders, appRouterHeaders.exports));
+	return appRouterHeaders.exports;
+}
+
+export { requireAppRouterHeaders as __require };

package/dist/node_modules/next/dist/client/components/forbidden.js

@@ -0,0 +1,62 @@
+import { __module as forbidden } from '../../../../../_virtual/forbidden.js';
+import { __require as requireHttpAccessFallback } from './http-access-fallback/http-access-fallback.js';
+
+var hasRequiredForbidden;
+
+function requireForbidden () {
+	if (hasRequiredForbidden) return forbidden.exports;
+	hasRequiredForbidden = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "forbidden", {
+		  enumerable: true,
+		  get: function () {
+		    return forbidden;
+		  }
+		});
+		const _httpaccessfallback = requireHttpAccessFallback();
+		// TODO: Add `forbidden` docs
+		/**
+		 * @experimental
+		 * This function allows you to render the [forbidden.js file](https://nextjs.org/docs/app/api-reference/file-conventions/forbidden)
+		 * within a route segment as well as inject a tag.
+		 *
+		 * `forbidden()` can be used in
+		 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
+		 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
+		 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
+		 *
+		 * Read more: [Next.js Docs: `forbidden`](https://nextjs.org/docs/app/api-reference/functions/forbidden)
+		 */
+		const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};403`;
+		function forbidden() {
+		  if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
+		    throw Object.defineProperty(new Error(`\`forbidden()\` is experimental and only allowed to be enabled when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
+		      value: "E488",
+		      enumerable: false,
+		      configurable: true
+		    });
+		  }
+		  const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+		    value: "E394",
+		    enumerable: false,
+		    configurable: true
+		  });
+		  error.digest = DIGEST;
+		  throw error;
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (forbidden, forbidden.exports));
+	return forbidden.exports;
+}
+
+export { requireForbidden as __require };

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

@@ -0,0 +1,50 @@
+import { __module as hooksServerContext } from '../../../../../_virtual/hooks-server-context.js';
+
+var hasRequiredHooksServerContext;
+
+function requireHooksServerContext () {
+	if (hasRequiredHooksServerContext) return hooksServerContext.exports;
+	hasRequiredHooksServerContext = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		function _export(target, all) {
+		  for (var name in all) Object.defineProperty(target, name, {
+		    enumerable: true,
+		    get: all[name]
+		  });
+		}
+		_export(exports$1, {
+		  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$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (hooksServerContext, hooksServerContext.exports));
+	return hooksServerContext.exports;
+}
+
+export { requireHooksServerContext as __require };

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

@@ -0,0 +1,77 @@
+import { __module as httpAccessFallback } from '../../../../../../_virtual/http-access-fallback.js';
+
+var hasRequiredHttpAccessFallback;
+
+function requireHttpAccessFallback () {
+	if (hasRequiredHttpAccessFallback) return httpAccessFallback.exports;
+	hasRequiredHttpAccessFallback = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		function _export(target, all) {
+		  for (var name in all) Object.defineProperty(target, name, {
+		    enumerable: true,
+		    get: all[name]
+		  });
+		}
+		_export(exports$1, {
+		  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$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (httpAccessFallback, httpAccessFallback.exports));
+	return httpAccessFallback.exports;
+}
+
+export { requireHttpAccessFallback as __require };

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

@@ -0,0 +1,37 @@
+import { __module as isNextRouterError } from '../../../../../_virtual/is-next-router-error.js';
+import { __require as requireHttpAccessFallback } from './http-access-fallback/http-access-fallback.js';
+import { __require as requireRedirectError } from './redirect-error.js';
+
+var hasRequiredIsNextRouterError;
+
+function requireIsNextRouterError () {
+	if (hasRequiredIsNextRouterError) return isNextRouterError.exports;
+	hasRequiredIsNextRouterError = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "isNextRouterError", {
+		  enumerable: true,
+		  get: function () {
+		    return isNextRouterError;
+		  }
+		});
+		const _httpaccessfallback = requireHttpAccessFallback();
+		const _redirecterror = requireRedirectError();
+		function isNextRouterError(error) {
+		  return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error);
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (isNextRouterError, isNextRouterError.exports));
+	return isNextRouterError.exports;
+}
+
+export { requireIsNextRouterError as __require };

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

@@ -0,0 +1,198 @@
+import { __module as navigation } from '../../../../../_virtual/navigation2.js';
+import { __require as require_interop_require_wildcard } from '../../../../@swc/helpers/cjs/_interop_require_wildcard.js';
+import React__default from 'react';
+import { __require as requireAppRouterContext_sharedRuntime } from '../../shared/lib/app-router-context.shared-runtime.js';
+import { __require as requireHooksClientContext_sharedRuntime } from '../../shared/lib/hooks-client-context.shared-runtime.js';
+import { __require as requireSegment } from '../../shared/lib/segment.js';
+import { __require as requireServerInsertedHtml_sharedRuntime } from '../../shared/lib/server-inserted-html.shared-runtime.js';
+import { __require as requireUnrecognizedActionError } from './unrecognized-action-error.js';
+import { __require as requireNavigation_reactServer } from './navigation.react-server.js';
+import { __require as requireDynamicRendering } from '../../server/app-render/dynamic-rendering.js';
+
+var hasRequiredNavigation;
+
+function requireNavigation () {
+	if (hasRequiredNavigation) return navigation.exports;
+	hasRequiredNavigation = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		function _export(target, all) {
+		  for (var name in all) Object.defineProperty(target, name, {
+		    enumerable: true,
+		    get: all[name]
+		  });
+		}
+		_export(exports$1, {
+		  // We need the same class that was used to instantiate the context value
+		  // Otherwise instanceof checks will fail in usercode
+		  ReadonlyURLSearchParams: function () {
+		    return _hooksclientcontextsharedruntime.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_isUnrecognizedActionError: function () {
+		    return _unrecognizedactionerror.unstable_isUnrecognizedActionError;
+		  },
+		  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 _interop_require_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _react = /*#__PURE__*/_interop_require_wildcard._(React__default);
+		const _approutercontextsharedruntime = requireAppRouterContext_sharedRuntime();
+		const _hooksclientcontextsharedruntime = requireHooksClientContext_sharedRuntime();
+		const _segment = requireSegment();
+		const _serverinsertedhtmlsharedruntime = requireServerInsertedHtml_sharedRuntime();
+		const _unrecognizedactionerror = requireUnrecognizedActionError();
+		const _navigationreactserver = requireNavigation_reactServer();
+		const useDynamicRouteParams = typeof window === 'undefined' ? requireDynamicRendering().useDynamicRouteParams : undefined;
+		const useDynamicSearchParams = typeof window === 'undefined' ? requireDynamicRendering().useDynamicSearchParams : undefined;
+		function useSearchParams() {
+		  useDynamicSearchParams?.('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 _hooksclientcontextsharedruntime.ReadonlyURLSearchParams(searchParams);
+		  }, [searchParams]);
+		  // Instrument with Suspense DevTools (dev-only)
+		  if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
+		    const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+		    if (navigationPromises) {
+		      return (0, _react.use)(navigationPromises.searchParams);
+		    }
+		  }
+		  return readonlySearchParams;
+		}
+		function usePathname() {
+		  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`.
+		  const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+		  // Instrument with Suspense DevTools (dev-only)
+		  if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
+		    const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+		    if (navigationPromises) {
+		      return (0, _react.use)(navigationPromises.pathname);
+		    }
+		  }
+		  return pathname;
+		}
+		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?.('useParams()');
+		  const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
+		  // Instrument with Suspense DevTools (dev-only)
+		  if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
+		    const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+		    if (navigationPromises) {
+		      return (0, _react.use)(navigationPromises.params);
+		    }
+		  }
+		  return params;
+		}
+		function useSelectedLayoutSegments(parallelRouteKey = 'children') {
+		  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;
+		  // Instrument with Suspense DevTools (dev-only)
+		  if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
+		    const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+		    if (navigationPromises) {
+		      const promise = navigationPromises.selectedLayoutSegmentsPromises?.get(parallelRouteKey);
+		      if (promise) {
+		        // We should always have a promise here, but if we don't, it's not worth erroring over.
+		        // We just won't be able to instrument it, but can still provide the value.
+		        return (0, _react.use)(promise);
+		      }
+		    }
+		  }
+		  return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
+		}
+		function useSelectedLayoutSegment(parallelRouteKey = 'children') {
+		  useDynamicRouteParams?.('useSelectedLayoutSegment()');
+		  const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+		  const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
+		  // Instrument with Suspense DevTools (dev-only)
+		  if (process.env.NODE_ENV !== 'production' && navigationPromises && 'use' in _react.default) {
+		    const promise = navigationPromises.selectedLayoutSegmentPromises?.get(parallelRouteKey);
+		    if (promise) {
+		      // We should always have a promise here, but if we don't, it's not worth erroring over.
+		      // We just won't be able to instrument it, but can still provide the value.
+		      return (0, _react.use)(promise);
+		    }
+		  }
+		  return (0, _segment.computeSelectedLayoutSegment)(selectedLayoutSegments, parallelRouteKey);
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (navigation, navigation.exports));
+	return navigation.exports;
+}
+
+export { requireNavigation as __require };