@tanstack/router-core 0.0.1-alpha.1 → 0.0.1-alpha.10

package/build/cjs/packages/router-core/src/router.js

@@ -0,0 +1,809 @@
+/**
+ * router-core
+ *
+ * Copyright (c) TanStack
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var index = require('../../../node_modules/history/index.js');
+var tinyInvariant = require('../../../node_modules/tiny-invariant/dist/esm/tiny-invariant.js');
+var path = require('./path.js');
+var route = require('./route.js');
+var routeMatch = require('./routeMatch.js');
+var searchParams = require('./searchParams.js');
+var utils = require('./utils.js');
+
+var _window$document;
+// Detect if we're in the DOM
+const isServer = Boolean(typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement)); // This is the default history object if none is defined
+
+const createDefaultHistory = () => !isServer ? index.createBrowserHistory() : index.createMemoryHistory();
+
+function createRouter(userOptions) {
+  var _userOptions$stringif, _userOptions$parseSea;
+
+  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
+
+  const originalOptions = _rollupPluginBabelHelpers["extends"]({
+    defaultLoaderGcMaxAge: 5 * 60 * 1000,
+    defaultLoaderMaxAge: 0,
+    defaultPreloadMaxAge: 2000,
+    defaultPreloadDelay: 50
+  }, userOptions, {
+    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : searchParams.defaultStringifySearch,
+    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : searchParams.defaultParseSearch
+  });
+
+  let router = {
+    history,
+    options: originalOptions,
+    listeners: [],
+    removeActionQueue: [],
+    // Resolved after construction
+    basepath: '',
+    routeTree: undefined,
+    routesById: {},
+    location: undefined,
+    allRouteInfo: undefined,
+    //
+    navigationPromise: Promise.resolve(),
+    resolveNavigation: () => {},
+    matchCache: {},
+    state: {
+      status: 'idle',
+      location: null,
+      matches: [],
+      actions: {},
+      loaderData: {},
+      lastUpdated: Date.now(),
+      isFetching: false,
+      isPreloading: false
+    },
+    startedLoadingAt: Date.now(),
+    subscribe: listener => {
+      router.listeners.push(listener);
+      return () => {
+        router.listeners = router.listeners.filter(x => x !== listener);
+      };
+    },
+    getRoute: id => {
+      return router.routesById[id];
+    },
+    notify: () => {
+      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
+        isFetching: router.state.status === 'loading' || router.state.matches.some(d => d.isFetching),
+        isPreloading: Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId))
+      });
+      route.cascadeLoaderData(router.state.matches);
+      router.listeners.forEach(listener => listener());
+    },
+    mount: () => {
+      const next = router.__.buildLocation({
+        to: '.',
+        search: true,
+        hash: true
+      }); // If the current location isn't updated, trigger a navigation
+      // to the current location. Otherwise, load the current location.
+
+
+      if (next.href !== router.location.href) {
+        router.__.commitLocation(next, true);
+      } else {
+        router.loadLocation();
+      }
+
+      const unsub = history.listen(event => {
+        router.loadLocation(router.__.parseLocation(event.location, router.location));
+      }); // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+      if (!isServer && window.addEventListener) {
+        // Listen to visibillitychange and focus
+        window.addEventListener('visibilitychange', router.onFocus, false);
+        window.addEventListener('focus', router.onFocus, false);
+      }
+
+      return () => {
+        unsub(); // Be sure to unsubscribe if a new handler is set
+
+        window.removeEventListener('visibilitychange', router.onFocus);
+        window.removeEventListener('focus', router.onFocus);
+      };
+    },
+    onFocus: () => {
+      router.loadLocation();
+    },
+    update: opts => {
+      Object.assign(router.options, opts);
+      const {
+        basepath,
+        routeConfig
+      } = router.options;
+      router.basepath = path.cleanPath("/" + (basepath != null ? basepath : ''));
+
+      if (routeConfig) {
+        router.routesById = {};
+        router.routeTree = router.__.buildRouteTree(routeConfig);
+      }
+
+      return router;
+    },
+    cancelMatches: () => {
+      var _router$state$pending, _router$state$pending2;
+      [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
+        match.cancel();
+      });
+    },
+    loadLocation: async next => {
+      const id = Math.random();
+      router.startedLoadingAt = id;
+
+      if (next) {
+        // Ingest the new location
+        router.location = next;
+      } // Clear out old actions
+
+
+      router.removeActionQueue.forEach(_ref => {
+        let {
+          action,
+          actionState
+        } = _ref;
+
+        if (router.state.currentAction === actionState) {
+          router.state.currentAction = undefined;
+        }
+
+        if (action.current === actionState) {
+          action.current = undefined;
+        }
+      });
+      router.removeActionQueue = []; // Cancel any pending matches
+
+      router.cancelMatches(); // Match the routes
+
+      const matches = router.matchRoutes(location.pathname, {
+        strictParseParams: true
+      });
+      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
+        pending: {
+          matches: matches,
+          location: router.location
+        },
+        status: 'loading'
+      });
+      router.notify(); // Load the matches
+
+      await router.loadMatches(matches, {
+        withPending: true
+      });
+
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return router.navigationPromise;
+      }
+
+      const previousMatches = router.state.matches;
+      const exiting = [],
+            staying = [];
+      previousMatches.forEach(d => {
+        if (matches.find(dd => dd.matchId === d.matchId)) {
+          staying.push(d);
+        } else {
+          exiting.push(d);
+        }
+      });
+      const now = Date.now();
+      exiting.forEach(d => {
+        var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
+
+        d.__.onExit == null ? void 0 : d.__.onExit({
+          params: d.params,
+          search: d.routeSearch
+        }); // Clear idle error states when match leaves
+
+        if (d.status === 'error' && !d.isFetching) {
+          d.status = 'idle';
+          d.error = undefined;
+        }
+
+        const gc = Math.max((_ref2 = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref2 : 0, (_ref3 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0);
+
+        if (gc > 0) {
+          router.matchCache[d.matchId] = {
+            gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
+            match: d
+          };
+        }
+      });
+      staying.forEach(d => {
+        d.options.onTransition == null ? void 0 : d.options.onTransition({
+          params: d.params,
+          search: d.routeSearch
+        });
+      });
+      const entering = matches.filter(d => {
+        return !previousMatches.find(dd => dd.matchId === d.matchId);
+      });
+      entering.forEach(d => {
+        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+          params: d.params,
+          search: d.search
+        });
+        delete router.matchCache[d.matchId];
+      });
+
+      if (matches.some(d => d.status === 'loading')) {
+        router.notify();
+        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+      }
+
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return;
+      }
+
+      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
+        location: router.location,
+        matches,
+        pending: undefined,
+        status: 'idle'
+      });
+      router.notify();
+      router.resolveNavigation();
+    },
+    cleanMatchCache: () => {
+      const now = Date.now();
+      Object.keys(router.matchCache).forEach(matchId => {
+        const entry = router.matchCache[matchId]; // Don't remove loading matches
+
+        if (entry.match.status === 'loading') {
+          return;
+        } // Do not remove successful matches that are still valid
+
+
+        if (entry.gc > 0 && entry.gc > now) {
+          return;
+        } // Everything else gets removed
+
+
+        delete router.matchCache[matchId];
+      });
+    },
+    loadRoute: async function loadRoute(navigateOpts) {
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
+
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches);
+      return matches;
+    },
+    preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
+      var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
+
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
+
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches, {
+        preload: true,
+        maxAge: (_ref4 = (_ref5 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref5 : router.options.defaultLoaderMaxAge) != null ? _ref4 : 0,
+        gcMaxAge: (_ref6 = (_ref7 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0
+      });
+      return matches;
+    },
+    matchRoutes: (pathname, opts) => {
+      var _router$state$pending3, _router$state$pending4;
+
+      router.cleanMatchCache();
+      const matches = [];
+
+      if (!router.routeTree) {
+        return matches;
+      }
+
+      const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
+
+      const recurse = async routes => {
+        var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
+
+        const parentMatch = utils.last(matches);
+        let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
+        const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
+        let foundRoutes = [];
+
+        const findMatchInRoutes = (parentRoutes, routes) => {
+          routes.some(route => {
+            var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
+
+            if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
+              return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
+            }
+
+            const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
+            const matchParams = path.matchPathname(pathname, {
+              to: route.fullPath,
+              fuzzy,
+              caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+            });
+
+            if (matchParams) {
+              let parsedParams;
+
+              try {
+                var _route$options$parseP;
+
+                parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
+              } catch (err) {
+                if (opts != null && opts.strictParseParams) {
+                  throw err;
+                }
+              }
+
+              params = _rollupPluginBabelHelpers["extends"]({}, params, parsedParams);
+            }
+
+            if (!!matchParams) {
+              foundRoutes = [...parentRoutes, route];
+            }
+
+            return !!foundRoutes.length;
+          });
+          return !!foundRoutes.length;
+        };
+
+        findMatchInRoutes([], filteredRoutes);
+
+        if (!foundRoutes.length) {
+          return;
+        }
+
+        foundRoutes.forEach(foundRoute => {
+          var _router$matchCache$ma;
+
+          const interpolatedPath = path.interpolatePath(foundRoute.routePath, params);
+          const matchId = path.interpolatePath(foundRoute.routeId, params, true);
+          const match = existingMatches.find(d => d.matchId === matchId) || ((_router$matchCache$ma = router.matchCache[matchId]) == null ? void 0 : _router$matchCache$ma.match) || routeMatch.createRouteMatch(router, foundRoute, {
+            matchId,
+            params,
+            pathname: path.joinPaths([pathname, interpolatedPath])
+          });
+          matches.push(match);
+        });
+        const foundRoute = utils.last(foundRoutes);
+
+        if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+          recurse(foundRoute.childRoutes);
+        }
+      };
+
+      recurse([router.routeTree]);
+      route.cascadeLoaderData(matches);
+      return matches;
+    },
+    loadMatches: async (resolvedMatches, loaderOpts) => {
+      const now = Date.now();
+      const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0;
+      const matchPromises = resolvedMatches.map(async match => {
+        // Validate the match (loads search params etc)
+        match.__.validate(); // If this is a preload, add it to the preload cache
+
+
+        if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
+          // If the match is currently active, don't preload it
+          if (router.state.matches.find(d => d.matchId === match.matchId)) {
+            return;
+          }
+
+          router.matchCache[match.matchId] = {
+            gc: now + loaderOpts.gcMaxAge,
+            match
+          };
+        } // If the match is invalid, errored or idle, trigger it to load
+
+
+        if (match.status === 'success' && match.getIsInvalid() || match.status === 'error' || match.status === 'idle') {
+          const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
+          match.load({
+            maxAge
+          });
+        }
+
+        if (match.status === 'loading') {
+          // If requested, start the pending timers
+          if (loaderOpts != null && loaderOpts.withPending) match.__.startPending(); // Wait for the first sign of activity from the match
+          // This might be completion, error, or a pending state
+
+          await match.__.loadPromise;
+        }
+      });
+      router.notify();
+      await Promise.all(matchPromises);
+    },
+    invalidateRoute: opts => {
+      var _router$state$pending5, _router$state$pending6;
+
+      const next = router.buildNext(opts);
+      const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
+      [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
+        if (unloadedMatchIds.includes(match.matchId)) {
+          match.invalidate();
+        }
+      });
+    },
+    reload: () => router.__.navigate({
+      fromCurrent: true,
+      replace: true,
+      search: true
+    }),
+    resolvePath: (from, path$1) => {
+      return path.resolvePath(router.basepath, from, path.cleanPath(path$1));
+    },
+    matchRoute: (location, opts) => {
+      var _location$from;
+
+      // const location = router.buildNext(opts)
+      location = _rollupPluginBabelHelpers["extends"]({}, location, {
+        to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
+      });
+      const next = router.buildNext(location);
+
+      if (opts != null && opts.pending) {
+        var _router$state$pending7;
+
+        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
+          return false;
+        }
+
+        return !!path.matchPathname(router.state.pending.location.pathname, _rollupPluginBabelHelpers["extends"]({}, opts, {
+          to: next.pathname
+        }));
+      }
+
+      return !!path.matchPathname(router.state.location.pathname, _rollupPluginBabelHelpers["extends"]({}, opts, {
+        to: next.pathname
+      }));
+    },
+    navigate: async _ref8 => {
+      let {
+        from,
+        to = '.',
+        search,
+        hash,
+        replace,
+        params
+      } = _ref8;
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      const toString = String(to);
+      const fromString = String(from);
+      let isExternal;
+
+      try {
+        new URL("" + toString);
+        isExternal = true;
+      } catch (e) {}
+
+      tinyInvariant["default"](!isExternal, 'Attempting to navigate to external url with router.navigate!');
+      return router.__.navigate({
+        from: fromString,
+        to: toString,
+        search,
+        hash,
+        replace,
+        params
+      });
+    },
+    buildLink: _ref9 => {
+      var _preload, _ref10;
+
+      let {
+        from,
+        to = '.',
+        search,
+        params,
+        hash,
+        target,
+        replace,
+        activeOptions,
+        preload,
+        preloadMaxAge: userPreloadMaxAge,
+        preloadGcMaxAge: userPreloadGcMaxAge,
+        preloadDelay: userPreloadDelay,
+        disabled
+      } = _ref9;
+
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      try {
+        new URL("" + to);
+        return {
+          type: 'external',
+          href: to
+        };
+      } catch (e) {}
+
+      const nextOpts = {
+        from,
+        to,
+        search,
+        params,
+        hash,
+        replace
+      };
+      const next = router.buildNext(nextOpts);
+      preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
+      const preloadDelay = (_ref10 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref10 : 0; // Compare path/hash for matches
+
+      const pathIsEqual = router.state.location.pathname === next.pathname;
+      const currentPathSplit = router.state.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
+
+      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
+      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
+
+      const isActive = pathTest && hashTest; // The click handler
+
+      const handleClick = e => {
+        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+          e.preventDefault();
+
+          if (pathIsEqual && !search && !hash) {
+            router.invalidateRoute(nextOpts);
+          } // All is well? Navigate!)
+
+
+          router.__.navigate(nextOpts);
+        }
+      }; // The click handler
+
+
+      const handleFocus = e => {
+        if (preload) {
+          router.preloadRoute(nextOpts, {
+            maxAge: userPreloadMaxAge,
+            gcMaxAge: userPreloadGcMaxAge
+          });
+        }
+      };
+
+      const handleEnter = e => {
+        const target = e.target || {};
+
+        if (preload) {
+          if (target.preloadTimeout) {
+            return;
+          }
+
+          target.preloadTimeout = setTimeout(() => {
+            target.preloadTimeout = null;
+            router.preloadRoute(nextOpts, {
+              maxAge: userPreloadMaxAge,
+              gcMaxAge: userPreloadGcMaxAge
+            });
+          }, preloadDelay);
+        }
+      };
+
+      const handleLeave = e => {
+        const target = e.target || {};
+
+        if (target.preloadTimeout) {
+          clearTimeout(target.preloadTimeout);
+          target.preloadTimeout = null;
+        }
+      };
+
+      return {
+        type: 'internal',
+        next,
+        handleFocus,
+        handleClick,
+        handleEnter,
+        handleLeave,
+        isActive,
+        disabled
+      };
+    },
+    buildNext: opts => {
+      const next = router.__.buildLocation(opts);
+
+      const matches = router.matchRoutes(next.pathname);
+
+      const __preSearchFilters = matches.map(match => {
+        var _match$options$preSea;
+
+        return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+      }).flat().filter(Boolean);
+
+      const __postSearchFilters = matches.map(match => {
+        var _match$options$postSe;
+
+        return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+      }).flat().filter(Boolean);
+
+      return router.__.buildLocation(_rollupPluginBabelHelpers["extends"]({}, opts, {
+        __preSearchFilters,
+        __postSearchFilters
+      }));
+    },
+    __: {
+      buildRouteTree: rootRouteConfig => {
+        const recurseRoutes = (routeConfigs, parent) => {
+          return routeConfigs.map(routeConfig => {
+            const routeOptions = routeConfig.options;
+            const route$1 = route.createRoute(routeConfig, routeOptions, parent, router); // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
+
+            const existingRoute = router.routesById[route$1.routeId];
+
+            if (existingRoute) {
+              if (process.env.NODE_ENV !== 'production') {
+                console.warn("Duplicate routes found with id: " + String(route$1.routeId), router.routesById, route$1);
+              }
+
+              throw new Error();
+            }
+            router.routesById[route$1.routeId] = route$1;
+            const children = routeConfig.children;
+            route$1.childRoutes = children != null && children.length ? recurseRoutes(children, route$1) : undefined;
+            return route$1;
+          });
+        };
+
+        const routes = recurseRoutes([rootRouteConfig]);
+        return routes[0];
+      },
+      parseLocation: (location, previousLocation) => {
+        var _location$hash$split$;
+
+        const parsedSearch = router.options.parseSearch(location.search);
+        return {
+          pathname: location.pathname,
+          searchStr: location.search,
+          search: utils.replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+          hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+          href: "" + location.pathname + location.search + location.hash,
+          state: location.state,
+          key: location.key
+        };
+      },
+      navigate: location => {
+        const next = router.buildNext(location);
+        return router.__.commitLocation(next, location.replace);
+      },
+      buildLocation: function buildLocation(dest) {
+        var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
+
+        if (dest === void 0) {
+          dest = {};
+        }
+
+        // const resolvedFrom: Location = {
+        //   ...router.location,
+        const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+
+        let pathname = path.resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+
+        const fromMatches = router.matchRoutes(router.location.pathname, {
+          strictParseParams: true
+        });
+        const toMatches = router.matchRoutes(pathname);
+
+        const prevParams = _rollupPluginBabelHelpers["extends"]({}, (_last = utils.last(fromMatches)) == null ? void 0 : _last.params);
+
+        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : utils.functionalUpdate(dest.params, prevParams);
+
+        if (nextParams) {
+          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
+
+        pathname = path.interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
+
+        const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
+
+        const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+        : dest.search ? (_functionalUpdate = utils.functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
+        : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
+        : {}; // Then post filters
+
+        const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+        const search = utils.replaceEqualDeep(router.location.search, postFilteredSearch);
+        const searchStr = router.options.stringifySearch(search);
+        let hash = dest.hash === true ? router.location.hash : utils.functionalUpdate(dest.hash, router.location.hash);
+        hash = hash ? "#" + hash : '';
+        return {
+          pathname,
+          search,
+          searchStr,
+          state: router.location.state,
+          hash,
+          href: "" + pathname + searchStr + hash,
+          key: dest.key
+        };
+      },
+      commitLocation: (next, replace) => {
+        const id = '' + Date.now() + Math.random();
+        if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
+        let nextAction = 'replace';
+
+        if (!replace) {
+          nextAction = 'push';
+        }
+
+        const isSameUrl = router.__.parseLocation(history.location).href === next.href;
+
+        if (isSameUrl && !next.key) {
+          nextAction = 'replace';
+        }
+
+        if (nextAction === 'replace') {
+          history.replace({
+            pathname: next.pathname,
+            hash: next.hash,
+            search: next.searchStr
+          }, {
+            id
+          });
+        } else {
+          history.push({
+            pathname: next.pathname,
+            hash: next.hash,
+            search: next.searchStr
+          }, {
+            id
+          });
+        }
+
+        router.navigationPromise = new Promise(resolve => {
+          const previousNavigationResolve = router.resolveNavigation;
+
+          router.resolveNavigation = () => {
+            previousNavigationResolve();
+            resolve();
+          };
+        });
+        return router.navigationPromise;
+      }
+    }
+  };
+  router.location = router.__.parseLocation(history.location);
+  router.state.location = router.location;
+  router.update(userOptions); // Allow frameworks to hook into the router creation
+
+  router.options.createRouter == null ? void 0 : router.options.createRouter(router);
+  return router;
+}
+
+function isCtrlEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+
+exports.createRouter = createRouter;
+//# sourceMappingURL=router.js.map