Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/react-router-dom/dist/umd/react-router-dom.development.js
f646e1f695a7paginated-inlines

react-router-dom.development.js
View Options

			/**
			* React Router DOM v6.6.1
			*
			* Copyright (c) Remix Software Inc.
			*
			* This source code is licensed under the MIT license found in the
			* LICENSE.md file in the root directory of this source tree.
			*
			* @license MIT
			*/
			(function (global, factory) {
			typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-router'), require('@remix-run/router')) :
			typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-router', '@remix-run/router'], factory) :
			(global = typeof globalThis !== 'undefined' ? globalThis : global \|\| self, factory(global.ReactRouterDOM = {}, global.React, global.ReactRouter, global.RemixRouter));
			})(this, (function (exports, React, reactRouter, router) { 'use strict';

			function _interopNamespace(e) {
			if (e && e.__esModule) return e;
			var n = Object.create(null);
			if (e) {
			Object.keys(e).forEach(function (k) {
			if (k !== 'default') {
			var d = Object.getOwnPropertyDescriptor(e, k);
			Object.defineProperty(n, k, d.get ? d : {
			enumerable: true,
			get: function () { return e[k]; }
			});
			}
			});
			}
			n["default"] = e;
			return Object.freeze(n);
			}

			var React__namespace = /#__PURE__/_interopNamespace(React);

			function _extends() {
			_extends = Object.assign ? Object.assign.bind() : function (target) {
			for (var i = 1; i < arguments.length; i++) {
			var source = arguments[i];

			for (var key in source) {
			if (Object.prototype.hasOwnProperty.call(source, key)) {
			target[key] = source[key];
			}
			}
			}

			return target;
			};
			return _extends.apply(this, arguments);
			}

			function _objectWithoutPropertiesLoose(source, excluded) {
			if (source == null) return {};
			var target = {};
			var sourceKeys = Object.keys(source);
			var key, i;

			for (i = 0; i < sourceKeys.length; i++) {
			key = sourceKeys[i];
			if (excluded.indexOf(key) >= 0) continue;
			target[key] = source[key];
			}

			return target;
			}

			const defaultMethod = "get";
			const defaultEncType = "application/x-www-form-urlencoded";
			function isHtmlElement(object) {
			return object != null && typeof object.tagName === "string";
			}
			function isButtonElement(object) {
			return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
			}
			function isFormElement(object) {
			return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
			}
			function isInputElement(object) {
			return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
			}

			function isModifiedEvent(event) {
			return !!(event.metaKey \|\| event.altKey \|\| event.ctrlKey \|\| event.shiftKey);
			}

			function shouldProcessLinkClick(event, target) {
			return event.button === 0 && ( // Ignore everything but left clicks
			!target \|\| target === "_self") && // Let browser handle "target=_blank" etc.
			!isModifiedEvent(event) // Ignore clicks with modifier keys
			;
			}

			/**
			* Creates a URLSearchParams object using the given initializer.
			*
			* This is identical to `new URLSearchParams(init)` except it also
			* supports arrays as values in the object form of the initializer
			* instead of just strings. This is convenient when you need multiple
			* values for a given key, but don't want to use an array initializer.
			*
			* For example, instead of:
			*
			* let searchParams = new URLSearchParams([
			* ['sort', 'name'],
			* ['sort', 'price']
			* ]);
			*
			* you can do:
			*
			* let searchParams = createSearchParams({
			* sort: ['name', 'price']
			* });
			*/
			function createSearchParams(init) {
			if (init === void 0) {
			init = "";
			}

			return new URLSearchParams(typeof init === "string" \|\| Array.isArray(init) \|\| init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
			let value = init[key];
			return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);
			}, []));
			}
			function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
			let searchParams = createSearchParams(locationSearch);

			for (let key of defaultSearchParams.keys()) {
			if (!searchParams.has(key)) {
			defaultSearchParams.getAll(key).forEach(value => {
			searchParams.append(key, value);
			});
			}
			}

			return searchParams;
			}
			function getFormSubmissionInfo(target, defaultAction, options) {
			let method;
			let action;
			let encType;
			let formData;

			if (isFormElement(target)) {
			let submissionTrigger = options.submissionTrigger;
			method = options.method \|\| target.getAttribute("method") \|\| defaultMethod;
			action = options.action \|\| target.getAttribute("action") \|\| defaultAction;
			encType = options.encType \|\| target.getAttribute("enctype") \|\| defaultEncType;
			formData = new FormData(target);

			if (submissionTrigger && submissionTrigger.name) {
			formData.append(submissionTrigger.name, submissionTrigger.value);
			}
			} else if (isButtonElement(target) \|\| isInputElement(target) && (target.type === "submit" \|\| target.type === "image")) {
			let form = target.form;

			if (form == null) {
			throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>");
			} // <button>/<input type="submit"> may override attributes of <form>


			method = options.method \|\| target.getAttribute("formmethod") \|\| form.getAttribute("method") \|\| defaultMethod;
			action = options.action \|\| target.getAttribute("formaction") \|\| form.getAttribute("action") \|\| defaultAction;
			encType = options.encType \|\| target.getAttribute("formenctype") \|\| form.getAttribute("enctype") \|\| defaultEncType;
			formData = new FormData(form); // Include name + value from a <button>, appending in case the button name
			// matches an existing input name

			if (target.name) {
			formData.append(target.name, target.value);
			}
			} else if (isHtmlElement(target)) {
			throw new Error("Cannot submit element that is not <form>, <button>, or " + "<input type=\"submit\|image\">");
			} else {
			method = options.method \|\| defaultMethod;
			action = options.action \|\| defaultAction;
			encType = options.encType \|\| defaultEncType;

			if (target instanceof FormData) {
			formData = target;
			} else {
			formData = new FormData();

			if (target instanceof URLSearchParams) {
			for (let [name, value] of target) {
			formData.append(name, value);
			}
			} else if (target != null) {
			for (let name of Object.keys(target)) {
			formData.append(name, target[name]);
			}
			}
			}
			}

			let {
			protocol,
			host
			} = window.location;
			let url = new URL(action, protocol + "//" + host);
			return {
			url,
			method: method.toLowerCase(),
			encType,
			formData
			};
			}

			const _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset"],
			_excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "children"],
			_excluded3 = ["reloadDocument", "replace", "method", "action", "onSubmit", "fetcherKey", "routeId", "relative"];

			////////////////////////////////////////////////////////////////////////////////
			//#region Routers
			////////////////////////////////////////////////////////////////////////////////
			function createBrowserRouter(routes, opts) {
			return router.createRouter({
			basename: opts == null ? void 0 : opts.basename,
			history: router.createBrowserHistory({
			window: opts == null ? void 0 : opts.window
			}),
			hydrationData: (opts == null ? void 0 : opts.hydrationData) \|\| parseHydrationData(),
			routes: reactRouter.UNSAFE_enhanceManualRouteObjects(routes)
			}).initialize();
			}
			function createHashRouter(routes, opts) {
			return router.createRouter({
			basename: opts == null ? void 0 : opts.basename,
			history: router.createHashHistory({
			window: opts == null ? void 0 : opts.window
			}),
			hydrationData: (opts == null ? void 0 : opts.hydrationData) \|\| parseHydrationData(),
			routes: reactRouter.UNSAFE_enhanceManualRouteObjects(routes)
			}).initialize();
			}

			function parseHydrationData() {
			var _window;

			let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;

			if (state && state.errors) {
			state = _extends({}, state, {
			errors: deserializeErrors(state.errors)
			});
			}

			return state;
			}

			function deserializeErrors(errors) {
			if (!errors) return null;
			let entries = Object.entries(errors);
			let serialized = {};

			for (let [key, val] of entries) {
			// Hey you! If you change this, please change the corresponding logic in
			// serializeErrors in react-router-dom/server.tsx :)
			if (val && val.__type === "RouteErrorResponse") {
			serialized[key] = new router.ErrorResponse(val.status, val.statusText, val.data, val.internal === true);
			} else if (val && val.__type === "Error") {
			let error = new Error(val.message); // Wipe away the client-side stack trace. Nothing to fill it in with
			// because we don't serialize SSR stack traces for security reasons

			error.stack = "";
			serialized[key] = error;
			} else {
			serialized[key] = val;
			}
			}

			return serialized;
			} //#endregion
			////////////////////////////////////////////////////////////////////////////////
			//#region Components
			////////////////////////////////////////////////////////////////////////////////


			/**
			* A `<Router>` for use in web browsers. Provides the cleanest URLs.
			*/
			function BrowserRouter(_ref) {
			let {
			basename,
			children,
			window
			} = _ref;
			let historyRef = React__namespace.useRef();

			if (historyRef.current == null) {
			historyRef.current = router.createBrowserHistory({
			window,
			v5Compat: true
			});
			}

			let history = historyRef.current;
			let [state, setState] = React__namespace.useState({
			action: history.action,
			location: history.location
			});
			React__namespace.useLayoutEffect(() => history.listen(setState), [history]);
			return /#__PURE__/React__namespace.createElement(reactRouter.Router, {
			basename: basename,
			children: children,
			location: state.location,
			navigationType: state.action,
			navigator: history
			});
			}

			/**
			* A `<Router>` for use in web browsers. Stores the location in the hash
			* portion of the URL so it is not sent to the server.
			*/
			function HashRouter(_ref2) {
			let {
			basename,
			children,
			window
			} = _ref2;
			let historyRef = React__namespace.useRef();

			if (historyRef.current == null) {
			historyRef.current = router.createHashHistory({
			window,
			v5Compat: true
			});
			}

			let history = historyRef.current;
			let [state, setState] = React__namespace.useState({
			action: history.action,
			location: history.location
			});
			React__namespace.useLayoutEffect(() => history.listen(setState), [history]);
			return /#__PURE__/React__namespace.createElement(reactRouter.Router, {
			basename: basename,
			children: children,
			location: state.location,
			navigationType: state.action,
			navigator: history
			});
			}

			/**
			* A `<Router>` that accepts a pre-instantiated history object. It's important
			* to note that using your own history object is highly discouraged and may add
			* two versions of the history library to your bundles unless you use the same
			* version of the history library that React Router uses internally.
			*/
			function HistoryRouter(_ref3) {
			let {
			basename,
			children,
			history
			} = _ref3;
			const [state, setState] = React__namespace.useState({
			action: history.action,
			location: history.location
			});
			React__namespace.useLayoutEffect(() => history.listen(setState), [history]);
			return /#__PURE__/React__namespace.createElement(reactRouter.Router, {
			basename: basename,
			children: children,
			location: state.location,
			navigationType: state.action,
			navigator: history
			});
			}

			{
			HistoryRouter.displayName = "unstable_HistoryRouter";
			}

			/**
			* The public API for rendering a history-aware <a>.
			*/
			const Link = /#__PURE__/React__namespace.forwardRef(function LinkWithRef(_ref4, ref) {
			let {
			onClick,
			relative,
			reloadDocument,
			replace,
			state,
			target,
			to,
			preventScrollReset
			} = _ref4,
			rest = _objectWithoutPropertiesLoose(_ref4, _excluded);

			let href = reactRouter.useHref(to, {
			relative
			});
			let internalOnClick = useLinkClickHandler(to, {
			replace,
			state,
			target,
			preventScrollReset,
			relative
			});

			function handleClick(event) {
			if (onClick) onClick(event);

			if (!event.defaultPrevented) {
			internalOnClick(event);
			}
			}

			return (
			/#__PURE__/
			// eslint-disable-next-line jsx-a11y/anchor-has-content
			React__namespace.createElement("a", _extends({}, rest, {
			href: href,
			onClick: reloadDocument ? onClick : handleClick,
			ref: ref,
			target: target
			}))
			);
			});

			{
			Link.displayName = "Link";
			}

			/**
			* A <Link> wrapper that knows if it's "active" or not.
			*/
			const NavLink = /#__PURE__/React__namespace.forwardRef(function NavLinkWithRef(_ref5, ref) {
			let {
			"aria-current": ariaCurrentProp = "page",
			caseSensitive = false,
			className: classNameProp = "",
			end = false,
			style: styleProp,
			to,
			children
			} = _ref5,
			rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);

			let path = reactRouter.useResolvedPath(to, {
			relative: rest.relative
			});
			let location = reactRouter.useLocation();
			let routerState = React__namespace.useContext(reactRouter.UNSAFE_DataRouterStateContext);
			let {
			navigator
			} = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
			let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
			let locationPathname = location.pathname;
			let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;

			if (!caseSensitive) {
			locationPathname = locationPathname.toLowerCase();
			nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
			toPathname = toPathname.toLowerCase();
			}

			let isActive = locationPathname === toPathname \|\| !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/";
			let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname \|\| !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/");
			let ariaCurrent = isActive ? ariaCurrentProp : undefined;
			let className;

			if (typeof classNameProp === "function") {
			className = classNameProp({
			isActive,
			isPending
			});
			} else {
			// If the className prop is not a function, we use a default `active`
			// class for <NavLink />s that are active. In v5 `active` was the default
			// value for `activeClassName`, but we are removing that API and can still
			// use the old default behavior for a cleaner upgrade path and keep the
			// simple styling rules working as they currently do.
			className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null].filter(Boolean).join(" ");
			}

			let style = typeof styleProp === "function" ? styleProp({
			isActive,
			isPending
			}) : styleProp;
			return /#__PURE__/React__namespace.createElement(Link, _extends({}, rest, {
			"aria-current": ariaCurrent,
			className: className,
			ref: ref,
			style: style,
			to: to
			}), typeof children === "function" ? children({
			isActive,
			isPending
			}) : children);
			});

			{
			NavLink.displayName = "NavLink";
			}

			/**
			* A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
			* that the interaction with the server is with `fetch` instead of new document
			* requests, allowing components to add nicer UX to the page as the form is
			* submitted and returns with data.
			*/
			const Form = /#__PURE__/React__namespace.forwardRef((props, ref) => {
			return /#__PURE__/React__namespace.createElement(FormImpl, _extends({}, props, {
			ref: ref
			}));
			});

			{
			Form.displayName = "Form";
			}

			const FormImpl = /#__PURE__/React__namespace.forwardRef((_ref6, forwardedRef) => {
			let {
			reloadDocument,
			replace,
			method = defaultMethod,
			action,
			onSubmit,
			fetcherKey,
			routeId,
			relative
			} = _ref6,
			props = _objectWithoutPropertiesLoose(_ref6, _excluded3);

			let submit = useSubmitImpl(fetcherKey, routeId);
			let formMethod = method.toLowerCase() === "get" ? "get" : "post";
			let formAction = useFormAction(action, {
			relative
			});

			let submitHandler = event => {
			onSubmit && onSubmit(event);
			if (event.defaultPrevented) return;
			event.preventDefault();
			let submitter = event.nativeEvent.submitter;
			let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) \|\| method;
			submit(submitter \|\| event.currentTarget, {
			method: submitMethod,
			replace,
			relative
			});
			};

			return /#__PURE__/React__namespace.createElement("form", _extends({
			ref: forwardedRef,
			method: formMethod,
			action: formAction,
			onSubmit: reloadDocument ? onSubmit : submitHandler
			}, props));
			});

			{
			FormImpl.displayName = "FormImpl";
			}

			/**
			* This component will emulate the browser's scroll restoration on location
			* changes.
			*/
			function ScrollRestoration(_ref7) {
			let {
			getKey,
			storageKey
			} = _ref7;
			useScrollRestoration({
			getKey,
			storageKey
			});
			return null;
			}

			{
			ScrollRestoration.displayName = "ScrollRestoration";
			} //#endregion
			////////////////////////////////////////////////////////////////////////////////
			//#region Hooks
			////////////////////////////////////////////////////////////////////////////////


			var DataRouterHook;

			(function (DataRouterHook) {
			DataRouterHook["UseScrollRestoration"] = "useScrollRestoration";
			DataRouterHook["UseSubmitImpl"] = "useSubmitImpl";
			DataRouterHook["UseFetcher"] = "useFetcher";
			})(DataRouterHook \|\| (DataRouterHook = {}));

			var DataRouterStateHook;

			(function (DataRouterStateHook) {
			DataRouterStateHook["UseFetchers"] = "useFetchers";
			DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration";
			})(DataRouterStateHook \|\| (DataRouterStateHook = {}));

			function getDataRouterConsoleError(hookName) {
			return hookName + " must be used within a data router. See https://reactrouter.com/routers/picking-a-router.";
			}

			function useDataRouterContext(hookName) {
			let ctx = React__namespace.useContext(reactRouter.UNSAFE_DataRouterContext);
			!ctx ? router.invariant(false, getDataRouterConsoleError(hookName)) : void 0;
			return ctx;
			}

			function useDataRouterState(hookName) {
			let state = React__namespace.useContext(reactRouter.UNSAFE_DataRouterStateContext);
			!state ? router.invariant(false, getDataRouterConsoleError(hookName)) : void 0;
			return state;
			}
			/**
			* Handles the click behavior for router `<Link>` components. This is useful if
			* you need to create custom `<Link>` components with the same click behavior we
			* use in our exported `<Link>`.
			*/


			function useLinkClickHandler(to, _temp) {
			let {
			target,
			replace: replaceProp,
			state,
			preventScrollReset,
			relative
			} = _temp === void 0 ? {} : _temp;
			let navigate = reactRouter.useNavigate();
			let location = reactRouter.useLocation();
			let path = reactRouter.useResolvedPath(to, {
			relative
			});
			return React__namespace.useCallback(event => {
			if (shouldProcessLinkClick(event, target)) {
			event.preventDefault(); // If the URL hasn't changed, a regular <a> will do a replace instead of
			// a push, so do the same here unless the replace prop is explicitly set

			let replace = replaceProp !== undefined ? replaceProp : reactRouter.createPath(location) === reactRouter.createPath(path);
			navigate(to, {
			replace,
			state,
			preventScrollReset,
			relative
			});
			}
			}, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);
			}
			/**
			* A convenient wrapper for reading and writing search parameters via the
			* URLSearchParams interface.
			*/

			function useSearchParams(defaultInit) {
			warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not " + "support the URLSearchParams API. If you need to support Internet " + "Explorer 11, we recommend you load a polyfill such as " + "https://github.com/ungap/url-search-params\n\n" + "If you're unsure how to load polyfills, we recommend you check out " + "https://polyfill.io/v3/ which provides some recommendations about how " + "to load polyfills only for users that need them, instead of for every " + "user.") ;
			let defaultSearchParamsRef = React__namespace.useRef(createSearchParams(defaultInit));
			let location = reactRouter.useLocation();
			let searchParams = React__namespace.useMemo(() => getSearchParamsForLocation(location.search, defaultSearchParamsRef.current), [location.search]);
			let navigate = reactRouter.useNavigate();
			let setSearchParams = React__namespace.useCallback((nextInit, navigateOptions) => {
			const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit);
			navigate("?" + newSearchParams, navigateOptions);
			}, [navigate, searchParams]);
			return [searchParams, setSearchParams];
			}

			/**
			* Returns a function that may be used to programmatically submit a form (or
			* some arbitrary data) to the server.
			*/
			function useSubmit() {
			return useSubmitImpl();
			}

			function useSubmitImpl(fetcherKey, routeId) {
			let {
			router: router$1
			} = useDataRouterContext(DataRouterHook.UseSubmitImpl);
			let defaultAction = useFormAction();
			return React__namespace.useCallback(function (target, options) {
			if (options === void 0) {
			options = {};
			}

			if (typeof document === "undefined") {
			throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead.");
			}

			let {
			method,
			encType,
			formData,
			url
			} = getFormSubmissionInfo(target, defaultAction, options);
			let href = url.pathname + url.search;
			let opts = {
			replace: options.replace,
			formData,
			formMethod: method,
			formEncType: encType
			};

			if (fetcherKey) {
			!(routeId != null) ? router.invariant(false, "No routeId available for useFetcher()") : void 0;
			router$1.fetch(fetcherKey, routeId, href, opts);
			} else {
			router$1.navigate(href, opts);
			}
			}, [defaultAction, router$1, fetcherKey, routeId]);
			}

			function useFormAction(action, _temp2) {
			let {
			relative
			} = _temp2 === void 0 ? {} : _temp2;
			let {
			basename
			} = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
			let routeContext = React__namespace.useContext(reactRouter.UNSAFE_RouteContext);
			!routeContext ? router.invariant(false, "useFormAction must be used inside a RouteContext") : void 0;
			let [match] = routeContext.matches.slice(-1); // Shallow clone path so we can modify it below, otherwise we modify the
			// object referenced by useMemo inside useResolvedPath

			let path = _extends({}, reactRouter.useResolvedPath(action ? action : ".", {
			relative
			})); // Previously we set the default action to ".". The problem with this is that
			// `useResolvedPath(".")` excludes search params and the hash of the resolved
			// URL. This is the intended behavior of when "." is specifically provided as
			// the form action, but inconsistent w/ browsers when the action is omitted.
			// https://github.com/remix-run/remix/issues/927


			let location = reactRouter.useLocation();

			if (action == null) {
			// Safe to write to these directly here since if action was undefined, we
			// would have called useResolvedPath(".") which will never include a search
			// or hash
			path.search = location.search;
			path.hash = location.hash; // When grabbing search params from the URL, remove the automatically
			// inserted ?index param so we match the useResolvedPath search behavior
			// which would not include ?index

			if (match.route.index) {
			let params = new URLSearchParams(path.search);
			params.delete("index");
			path.search = params.toString() ? "?" + params.toString() : "";
			}
			}

			if ((!action \|\| action === ".") && match.route.index) {
			path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
			} // If we're operating within a basename, prepend it to the pathname prior
			// to creating the form action. If this is a root navigation, then just use
			// the raw basename which allows the basename to have full control over the
			// presence of a trailing slash on root actions


			if (basename !== "/") {
			path.pathname = path.pathname === "/" ? basename : router.joinPaths([basename, path.pathname]);
			}

			return reactRouter.createPath(path);
			}

			function createFetcherForm(fetcherKey, routeId) {
			let FetcherForm = /#__PURE__/React__namespace.forwardRef((props, ref) => {
			return /#__PURE__/React__namespace.createElement(FormImpl, _extends({}, props, {
			ref: ref,
			fetcherKey: fetcherKey,
			routeId: routeId
			}));
			});

			{
			FetcherForm.displayName = "fetcher.Form";
			}

			return FetcherForm;
			}

			let fetcherId = 0;

			/**
			* Interacts with route loaders and actions without causing a navigation. Great
			* for any interaction that stays on the same page.
			*/
			function useFetcher() {
			var _route$matches;

			let {
			router: router$1
			} = useDataRouterContext(DataRouterHook.UseFetcher);
			let route = React__namespace.useContext(reactRouter.UNSAFE_RouteContext);
			!route ? router.invariant(false, "useFetcher must be used inside a RouteContext") : void 0;
			let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;
			!(routeId != null) ? router.invariant(false, "useFetcher can only be used on routes that contain a unique \"id\"") : void 0;
			let [fetcherKey] = React__namespace.useState(() => String(++fetcherId));
			let [Form] = React__namespace.useState(() => {
			!routeId ? router.invariant(false, "No routeId available for fetcher.Form()") : void 0;
			return createFetcherForm(fetcherKey, routeId);
			});
			let [load] = React__namespace.useState(() => href => {
			!router$1 ? router.invariant(false, "No router available for fetcher.load()") : void 0;
			!routeId ? router.invariant(false, "No routeId available for fetcher.load()") : void 0;
			router$1.fetch(fetcherKey, routeId, href);
			});
			let submit = useSubmitImpl(fetcherKey, routeId);
			let fetcher = router$1.getFetcher(fetcherKey);
			let fetcherWithComponents = React__namespace.useMemo(() => _extends({
			Form,
			submit,
			load
			}, fetcher), [fetcher, Form, submit, load]);
			React__namespace.useEffect(() => {
			// Is this busted when the React team gets real weird and calls effects
			// twice on mount? We really just need to garbage collect here when this
			// fetcher is no longer around.
			return () => {
			if (!router$1) {
			console.warn("No fetcher available to clean up from useFetcher()");
			return;
			}

			router$1.deleteFetcher(fetcherKey);
			};
			}, [router$1, fetcherKey]);
			return fetcherWithComponents;
			}
			/**
			* Provides all fetchers currently on the page. Useful for layouts and parent
			* routes that need to provide pending/optimistic UI regarding the fetch.
			*/

			function useFetchers() {
			let state = useDataRouterState(DataRouterStateHook.UseFetchers);
			return [...state.fetchers.values()];
			}
			const SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions";
			let savedScrollPositions = {};
			/**
			* When rendered inside a RouterProvider, will restore scroll positions on navigations
			*/

			function useScrollRestoration(_temp3) {
			let {
			getKey,
			storageKey
			} = _temp3 === void 0 ? {} : _temp3;
			let {
			router
			} = useDataRouterContext(DataRouterHook.UseScrollRestoration);
			let {
			restoreScrollPosition,
			preventScrollReset
			} = useDataRouterState(DataRouterStateHook.UseScrollRestoration);
			let location = reactRouter.useLocation();
			let matches = reactRouter.useMatches();
			let navigation = reactRouter.useNavigation(); // Trigger manual scroll restoration while we're active

			React__namespace.useEffect(() => {
			window.history.scrollRestoration = "manual";
			return () => {
			window.history.scrollRestoration = "auto";
			};
			}, []); // Save positions on unload

			useBeforeUnload(React__namespace.useCallback(() => {
			if (navigation.state === "idle") {
			let key = (getKey ? getKey(location, matches) : null) \|\| location.key;
			savedScrollPositions[key] = window.scrollY;
			}

			sessionStorage.setItem(storageKey \|\| SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));
			window.history.scrollRestoration = "auto";
			}, [storageKey, getKey, navigation.state, location, matches])); // Read in any saved scroll locations

			if (typeof document !== "undefined") {
			// eslint-disable-next-line react-hooks/rules-of-hooks
			React__namespace.useLayoutEffect(() => {
			try {
			let sessionPositions = sessionStorage.getItem(storageKey \|\| SCROLL_RESTORATION_STORAGE_KEY);

			if (sessionPositions) {
			savedScrollPositions = JSON.parse(sessionPositions);
			}
			} catch (e) {// no-op, use default empty object
			}
			}, [storageKey]); // Enable scroll restoration in the router
			// eslint-disable-next-line react-hooks/rules-of-hooks

			React__namespace.useLayoutEffect(() => {
			let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKey);
			return () => disableScrollRestoration && disableScrollRestoration();
			}, [router, getKey]); // Restore scrolling when state.restoreScrollPosition changes
			// eslint-disable-next-line react-hooks/rules-of-hooks

			React__namespace.useLayoutEffect(() => {
			// Explicit false means don't do anything (used for submissions)
			if (restoreScrollPosition === false) {
			return;
			} // been here before, scroll to it


			if (typeof restoreScrollPosition === "number") {
			window.scrollTo(0, restoreScrollPosition);
			return;
			} // try to scroll to the hash


			if (location.hash) {
			let el = document.getElementById(location.hash.slice(1));

			if (el) {
			el.scrollIntoView();
			return;
			}
			} // Opt out of scroll reset if this link requested it


			if (preventScrollReset === true) {
			return;
			} // otherwise go to the top on new locations


			window.scrollTo(0, 0);
			}, [location, restoreScrollPosition, preventScrollReset]);
			}
			}
			/**
			* Setup a callback to be fired on the window's `beforeunload` event. This is
			* useful for saving some data to `window.localStorage` just before the page
			* refreshes.
			*
			* Note: The `callback` argument should be a function created with
			* `React.useCallback()`.
			*/


			function useBeforeUnload(callback) {
			React__namespace.useEffect(() => {
			window.addEventListener("beforeunload", callback);
			return () => {
			window.removeEventListener("beforeunload", callback);
			};
			}, [callback]);
			} //#endregion
			////////////////////////////////////////////////////////////////////////////////
			//#region Utils
			////////////////////////////////////////////////////////////////////////////////

			function warning(cond, message) {
			if (!cond) {
			// eslint-disable-next-line no-console
			if (typeof console !== "undefined") console.warn(message);

			try {
			// Welcome to debugging React Router!
			//
			// This error is thrown as a convenience so you can more easily
			// find the source for a warning that appears in the console by
			// enabling "pause on exceptions" in your JavaScript debugger.
			throw new Error(message); // eslint-disable-next-line no-empty
			} catch (e) {}
			}
			} //#endregion

			Object.defineProperty(exports, 'AbortedDeferredError', {
			enumerable: true,
			get: function () { return reactRouter.AbortedDeferredError; }
			});
			Object.defineProperty(exports, 'Await', {
			enumerable: true,
			get: function () { return reactRouter.Await; }
			});
			Object.defineProperty(exports, 'MemoryRouter', {
			enumerable: true,
			get: function () { return reactRouter.MemoryRouter; }
			});
			Object.defineProperty(exports, 'Navigate', {
			enumerable: true,
			get: function () { return reactRouter.Navigate; }
			});
			Object.defineProperty(exports, 'NavigationType', {
			enumerable: true,
			get: function () { return reactRouter.NavigationType; }
			});
			Object.defineProperty(exports, 'Outlet', {
			enumerable: true,
			get: function () { return reactRouter.Outlet; }
			});
			Object.defineProperty(exports, 'Route', {
			enumerable: true,
			get: function () { return reactRouter.Route; }
			});
			Object.defineProperty(exports, 'Router', {
			enumerable: true,
			get: function () { return reactRouter.Router; }
			});
			Object.defineProperty(exports, 'RouterProvider', {
			enumerable: true,
			get: function () { return reactRouter.RouterProvider; }
			});
			Object.defineProperty(exports, 'Routes', {
			enumerable: true,
			get: function () { return reactRouter.Routes; }
			});
			Object.defineProperty(exports, 'UNSAFE_DataRouterContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_DataRouterContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_DataRouterStateContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_DataRouterStateContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_DataStaticRouterContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_DataStaticRouterContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_LocationContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_LocationContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_NavigationContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_NavigationContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_RouteContext', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_RouteContext; }
			});
			Object.defineProperty(exports, 'UNSAFE_enhanceManualRouteObjects', {
			enumerable: true,
			get: function () { return reactRouter.UNSAFE_enhanceManualRouteObjects; }
			});
			Object.defineProperty(exports, 'createMemoryRouter', {
			enumerable: true,
			get: function () { return reactRouter.createMemoryRouter; }
			});
			Object.defineProperty(exports, 'createPath', {
			enumerable: true,
			get: function () { return reactRouter.createPath; }
			});
			Object.defineProperty(exports, 'createRoutesFromChildren', {
			enumerable: true,
			get: function () { return reactRouter.createRoutesFromChildren; }
			});
			Object.defineProperty(exports, 'createRoutesFromElements', {
			enumerable: true,
			get: function () { return reactRouter.createRoutesFromElements; }
			});
			Object.defineProperty(exports, 'defer', {
			enumerable: true,
			get: function () { return reactRouter.defer; }
			});
			Object.defineProperty(exports, 'generatePath', {
			enumerable: true,
			get: function () { return reactRouter.generatePath; }
			});
			Object.defineProperty(exports, 'isRouteErrorResponse', {
			enumerable: true,
			get: function () { return reactRouter.isRouteErrorResponse; }
			});
			Object.defineProperty(exports, 'json', {
			enumerable: true,
			get: function () { return reactRouter.json; }
			});
			Object.defineProperty(exports, 'matchPath', {
			enumerable: true,
			get: function () { return reactRouter.matchPath; }
			});
			Object.defineProperty(exports, 'matchRoutes', {
			enumerable: true,
			get: function () { return reactRouter.matchRoutes; }
			});
			Object.defineProperty(exports, 'parsePath', {
			enumerable: true,
			get: function () { return reactRouter.parsePath; }
			});
			Object.defineProperty(exports, 'redirect', {
			enumerable: true,
			get: function () { return reactRouter.redirect; }
			});
			Object.defineProperty(exports, 'renderMatches', {
			enumerable: true,
			get: function () { return reactRouter.renderMatches; }
			});
			Object.defineProperty(exports, 'resolvePath', {
			enumerable: true,
			get: function () { return reactRouter.resolvePath; }
			});
			Object.defineProperty(exports, 'useActionData', {
			enumerable: true,
			get: function () { return reactRouter.useActionData; }
			});
			Object.defineProperty(exports, 'useAsyncError', {
			enumerable: true,
			get: function () { return reactRouter.useAsyncError; }
			});
			Object.defineProperty(exports, 'useAsyncValue', {
			enumerable: true,
			get: function () { return reactRouter.useAsyncValue; }
			});
			Object.defineProperty(exports, 'useHref', {
			enumerable: true,
			get: function () { return reactRouter.useHref; }
			});
			Object.defineProperty(exports, 'useInRouterContext', {
			enumerable: true,
			get: function () { return reactRouter.useInRouterContext; }
			});
			Object.defineProperty(exports, 'useLoaderData', {
			enumerable: true,
			get: function () { return reactRouter.useLoaderData; }
			});
			Object.defineProperty(exports, 'useLocation', {
			enumerable: true,
			get: function () { return reactRouter.useLocation; }
			});
			Object.defineProperty(exports, 'useMatch', {
			enumerable: true,
			get: function () { return reactRouter.useMatch; }
			});
			Object.defineProperty(exports, 'useMatches', {
			enumerable: true,
			get: function () { return reactRouter.useMatches; }
			});
			Object.defineProperty(exports, 'useNavigate', {
			enumerable: true,
			get: function () { return reactRouter.useNavigate; }
			});
			Object.defineProperty(exports, 'useNavigation', {
			enumerable: true,
			get: function () { return reactRouter.useNavigation; }
			});
			Object.defineProperty(exports, 'useNavigationType', {
			enumerable: true,
			get: function () { return reactRouter.useNavigationType; }
			});
			Object.defineProperty(exports, 'useOutlet', {
			enumerable: true,
			get: function () { return reactRouter.useOutlet; }
			});
			Object.defineProperty(exports, 'useOutletContext', {
			enumerable: true,
			get: function () { return reactRouter.useOutletContext; }
			});
			Object.defineProperty(exports, 'useParams', {
			enumerable: true,
			get: function () { return reactRouter.useParams; }
			});
			Object.defineProperty(exports, 'useResolvedPath', {
			enumerable: true,
			get: function () { return reactRouter.useResolvedPath; }
			});
			Object.defineProperty(exports, 'useRevalidator', {
			enumerable: true,
			get: function () { return reactRouter.useRevalidator; }
			});
			Object.defineProperty(exports, 'useRouteError', {
			enumerable: true,
			get: function () { return reactRouter.useRouteError; }
			});
			Object.defineProperty(exports, 'useRouteLoaderData', {
			enumerable: true,
			get: function () { return reactRouter.useRouteLoaderData; }
			});
			Object.defineProperty(exports, 'useRoutes', {
			enumerable: true,
			get: function () { return reactRouter.useRoutes; }
			});
			exports.BrowserRouter = BrowserRouter;
			exports.Form = Form;
			exports.HashRouter = HashRouter;
			exports.Link = Link;
			exports.NavLink = NavLink;
			exports.ScrollRestoration = ScrollRestoration;
			exports.UNSAFE_useScrollRestoration = useScrollRestoration;
			exports.createBrowserRouter = createBrowserRouter;
			exports.createHashRouter = createHashRouter;
			exports.createSearchParams = createSearchParams;
			exports.unstable_HistoryRouter = HistoryRouter;
			exports.useBeforeUnload = useBeforeUnload;
			exports.useFetcher = useFetcher;
			exports.useFetchers = useFetchers;
			exports.useFormAction = useFormAction;
			exports.useLinkClickHandler = useLinkClickHandler;
			exports.useSearchParams = useSearchParams;
			exports.useSubmit = useSubmit;

			Object.defineProperty(exports, '__esModule', { value: true });

			}));
			//# sourceMappingURL=react-router-dom.development.js.map