framework7 6.3.4 → 7.0.0-beta.3

package/{esm/modules → modules}/router/router-class.js

@@ -1,9 +1,3 @@
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 import { getWindow, getDocument } from 'ssr-window';
 import { pathToRegexp, compile } from 'path-to-regexp';
 import $ from '../../shared/dom7';
@@ -18,23 +12,17 @@ import { back } from './back';
 import { clearPreviousHistory } from './clear-previous-history';
 import appRouterCheck from './app-router-check';
 
-var Router = /*#__PURE__*/function (_Framework7Class) {
-  _inheritsLoose(Router, _Framework7Class);
-
-  function Router(app, view) {
-    var _this;
-
-    _this = _Framework7Class.call(this, {}, [typeof view === 'undefined' ? app : view]) || this;
-
-    var router = _assertThisInitialized(_this); // Is App Router
-
+class Router extends Framework7Class {
+  constructor(app, view) {
+    super({}, [typeof view === 'undefined' ? app : view]);
+    const router = this; // Is App Router
 
     router.isAppRouter = typeof view === 'undefined';
 
     if (router.isAppRouter) {
       // App Router
       extend(false, router, {
-        app: app,
+        app,
         params: app.params.view,
         routes: app.routes || [],
         cache: app.cache
@@ -42,8 +30,8 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     } else {
       // View Router
       extend(false, router, {
-        app: app,
-        view: view,
+        app,
+        view,
         viewId: view.id,
         id: view.params.routerId,
         params: view.params,
@@ -62,45 +50,45 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
     router.allowPageChange = true; // Current Route
 
-    var currentRoute = {};
-    var previousRoute = {};
+    let currentRoute = {};
+    let previousRoute = {};
     Object.defineProperty(router, 'currentRoute', {
       enumerable: true,
       configurable: true,
-      set: function set(newRoute) {
-        if (newRoute === void 0) {
-          newRoute = {};
-        }
 
+      set(newRoute = {}) {
         previousRoute = extend({}, currentRoute);
         currentRoute = newRoute;
         if (!currentRoute) return;
         router.url = currentRoute.url;
         router.emit('routeChange', newRoute, previousRoute, router);
       },
-      get: function get() {
+
+      get() {
         return currentRoute;
       }
+
     });
     Object.defineProperty(router, 'previousRoute', {
       enumerable: true,
       configurable: true,
-      get: function get() {
+
+      get() {
         return previousRoute;
       },
-      set: function set(newRoute) {
+
+      set(newRoute) {
         previousRoute = newRoute;
       }
+
     });
-    return router || _assertThisInitialized(_this);
+    return router;
   }
 
-  var _proto = Router.prototype;
-
-  _proto.mount = function mount() {
-    var router = this;
-    var view = router.view;
-    var document = getDocument();
+  mount() {
+    const router = this;
+    const view = router.view;
+    const document = getDocument();
     extend(false, router, {
       tempDom: document.createElement('div'),
       $el: view.$el,
@@ -109,21 +97,21 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       navbarsEl: view.navbarsEl
     });
     router.emit('local::mount routerMount', router);
-  };
+  }
 
-  _proto.animatableNavElements = function animatableNavElements($newNavbarEl, $oldNavbarEl, toLarge, fromLarge, direction) {
-    var router = this;
-    var dynamicNavbar = router.dynamicNavbar;
-    var animateIcon = router.params.iosAnimateNavbarBackIcon;
-    var newNavEls;
-    var oldNavEls;
+  animatableNavElements($newNavbarEl, $oldNavbarEl, toLarge, fromLarge, direction) {
+    const router = this;
+    const dynamicNavbar = router.dynamicNavbar;
+    const animateIcon = router.params.iosAnimateNavbarBackIcon;
+    let newNavEls;
+    let oldNavEls;
 
     function animatableNavEl($el, $navbarInner) {
-      var isSliding = $el.hasClass('sliding') || $navbarInner.hasClass('sliding');
-      var isSubnavbar = $el.hasClass('subnavbar');
-      var needsOpacityTransition = isSliding ? !isSubnavbar : true;
-      var $iconEl = $el.find('.back .icon');
-      var isIconLabel;
+      const isSliding = $el.hasClass('sliding') || $navbarInner.hasClass('sliding');
+      const isSubnavbar = $el.hasClass('subnavbar');
+      const needsOpacityTransition = isSliding ? !isSubnavbar : true;
+      const $iconEl = $el.find('.back .icon');
+      let isIconLabel;
 
       if (isSliding && animateIcon && $el.hasClass('left') && $iconEl.length > 0 && $iconEl.next('span').length) {
         $el = $iconEl.next('span'); // eslint-disable-line
@@ -132,29 +120,29 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       }
 
       return {
-        $el: $el,
-        isIconLabel: isIconLabel,
+        $el,
+        isIconLabel,
         leftOffset: $el[0].f7NavbarLeftOffset,
         rightOffset: $el[0].f7NavbarRightOffset,
-        isSliding: isSliding,
-        isSubnavbar: isSubnavbar,
-        needsOpacityTransition: needsOpacityTransition
+        isSliding,
+        isSubnavbar,
+        needsOpacityTransition
       };
     }
 
     if (dynamicNavbar) {
       newNavEls = [];
       oldNavEls = [];
-      $newNavbarEl.children('.navbar-inner').children('.left, .right, .title, .subnavbar').each(function (navEl) {
-        var $navEl = $(navEl);
+      $newNavbarEl.children('.navbar-inner').children('.left, .right, .title, .subnavbar').each(navEl => {
+        const $navEl = $(navEl);
         if ($navEl.hasClass('left') && fromLarge && direction === 'forward') return;
         if ($navEl.hasClass('title') && toLarge) return;
         newNavEls.push(animatableNavEl($navEl, $newNavbarEl.children('.navbar-inner')));
       });
 
       if (!($oldNavbarEl.hasClass('navbar-master') && router.params.masterDetailBreakpoint > 0 && router.app.width >= router.params.masterDetailBreakpoint)) {
-        $oldNavbarEl.children('.navbar-inner').children('.left, .right, .title, .subnavbar').each(function (navEl) {
-          var $navEl = $(navEl);
+        $oldNavbarEl.children('.navbar-inner').children('.left, .right, .title, .subnavbar').each(navEl => {
+          const $navEl = $(navEl);
           if ($navEl.hasClass('left') && toLarge && !fromLarge && direction === 'forward') return;
           if ($navEl.hasClass('left') && toLarge && direction === 'backward') return;
 
@@ -166,16 +154,18 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         });
       }
 
-      [oldNavEls, newNavEls].forEach(function (navEls) {
-        navEls.forEach(function (navEl) {
-          var n = navEl;
-          var isSliding = navEl.isSliding,
-              $el = navEl.$el;
-          var otherEls = navEls === oldNavEls ? newNavEls : oldNavEls;
+      [oldNavEls, newNavEls].forEach(navEls => {
+        navEls.forEach(navEl => {
+          const n = navEl;
+          const {
+            isSliding,
+            $el
+          } = navEl;
+          const otherEls = navEls === oldNavEls ? newNavEls : oldNavEls;
           if (!(isSliding && $el.hasClass('title') && otherEls)) return;
-          otherEls.forEach(function (otherNavEl) {
+          otherEls.forEach(otherNavEl => {
             if (otherNavEl.isIconLabel) {
-              var iconTextEl = otherNavEl.$el[0];
+              const iconTextEl = otherNavEl.$el[0];
               n.leftOffset += iconTextEl ? iconTextEl.offsetLeft || 0 : 0;
             }
           });
@@ -184,26 +174,26 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     return {
-      newNavEls: newNavEls,
-      oldNavEls: oldNavEls
+      newNavEls,
+      oldNavEls
     };
-  };
+  }
 
-  _proto.animate = function animate($oldPageEl, $newPageEl, $oldNavbarEl, $newNavbarEl, direction, transition, callback) {
-    var router = this;
+  animate($oldPageEl, $newPageEl, $oldNavbarEl, $newNavbarEl, direction, transition, callback) {
+    const router = this;
 
     if (router.params.animateCustom) {
       router.params.animateCustom.apply(router, [$oldPageEl, $newPageEl, $oldNavbarEl, $newNavbarEl, direction, callback]);
       return;
     }
 
-    var dynamicNavbar = router.dynamicNavbar;
-    var ios = router.app.theme === 'ios';
+    const dynamicNavbar = router.dynamicNavbar;
+    const ios = router.app.theme === 'ios';
 
     if (transition) {
-      var routerCustomTransitionClass = "router-transition-custom router-transition-" + transition + "-" + direction; // Animate
+      const routerCustomTransitionClass = `router-transition-custom router-transition-${transition}-${direction}`; // Animate
 
-      var onCustomTransitionDone = function onCustomTransitionDone() {
+      const onCustomTransitionDone = () => {
         router.$el.removeClass(routerCustomTransitionClass);
 
         if (dynamicNavbar && router.$navbarsEl.length) {
@@ -240,17 +230,17 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     } // Router Animation class
 
 
-    var routerTransitionClass = "router-transition-" + direction + " router-transition";
-    var newNavEls;
-    var oldNavEls;
-    var fromLarge;
-    var toLarge;
-    var toDifferent;
-    var oldIsLarge;
-    var newIsLarge;
+    const routerTransitionClass = `router-transition-${direction} router-transition`;
+    let newNavEls;
+    let oldNavEls;
+    let fromLarge;
+    let toLarge;
+    let toDifferent;
+    let oldIsLarge;
+    let newIsLarge;
 
     if (ios && dynamicNavbar) {
-      var betweenMasterAndDetail = router.params.masterDetailBreakpoint > 0 && router.app.width >= router.params.masterDetailBreakpoint && ($oldNavbarEl.hasClass('navbar-master') && $newNavbarEl.hasClass('navbar-master-detail') || $oldNavbarEl.hasClass('navbar-master-detail') && $newNavbarEl.hasClass('navbar-master'));
+      const betweenMasterAndDetail = router.params.masterDetailBreakpoint > 0 && router.app.width >= router.params.masterDetailBreakpoint && ($oldNavbarEl.hasClass('navbar-master') && $newNavbarEl.hasClass('navbar-master-detail') || $oldNavbarEl.hasClass('navbar-master-detail') && $newNavbarEl.hasClass('navbar-master'));
 
       if (!betweenMasterAndDetail) {
         oldIsLarge = $oldNavbarEl && $oldNavbarEl.hasClass('navbar-large');
@@ -260,7 +250,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         toDifferent = fromLarge && !toLarge || toLarge && !fromLarge;
       }
 
-      var navEls = router.animatableNavElements($newNavbarEl, $oldNavbarEl, toLarge, fromLarge, direction);
+      const navEls = router.animatableNavElements($newNavbarEl, $oldNavbarEl, toLarge, fromLarge, direction);
       newNavEls = navEls.newNavEls;
       oldNavEls = navEls.oldNavEls;
     }
@@ -280,28 +270,28 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         }
       }
 
-      newNavEls.forEach(function (navEl) {
-        var $el = navEl.$el;
-        var offset = direction === 'forward' ? navEl.rightOffset : navEl.leftOffset;
+      newNavEls.forEach(navEl => {
+        const $el = navEl.$el;
+        const offset = direction === 'forward' ? navEl.rightOffset : navEl.leftOffset;
 
         if (navEl.isSliding) {
           if (navEl.isSubnavbar && newIsLarge) {
             // prettier-ignore
-            $el[0].style.setProperty('transform', "translate3d(" + offset * (1 - progress) + "px, calc(-1 * var(--f7-navbar-large-collapse-progress) * var(--f7-navbar-large-title-height)), 0)", 'important');
+            $el[0].style.setProperty('transform', `translate3d(${offset * (1 - progress)}px, calc(-1 * var(--f7-navbar-large-collapse-progress) * var(--f7-navbar-large-title-height)), 0)`, 'important');
           } else {
-            $el.transform("translate3d(" + offset * (1 - progress) + "px,0,0)");
+            $el.transform(`translate3d(${offset * (1 - progress)}px,0,0)`);
           }
         }
       });
-      oldNavEls.forEach(function (navEl) {
-        var $el = navEl.$el;
-        var offset = direction === 'forward' ? navEl.leftOffset : navEl.rightOffset;
+      oldNavEls.forEach(navEl => {
+        const $el = navEl.$el;
+        const offset = direction === 'forward' ? navEl.leftOffset : navEl.rightOffset;
 
         if (navEl.isSliding) {
           if (navEl.isSubnavbar && oldIsLarge) {
-            $el.transform("translate3d(" + offset * progress + "px, calc(-1 * var(--f7-navbar-large-collapse-progress) * var(--f7-navbar-large-title-height)), 0)");
+            $el.transform(`translate3d(${offset * progress}px, calc(-1 * var(--f7-navbar-large-collapse-progress) * var(--f7-navbar-large-title-height)), 0)`);
           } else {
-            $el.transform("translate3d(" + offset * progress + "px,0,0)");
+            $el.transform(`translate3d(${offset * progress}px,0,0)`);
           }
         }
       });
@@ -313,7 +303,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         if ($newNavbarEl) {
           $newNavbarEl.removeClass('router-navbar-transition-to-large router-navbar-transition-from-large');
           $newNavbarEl.addClass('navbar-no-title-large-transition');
-          nextFrame(function () {
+          nextFrame(() => {
             $newNavbarEl.removeClass('navbar-no-title-large-transition');
           });
         }
@@ -339,14 +329,14 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       if (callback) callback();
     }
 
-    (direction === 'forward' ? $newPageEl : $oldPageEl).animationEnd(function () {
+    (direction === 'forward' ? $newPageEl : $oldPageEl).animationEnd(() => {
       onDone();
     }); // Animate
 
     if (dynamicNavbar) {
       // Prepare Navbars
       animateNavbars(0);
-      nextFrame(function () {
+      nextFrame(() => {
         // Add class, start animation
         router.$el.addClass(routerTransitionClass);
 
@@ -361,28 +351,28 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       // Add class, start animation
       router.$el.addClass(routerTransitionClass);
     }
-  };
+  }
 
-  _proto.removeModal = function removeModal(modalEl) {
-    var router = this;
+  removeModal(modalEl) {
+    const router = this;
     router.removeEl(modalEl);
   } // eslint-disable-next-line
-  ;
 
-  _proto.removeTabContent = function removeTabContent(tabEl) {
-    var $tabEl = $(tabEl);
+
+  removeTabContent(tabEl) {
+    const $tabEl = $(tabEl);
     $tabEl.html('');
-  };
+  }
 
-  _proto.removeNavbar = function removeNavbar(el) {
-    var router = this;
+  removeNavbar(el) {
+    const router = this;
     router.removeEl(el);
-  };
+  }
 
-  _proto.removePage = function removePage(el) {
-    var $el = $(el);
-    var f7Page = $el && $el[0] && $el[0].f7Page;
-    var router = this;
+  removePage(el) {
+    const $el = $(el);
+    const f7Page = $el && $el[0] && $el[0].f7Page;
+    const router = this;
 
     if (f7Page && f7Page.route && f7Page.route.route && f7Page.route.route.keepAlive) {
       $el.remove();
@@ -390,15 +380,15 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     router.removeEl(el);
-  };
+  }
 
-  _proto.removeEl = function removeEl(el) {
+  removeEl(el) {
     if (!el) return;
-    var router = this;
-    var $el = $(el);
+    const router = this;
+    const $el = $(el);
     if ($el.length === 0) return;
-    $el.find('.tab').each(function (tabEl) {
-      $(tabEl).children().each(function (tabChild) {
+    $el.find('.tab').each(tabEl => {
+      $(tabEl).children().each(tabChild => {
         if (tabChild.f7Component) {
           $(tabChild).trigger('tab:beforeremove');
           tabChild.f7Component.destroy();
@@ -415,16 +405,16 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     if (router.params.removeElementsWithTimeout) {
-      setTimeout(function () {
+      setTimeout(() => {
         $el.remove();
       }, router.params.removeElementsTimeout);
     } else {
       $el.remove();
     }
-  };
+  }
 
-  _proto.getPageEl = function getPageEl(content) {
-    var router = this;
+  getPageEl(content) {
+    const router = this;
 
     if (typeof content === 'string') {
       router.tempDom.innerHTML = content;
@@ -438,30 +428,28 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     return router.findElement('.page', router.tempDom);
-  };
+  }
 
-  _proto.findElement = function findElement(stringSelector, container, notStacked) {
-    var router = this;
-    var view = router.view;
-    var app = router.app; // Modals Selector
+  findElement(stringSelector, container, notStacked) {
+    const router = this;
+    const view = router.view;
+    const app = router.app; // Modals Selector
 
-    var modalsSelector = '.popup, .dialog, .popover, .actions-modal, .sheet-modal, .login-screen, .page';
-    var $container = $(container);
-    var selector = stringSelector;
+    const modalsSelector = '.popup, .dialog, .popover, .actions-modal, .sheet-modal, .login-screen, .page';
+    const $container = $(container);
+    let selector = stringSelector;
     if (notStacked) selector += ':not(.stacked)';
-    var found = $container.find(selector).filter(function (el) {
-      return $(el).parents(modalsSelector).length === 0;
-    });
+    let found = $container.find(selector).filter(el => $(el).parents(modalsSelector).length === 0);
 
     if (found.length > 1) {
       if (typeof view.selector === 'string') {
         // Search in related view
-        found = $container.find(view.selector + " " + selector);
+        found = $container.find(`${view.selector} ${selector}`);
       }
 
       if (found.length > 1) {
         // Search in main view
-        found = $container.find("." + app.params.viewMainClass + " " + selector);
+        found = $container.find(`.${app.params.viewMainClass} ${selector}`);
       }
     }
 
@@ -471,22 +459,18 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     if (found && found.length === 1) return found;
     if (found && found.length > 1) return $(found[0]);
     return undefined;
-  };
-
-  _proto.flattenRoutes = function flattenRoutes(routes) {
-    if (routes === void 0) {
-      routes = this.routes;
-    }
+  }
 
-    var router = this;
-    var flattenedRoutes = [];
-    routes.forEach(function (route) {
-      var hasTabRoutes = false;
+  flattenRoutes(routes = this.routes) {
+    const router = this;
+    let flattenedRoutes = [];
+    routes.forEach(route => {
+      let hasTabRoutes = false;
 
       if ('tabs' in route && route.tabs) {
-        var mergedPathsRoutes = route.tabs.map(function (tabRoute) {
-          var tRoute = extend({}, route, {
-            path: (route.path + "/" + tabRoute.path).replace('///', '/').replace('//', '/'),
+        const mergedPathsRoutes = route.tabs.map(tabRoute => {
+          const tRoute = extend({}, route, {
+            path: `${route.path}/${tabRoute.path}`.replace('///', '/').replace('//', '/'),
             parentPath: route.path,
             tab: tabRoute
           });
@@ -499,27 +483,26 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       }
 
       if ('detailRoutes' in route) {
-        var _mergedPathsRoutes = route.detailRoutes.map(function (detailRoute) {
-          var dRoute = extend({}, detailRoute);
+        const mergedPathsRoutes = route.detailRoutes.map(detailRoute => {
+          const dRoute = extend({}, detailRoute);
           dRoute.masterRoute = route;
           dRoute.masterRoutePath = route.path;
           return dRoute;
         });
-
-        flattenedRoutes = flattenedRoutes.concat(route, router.flattenRoutes(_mergedPathsRoutes));
+        flattenedRoutes = flattenedRoutes.concat(route, router.flattenRoutes(mergedPathsRoutes));
       }
 
       if ('routes' in route) {
-        var _mergedPathsRoutes2 = route.routes.map(function (childRoute) {
-          var cRoute = extend({}, childRoute);
-          cRoute.path = (route.path + "/" + cRoute.path).replace('///', '/').replace('//', '/');
+        const mergedPathsRoutes = route.routes.map(childRoute => {
+          const cRoute = extend({}, childRoute);
+          cRoute.path = `${route.path}/${cRoute.path}`.replace('///', '/').replace('//', '/');
           return cRoute;
         });
 
         if (hasTabRoutes) {
-          flattenedRoutes = flattenedRoutes.concat(router.flattenRoutes(_mergedPathsRoutes2));
+          flattenedRoutes = flattenedRoutes.concat(router.flattenRoutes(mergedPathsRoutes));
         } else {
-          flattenedRoutes = flattenedRoutes.concat(route, router.flattenRoutes(_mergedPathsRoutes2));
+          flattenedRoutes = flattenedRoutes.concat(route, router.flattenRoutes(mergedPathsRoutes));
         }
       }
 
@@ -529,96 +512,94 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     });
     return flattenedRoutes;
   } // eslint-disable-next-line
-  ;
 
-  _proto.parseRouteUrl = function parseRouteUrl(url) {
+
+  parseRouteUrl(url) {
     if (!url) return {};
-    var query = parseUrlQuery(url);
-    var hash = url.split('#')[1];
-    var params = {};
-    var path = url.split('#')[0].split('?')[0];
+    const query = parseUrlQuery(url);
+    const hash = url.split('#')[1];
+    const params = {};
+    const path = url.split('#')[0].split('?')[0];
     return {
-      query: query,
-      hash: hash,
-      params: params,
-      url: url,
-      path: path
+      query,
+      hash,
+      params,
+      url,
+      path
     };
-  };
-
-  _proto.generateUrl = function generateUrl(parameters) {
-    if (parameters === void 0) {
-      parameters = {};
-    }
+  }
 
+  generateUrl(parameters = {}) {
     if (typeof parameters === 'string') {
       return parameters;
     }
 
-    var _parameters = parameters,
-        name = _parameters.name,
-        path = _parameters.path,
-        params = _parameters.params,
-        query = _parameters.query;
+    const {
+      name,
+      path,
+      params,
+      query
+    } = parameters;
 
     if (!name && !path) {
       throw new Error('Framework7: "name" or "path" parameter is required');
     }
 
-    var router = this;
-    var route = name ? router.findRouteByKey('name', name) : router.findRouteByKey('path', path);
+    const router = this;
+    const route = name ? router.findRouteByKey('name', name) : router.findRouteByKey('path', path);
 
     if (!route) {
       if (name) {
-        throw new Error("Framework7: route with name \"" + name + "\" not found");
+        throw new Error(`Framework7: route with name "${name}" not found`);
       } else {
-        throw new Error("Framework7: route with path \"" + path + "\" not found");
+        throw new Error(`Framework7: route with path "${path}" not found`);
       }
     }
 
-    var url = router.constructRouteUrl(route, {
-      params: params,
-      query: query
+    const url = router.constructRouteUrl(route, {
+      params,
+      query
     });
 
     if (!url) {
-      throw new Error("Framework7: can't construct URL for route with name \"" + name + "\"");
+      throw new Error(`Framework7: can't construct URL for route with name "${name}"`);
     }
 
     return url;
   } // eslint-disable-next-line
-  ;
 
-  _proto.constructRouteUrl = function constructRouteUrl(route, _temp) {
-    var _ref = _temp === void 0 ? {} : _temp,
-        params = _ref.params,
-        query = _ref.query;
 
-    var path = route.path;
-    var toUrl = compile(path);
-    var url;
+  constructRouteUrl(route, {
+    params,
+    query
+  } = {}) {
+    const {
+      path
+    } = route;
+    const toUrl = compile(path);
+    let url;
 
     try {
       url = toUrl(params || {});
     } catch (error) {
-      throw new Error("Framework7: error constructing route URL from passed params:\nRoute: " + path + "\n" + error.toString());
+      throw new Error(`Framework7: error constructing route URL from passed params:\nRoute: ${path}\n${error.toString()}`);
     }
 
     if (query) {
-      if (typeof query === 'string') url += "?" + query;else if (Object.keys(query).length) url += "?" + serializeObject(query);
+      if (typeof query === 'string') url += `?${query}`;else if (Object.keys(query).length) url += `?${serializeObject(query)}`;
     }
 
     return url;
-  };
-
-  _proto.findTabRouteUrl = function findTabRouteUrl(tabEl) {
-    var router = this;
-    var $tabEl = $(tabEl);
-    var parentPath = router.currentRoute.route.parentPath;
-    var tabId = $tabEl.attr('id');
-    var flattenedRoutes = router.flattenRoutes(router.routes);
-    var foundTabRouteUrl;
-    flattenedRoutes.forEach(function (route) {
+  }
+
+  findTabRouteUrl(tabEl) {
+    const router = this;
+    const $tabEl = $(tabEl);
+    const parentPath = router.currentRoute.route.parentPath;
+    const tabId = $tabEl.attr('id');
+    const flattenedRoutes = router.flattenRoutes(router.routes);
+    let foundTabRouteUrl;
+    flattenedRoutes.forEach(route => {
       if (route.parentPath === parentPath && route.tab && route.tab.id === tabId) {
         if (router.currentRoute.params && Object.keys(router.currentRoute.params).length > 0) {
           foundTabRouteUrl = router.constructRouteUrl(route, {
@@ -631,14 +612,14 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       }
     });
     return foundTabRouteUrl;
-  };
-
-  _proto.findRouteByKey = function findRouteByKey(key, value) {
-    var router = this;
-    var routes = router.routes;
-    var flattenedRoutes = router.flattenRoutes(routes);
-    var matchingRoute;
-    flattenedRoutes.forEach(function (route) {
+  }
+
+  findRouteByKey(key, value) {
+    const router = this;
+    const routes = router.routes;
+    const flattenedRoutes = router.flattenRoutes(routes);
+    let matchingRoute;
+    flattenedRoutes.forEach(route => {
       if (matchingRoute) return;
 
       if (route[key] === value) {
@@ -646,44 +627,43 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       }
     });
     return matchingRoute;
-  };
+  }
 
-  _proto.findMatchingRoute = function findMatchingRoute(url) {
+  findMatchingRoute(url) {
     if (!url) return undefined;
-    var router = this;
-    var routes = router.routes;
-    var flattenedRoutes = router.flattenRoutes(routes);
-
-    var _router$parseRouteUrl = router.parseRouteUrl(url),
-        path = _router$parseRouteUrl.path,
-        query = _router$parseRouteUrl.query,
-        hash = _router$parseRouteUrl.hash,
-        params = _router$parseRouteUrl.params;
-
-    var matchingRoute;
-    flattenedRoutes.forEach(function (route) {
+    const router = this;
+    const routes = router.routes;
+    const flattenedRoutes = router.flattenRoutes(routes);
+    const {
+      path,
+      query,
+      hash,
+      params
+    } = router.parseRouteUrl(url);
+    let matchingRoute;
+    flattenedRoutes.forEach(route => {
       if (matchingRoute) return;
-      var keys = [];
-      var pathsToMatch = [route.path];
+      const keys = [];
+      const pathsToMatch = [route.path];
 
       if (route.alias) {
         if (typeof route.alias === 'string') pathsToMatch.push(route.alias);else if (Array.isArray(route.alias)) {
-          route.alias.forEach(function (aliasPath) {
+          route.alias.forEach(aliasPath => {
             pathsToMatch.push(aliasPath);
           });
         }
       }
 
-      var matched;
-      pathsToMatch.forEach(function (pathToMatch) {
+      let matched;
+      pathsToMatch.forEach(pathToMatch => {
         if (matched) return;
         matched = pathToRegexp(pathToMatch, keys).exec(path);
       });
 
       if (matched) {
-        keys.forEach(function (keyObj, index) {
+        keys.forEach((keyObj, index) => {
           if (typeof keyObj.name === 'number') return;
-          var paramValue = matched[index + 1];
+          const paramValue = matched[index + 1];
 
           if (typeof paramValue === 'undefined' || paramValue === null) {
             params[keyObj.name] = paramValue;
@@ -691,75 +671,69 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
             params[keyObj.name] = decodeURIComponent(paramValue);
           }
         });
-        var parentPath;
+        let parentPath;
 
         if (route.parentPath) {
           parentPath = path.split('/').slice(0, route.parentPath.split('/').length - 1).join('/');
         }
 
         matchingRoute = {
-          query: query,
-          hash: hash,
-          params: params,
-          url: url,
-          path: path,
-          parentPath: parentPath,
-          route: route,
+          query,
+          hash,
+          params,
+          url,
+          path,
+          parentPath,
+          route,
           name: route.name
         };
       }
     });
     return matchingRoute;
   } // eslint-disable-next-line
-  ;
 
-  _proto.replaceRequestUrlParams = function replaceRequestUrlParams(url, options) {
-    if (url === void 0) {
-      url = '';
-    }
 
-    if (options === void 0) {
-      options = {};
-    }
-
-    var compiledUrl = url;
+  replaceRequestUrlParams(url = '', options = {}) {
+    let compiledUrl = url;
 
     if (typeof compiledUrl === 'string' && compiledUrl.indexOf('{{') >= 0 && options && options.route && options.route.params && Object.keys(options.route.params).length) {
-      Object.keys(options.route.params).forEach(function (paramName) {
-        var regExp = new RegExp("{{" + paramName + "}}", 'g');
+      Object.keys(options.route.params).forEach(paramName => {
+        const regExp = new RegExp(`{{${paramName}}}`, 'g');
         compiledUrl = compiledUrl.replace(regExp, options.route.params[paramName] || '');
       });
     }
 
     return compiledUrl;
-  };
+  }
 
-  _proto.removeFromXhrCache = function removeFromXhrCache(url) {
-    var router = this;
-    var xhrCache = router.cache.xhr;
-    var index = false;
+  removeFromXhrCache(url) {
+    const router = this;
+    const xhrCache = router.cache.xhr;
+    let index = false;
 
-    for (var i = 0; i < xhrCache.length; i += 1) {
+    for (let i = 0; i < xhrCache.length; i += 1) {
       if (xhrCache[i].url === url) index = i;
     }
 
     if (index !== false) xhrCache.splice(index, 1);
-  };
+  }
 
-  _proto.xhrRequest = function xhrRequest(requestUrl, options) {
-    var router = this;
-    var params = router.params;
-    var ignoreCache = options.ignoreCache;
-    var url = requestUrl;
-    var hasQuery = url.indexOf('?') >= 0;
+  xhrRequest(requestUrl, options) {
+    const router = this;
+    const params = router.params;
+    const {
+      ignoreCache
+    } = options;
+    let url = requestUrl;
+    let hasQuery = url.indexOf('?') >= 0;
 
     if (params.passRouteQueryToRequest && options && options.route && options.route.query && Object.keys(options.route.query).length) {
-      url += "" + (hasQuery ? '&' : '?') + serializeObject(options.route.query);
+      url += `${hasQuery ? '&' : '?'}${serializeObject(options.route.query)}`;
       hasQuery = true;
     }
 
     if (params.passRouteParamsToRequest && options && options.route && options.route.params && Object.keys(options.route.params).length) {
-      url += "" + (hasQuery ? '&' : '?') + serializeObject(options.route.params);
+      url += `${hasQuery ? '&' : '?'}${serializeObject(options.route.params)}`;
       hasQuery = true;
     }
 
@@ -772,10 +746,10 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       url = url.split('?')[0];
     }
 
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       if (params.xhrCache && !ignoreCache && url.indexOf('nocache') < 0 && params.xhrCacheIgnore.indexOf(url) < 0) {
-        for (var i = 0; i < router.cache.xhr.length; i += 1) {
-          var cachedUrl = router.cache.xhr[i];
+        for (let i = 0; i < router.cache.xhr.length; i += 1) {
+          const cachedUrl = router.cache.xhr[i];
 
           if (cachedUrl.url === url) {
             // Check expiration
@@ -791,19 +765,21 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       router.xhrAbortController = router.app.request.abortController();
       router.app.request({
         abortController: router.xhrAbortController,
-        url: url,
+        url,
         method: 'GET',
-        beforeSend: function beforeSend(xhr) {
+
+        beforeSend(xhr) {
           router.emit('routerAjaxStart', xhr, options);
         },
-        complete: function complete(xhr, status) {
+
+        complete(xhr, status) {
           router.emit('routerAjaxComplete', xhr);
 
           if (status !== 'error' && status !== 'timeout' && xhr.status >= 200 && xhr.status < 300 || xhr.status === 0) {
             if (params.xhrCache && xhr.responseText !== '') {
               router.removeFromXhrCache(url);
               router.cache.xhr.push({
-                url: url,
+                url,
                 time: now(),
                 content: xhr.responseText
               });
@@ -816,20 +792,22 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
             reject(xhr);
           }
         },
-        error: function error(xhr) {
+
+        error(xhr) {
           router.emit('routerAjaxError', xhr, options);
           reject(xhr);
         }
+
       });
     });
-  };
+  }
 
-  _proto.setNavbarPosition = function setNavbarPosition($el, position, ariaHidden) {
-    var router = this;
+  setNavbarPosition($el, position, ariaHidden) {
+    const router = this;
     $el.removeClass('navbar-previous navbar-current navbar-next');
 
     if (position) {
-      $el.addClass("navbar-" + position);
+      $el.addClass(`navbar-${position}`);
     }
 
     if (ariaHidden === false) {
@@ -839,15 +817,15 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     $el.trigger('navbar:position', {
-      position: position
+      position
     });
     router.emit('navbarPosition', $el[0], position);
-  };
+  }
 
-  _proto.setPagePosition = function setPagePosition($el, position, ariaHidden) {
-    var router = this;
+  setPagePosition($el, position, ariaHidden) {
+    const router = this;
     $el.removeClass('page-previous page-current page-next');
-    $el.addClass("page-" + position);
+    $el.addClass(`page-${position}`);
 
     if (ariaHidden === false) {
       $el.removeAttr('aria-hidden');
@@ -856,16 +834,16 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     $el.trigger('page:position', {
-      position: position
+      position
     });
     router.emit('pagePosition', $el[0], position);
   } // Remove theme elements
-  ;
 
-  _proto.removeThemeElements = function removeThemeElements(el) {
-    var router = this;
-    var theme = router.app.theme;
-    var toRemove;
+
+  removeThemeElements(el) {
+    const router = this;
+    const theme = router.app.theme;
+    let toRemove;
 
     if (theme === 'ios') {
       toRemove = '.md-only, .aurora-only, .if-md, .if-aurora, .if-not-ios, .not-ios';
@@ -876,24 +854,20 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     $(el).find(toRemove).remove();
-  };
-
-  _proto.getPageData = function getPageData(pageEl, navbarEl, from, to, route, pageFromEl) {
-    if (route === void 0) {
-      route = {};
-    }
+  }
 
-    var router = this;
-    var $pageEl = $(pageEl).eq(0);
-    var $navbarEl = $(navbarEl).eq(0);
-    var currentPage = $pageEl[0].f7Page || {};
-    var direction;
-    var pageFrom;
+  getPageData(pageEl, navbarEl, from, to, route = {}, pageFromEl) {
+    const router = this;
+    const $pageEl = $(pageEl).eq(0);
+    const $navbarEl = $(navbarEl).eq(0);
+    const currentPage = $pageEl[0].f7Page || {};
+    let direction;
+    let pageFrom;
     if (from === 'next' && to === 'current' || from === 'current' && to === 'previous') direction = 'forward';
     if (from === 'current' && to === 'next' || from === 'previous' && to === 'current') direction = 'backward';
 
     if (currentPage && !currentPage.fromPage) {
-      var $pageFromEl = $(pageFromEl);
+      const $pageFromEl = $(pageFromEl);
 
       if ($pageFromEl.length) {
         pageFrom = $pageFromEl[0].f7Page;
@@ -906,56 +880,53 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       pageFrom.pageFrom = null;
     }
 
-    var page = {
+    const page = {
       app: router.app,
       view: router.view,
-      router: router,
+      router,
       $el: $pageEl,
       el: $pageEl[0],
-      $pageEl: $pageEl,
+      $pageEl,
       pageEl: $pageEl[0],
-      $navbarEl: $navbarEl,
+      $navbarEl,
       navbarEl: $navbarEl[0],
       name: $pageEl.attr('data-name'),
       position: from,
-      from: from,
-      to: to,
-      direction: direction,
+      from,
+      to,
+      direction,
       route: currentPage.route ? currentPage.route : route,
-      pageFrom: pageFrom
+      pageFrom
     };
     $pageEl[0].f7Page = page;
     return page;
   } // Callbacks
-  ;
 
-  _proto.pageCallback = function pageCallback(callback, pageEl, navbarEl, from, to, options, pageFromEl) {
-    if (options === void 0) {
-      options = {};
-    }
 
+  pageCallback(callback, pageEl, navbarEl, from, to, options = {}, pageFromEl) {
     if (!pageEl) return;
-    var router = this;
-    var $pageEl = $(pageEl);
+    const router = this;
+    const $pageEl = $(pageEl);
     if (!$pageEl.length) return;
-    var $navbarEl = $(navbarEl);
-    var _options = options,
-        route = _options.route;
-    var restoreScrollTopOnBack = router.params.restoreScrollTopOnBack && !(router.params.masterDetailBreakpoint > 0 && $pageEl.hasClass('page-master') && router.app.width >= router.params.masterDetailBreakpoint);
-    var keepAlive = $pageEl[0].f7Page && $pageEl[0].f7Page.route && $pageEl[0].f7Page.route.route && $pageEl[0].f7Page.route.route.keepAlive;
+    const $navbarEl = $(navbarEl);
+    const {
+      route
+    } = options;
+    const restoreScrollTopOnBack = router.params.restoreScrollTopOnBack && !(router.params.masterDetailBreakpoint > 0 && $pageEl.hasClass('page-master') && router.app.width >= router.params.masterDetailBreakpoint);
+    const keepAlive = $pageEl[0].f7Page && $pageEl[0].f7Page.route && $pageEl[0].f7Page.route.route && $pageEl[0].f7Page.route.route.keepAlive;
 
     if (callback === 'beforeRemove' && keepAlive) {
       callback = 'beforeUnmount'; // eslint-disable-line
     }
 
-    var camelName = "page" + (callback[0].toUpperCase() + callback.slice(1, callback.length));
-    var colonName = "page:" + callback.toLowerCase();
-    var page = {};
+    const camelName = `page${callback[0].toUpperCase() + callback.slice(1, callback.length)}`;
+    const colonName = `page:${callback.toLowerCase()}`;
+    let page = {};
 
     if (callback === 'beforeRemove' && $pageEl[0].f7Page) {
       page = extend($pageEl[0].f7Page, {
-        from: from,
-        to: to,
+        from,
+        to,
         position: from
       });
     } else {
@@ -963,12 +934,10 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     page.swipeBack = !!options.swipeBack;
-
-    var _ref2 = options.route ? options.route.route : {},
-        _ref2$on = _ref2.on,
-        on = _ref2$on === void 0 ? {} : _ref2$on,
-        _ref2$once = _ref2.once,
-        once = _ref2$once === void 0 ? {} : _ref2$once;
+    const {
+      on = {},
+      once = {}
+    } = options.route ? options.route.route : {};
 
     if (options.on) {
       extend(on, options.on);
@@ -984,7 +953,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
       if (on && Object.keys(on).length > 0) {
         $pageEl[0].f7RouteEventsOn = on;
-        Object.keys(on).forEach(function (eventName) {
+        Object.keys(on).forEach(eventName => {
           on[eventName] = on[eventName].bind(router);
           $pageEl.on(eventNameToColonCase(eventName), on[eventName]);
         });
@@ -992,7 +961,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
       if (once && Object.keys(once).length > 0) {
         $pageEl[0].f7RouteEventsOnce = once;
-        Object.keys(once).forEach(function (eventName) {
+        Object.keys(once).forEach(eventName => {
           once[eventName] = once[eventName].bind(router);
           $pageEl.once(eventNameToColonCase(eventName), once[eventName]);
         });
@@ -1003,13 +972,13 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       if (!$pageEl[0].f7RouteEventsAttached) return;
 
       if ($pageEl[0].f7RouteEventsOn) {
-        Object.keys($pageEl[0].f7RouteEventsOn).forEach(function (eventName) {
+        Object.keys($pageEl[0].f7RouteEventsOn).forEach(eventName => {
           $pageEl.off(eventNameToColonCase(eventName), $pageEl[0].f7RouteEventsOn[eventName]);
         });
       }
 
       if ($pageEl[0].f7RouteEventsOnce) {
-        Object.keys($pageEl[0].f7RouteEventsOnce).forEach(function (eventName) {
+        Object.keys($pageEl[0].f7RouteEventsOnce).forEach(eventName => {
           $pageEl.off(eventNameToColonCase(eventName), $pageEl[0].f7RouteEventsOnce[eventName]);
         });
       }
@@ -1028,11 +997,11 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
     if (callback === 'init') {
       if (restoreScrollTopOnBack && (from === 'previous' || !from) && to === 'current' && router.scrollHistory[page.route.url] && !$pageEl.hasClass('no-restore-scroll')) {
-        var $pageContent = $pageEl.find('.page-content');
+        let $pageContent = $pageEl.find('.page-content');
 
         if ($pageContent.length > 0) {
           // eslint-disable-next-line
-          $pageContent = $pageContent.filter(function (pageContentEl) {
+          $pageContent = $pageContent.filter(pageContentEl => {
             return $(pageContentEl).parents('.tab:not(.tab-active)').length === 0 && !$(pageContentEl).is('.tab:not(.tab-active)');
           });
         }
@@ -1053,16 +1022,16 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
     if (restoreScrollTopOnBack && callback === 'beforeOut' && from === 'current' && to === 'previous') {
       // Save scroll position
-      var _$pageContent = $pageEl.find('.page-content');
+      let $pageContent = $pageEl.find('.page-content');
 
-      if (_$pageContent.length > 0) {
+      if ($pageContent.length > 0) {
         // eslint-disable-next-line
-        _$pageContent = _$pageContent.filter(function (pageContentEl) {
+        $pageContent = $pageContent.filter(pageContentEl => {
           return $(pageContentEl).parents('.tab:not(.tab-active)').length === 0 && !$(pageContentEl).is('.tab:not(.tab-active)');
         });
       }
 
-      router.scrollHistory[page.route.url] = _$pageContent.scrollTop();
+      router.scrollHistory[page.route.url] = $pageContent.scrollTop();
     }
 
     if (restoreScrollTopOnBack && callback === 'beforeOut' && from === 'current' && to === 'next') {
@@ -1084,37 +1053,37 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         $pageEl[0].f7Page = null;
       }
     }
-  };
+  }
 
-  _proto.saveHistory = function saveHistory() {
-    var router = this;
-    var window = getWindow();
+  saveHistory() {
+    const router = this;
+    const window = getWindow();
     router.view.history = router.history;
 
     if (router.params.browserHistory && router.params.browserHistoryStoreHistory && window.localStorage) {
-      window.localStorage["f7router-" + router.view.id + "-history"] = JSON.stringify(router.history);
+      window.localStorage[`f7router-${router.view.id}-history`] = JSON.stringify(router.history);
     }
-  };
+  }
 
-  _proto.restoreHistory = function restoreHistory() {
-    var router = this;
-    var window = getWindow();
+  restoreHistory() {
+    const router = this;
+    const window = getWindow();
 
-    if (router.params.browserHistory && router.params.browserHistoryStoreHistory && window.localStorage && window.localStorage["f7router-" + router.view.id + "-history"]) {
-      router.history = JSON.parse(window.localStorage["f7router-" + router.view.id + "-history"]);
+    if (router.params.browserHistory && router.params.browserHistoryStoreHistory && window.localStorage && window.localStorage[`f7router-${router.view.id}-history`]) {
+      router.history = JSON.parse(window.localStorage[`f7router-${router.view.id}-history`]);
       router.view.history = router.history;
     }
-  };
+  }
 
-  _proto.clearHistory = function clearHistory() {
-    var router = this;
+  clearHistory() {
+    const router = this;
     router.history = [];
     if (router.view) router.view.history = [];
     router.saveHistory();
-  };
+  }
 
-  _proto.updateCurrentUrl = function updateCurrentUrl(newUrl) {
-    var router = this;
+  updateCurrentUrl(newUrl) {
+    const router = this;
     appRouterCheck(router, 'updateCurrentUrl'); // Update history
 
     if (router.history.length) {
@@ -1124,25 +1093,26 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     } // Update current route params
 
 
-    var _router$parseRouteUrl2 = router.parseRouteUrl(newUrl),
-        query = _router$parseRouteUrl2.query,
-        hash = _router$parseRouteUrl2.hash,
-        params = _router$parseRouteUrl2.params,
-        url = _router$parseRouteUrl2.url,
-        path = _router$parseRouteUrl2.path;
+    const {
+      query,
+      hash,
+      params,
+      url,
+      path
+    } = router.parseRouteUrl(newUrl);
 
     if (router.currentRoute) {
       extend(router.currentRoute, {
-        query: query,
-        hash: hash,
-        params: params,
-        url: url,
-        path: path
+        query,
+        hash,
+        params,
+        url,
+        path
       });
     }
 
     if (router.params.browserHistory) {
-      var browserHistoryRoot = router.params.browserHistoryRoot || '';
+      const browserHistoryRoot = router.params.browserHistoryRoot || '';
       History.replace(router.view.id, {
         url: newUrl
       }, browserHistoryRoot + router.params.browserHistorySeparator + newUrl);
@@ -1151,10 +1121,10 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
     router.saveHistory();
     router.emit('routeUrlUpdate', router.currentRoute, router);
-  };
+  }
 
-  _proto.getInitialUrl = function getInitialUrl() {
-    var router = this;
+  getInitialUrl() {
+    const router = this;
 
     if (router.initialUrl) {
       return {
@@ -1163,19 +1133,24 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
       };
     }
 
-    var app = router.app,
-        view = router.view;
-    var document = getDocument();
-    var window = getWindow();
-    var location = app.params.url && typeof app.params.url === 'string' && typeof URL !== 'undefined' ? new URL(app.params.url) : document.location;
-    var initialUrl = router.params.url;
-    var documentUrl = location.href.split(location.origin)[1];
-    var historyRestored;
-    var _router$params = router.params,
-        browserHistory = _router$params.browserHistory,
-        browserHistoryOnLoad = _router$params.browserHistoryOnLoad,
-        browserHistorySeparator = _router$params.browserHistorySeparator;
-    var browserHistoryRoot = router.params.browserHistoryRoot;
+    const {
+      app,
+      view
+    } = router;
+    const document = getDocument();
+    const window = getWindow();
+    const location = app.params.url && typeof app.params.url === 'string' && typeof URL !== 'undefined' ? new URL(app.params.url) : document.location;
+    let initialUrl = router.params.url;
+    let documentUrl = location.href.split(location.origin)[1];
+    let historyRestored;
+    const {
+      browserHistory,
+      browserHistoryOnLoad,
+      browserHistorySeparator
+    } = router.params;
+    let {
+      browserHistoryRoot
+    } = router.params;
 
     if ((window.cordova || window.Capacitor && window.Capacitor.isNative) && browserHistory && !browserHistorySeparator && !browserHistoryRoot && location.pathname.indexOf('index.html')) {
       // eslint-disable-next-line
@@ -1231,37 +1206,39 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     router.initialUrl = initialUrl;
     router.historyRestored = historyRestored;
     return {
-      initialUrl: initialUrl,
-      historyRestored: historyRestored
+      initialUrl,
+      historyRestored
     };
-  };
+  }
 
-  _proto.init = function init() {
-    var router = this;
-    var app = router.app,
-        view = router.view;
-    var document = getDocument();
+  init() {
+    const router = this;
+    const {
+      app,
+      view
+    } = router;
+    const document = getDocument();
     router.mount();
-
-    var _router$getInitialUrl = router.getInitialUrl(),
-        initialUrl = _router$getInitialUrl.initialUrl,
-        historyRestored = _router$getInitialUrl.historyRestored; // Init Swipeback
-
+    const {
+      initialUrl,
+      historyRestored
+    } = router.getInitialUrl(); // Init Swipeback
 
     if (view && router.params.iosSwipeBack && app.theme === 'ios' || view && router.params.mdSwipeBack && app.theme === 'md' || view && router.params.auroraSwipeBack && app.theme === 'aurora') {
       SwipeBack(router);
     }
 
-    var _router$params2 = router.params,
-        browserHistory = _router$params2.browserHistory,
-        browserHistoryOnLoad = _router$params2.browserHistoryOnLoad,
-        browserHistoryAnimateOnLoad = _router$params2.browserHistoryAnimateOnLoad,
-        browserHistoryInitialMatch = _router$params2.browserHistoryInitialMatch;
-    var currentRoute;
+    const {
+      browserHistory,
+      browserHistoryOnLoad,
+      browserHistoryAnimateOnLoad,
+      browserHistoryInitialMatch
+    } = router.params;
+    let currentRoute;
 
     if (router.history.length > 1) {
       // Will load page
-      var initUrl = browserHistoryInitialMatch ? initialUrl : router.history[0];
+      const initUrl = browserHistoryInitialMatch ? initialUrl : router.history[0];
       currentRoute = router.findMatchingRoute(initUrl);
 
       if (!currentRoute) {
@@ -1287,8 +1264,8 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     if (router.params.stackPages) {
-      router.$el.children('.page').each(function (pageEl) {
-        var $pageEl = $(pageEl);
+      router.$el.children('.page').each(pageEl => {
+        const $pageEl = $(pageEl);
         router.initialPages.push($pageEl[0]);
 
         if (router.dynamicNavbar && $pageEl.children('.navbar').length > 0) {
@@ -1305,9 +1282,9 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
         browserHistory: false,
         animate: false,
         once: {
-          modalOpen: function modalOpen() {
+          modalOpen() {
             if (!historyRestored) return;
-            var preloadPreviousPage = router.params.preloadPreviousPage || router.params[app.theme + "SwipeBack"];
+            const preloadPreviousPage = router.params.preloadPreviousPage || router.params[`${app.theme}SwipeBack`];
 
             if (preloadPreviousPage && router.history.length > 1) {
               router.back({
@@ -1315,9 +1292,10 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
               });
             }
           },
-          pageAfterIn: function pageAfterIn() {
+
+          pageAfterIn() {
             if (!historyRestored) return;
-            var preloadPreviousPage = router.params.preloadPreviousPage || router.params[app.theme + "SwipeBack"];
+            const preloadPreviousPage = router.params.preloadPreviousPage || router.params[`${app.theme}SwipeBack`];
 
             if (preloadPreviousPage && router.history.length > 1) {
               router.back({
@@ -1325,15 +1303,16 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
               });
             }
           }
+
         }
       });
     } else if (router.$el.children('.page:not(.stacked)').length) {
       // Init current DOM page
-      var hasTabRoute;
+      let hasTabRoute;
       router.currentRoute = currentRoute;
-      router.$el.children('.page:not(.stacked)').each(function (pageEl) {
-        var $pageEl = $(pageEl);
-        var $navbarEl;
+      router.$el.children('.page:not(.stacked)').each(pageEl => {
+        const $pageEl = $(pageEl);
+        let $navbarEl;
         router.setPagePosition($pageEl, 'current');
 
         if (router.dynamicNavbar) {
@@ -1374,7 +1353,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
           view.checkMasterDetailBreakpoint();
         }
 
-        var initOptions = {
+        const initOptions = {
           route: router.currentRoute
         };
 
@@ -1406,7 +1385,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
 
       if (historyRestored) {
         if (browserHistoryInitialMatch) {
-          var preloadPreviousPage = router.params.preloadPreviousPage || router.params[app.theme + "SwipeBack"];
+          const preloadPreviousPage = router.params.preloadPreviousPage || router.params[`${app.theme}SwipeBack`];
 
           if (preloadPreviousPage && router.history.length > 1) {
             router.back({
@@ -1420,8 +1399,8 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
             history: false,
             animate: browserHistoryAnimateOnLoad,
             once: {
-              pageAfterIn: function pageAfterIn() {
-                var preloadPreviousPage = router.params.preloadPreviousPage || router.params[app.theme + "SwipeBack"];
+              pageAfterIn() {
+                const preloadPreviousPage = router.params.preloadPreviousPage || router.params[`${app.theme}SwipeBack`];
 
                 if (preloadPreviousPage && router.history.length > 2) {
                   router.back({
@@ -1429,6 +1408,7 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
                   });
                 }
               }
+
             }
           });
         }
@@ -1447,21 +1427,20 @@ var Router = /*#__PURE__*/function (_Framework7Class) {
     }
 
     router.emit('local::init routerInit', router);
-  };
+  }
 
-  _proto.destroy = function destroy() {
-    var router = this;
+  destroy() {
+    let router = this;
     router.emit('local::destroy routerDestroy', router); // Delete props & methods
 
-    Object.keys(router).forEach(function (routerProp) {
+    Object.keys(router).forEach(routerProp => {
       router[routerProp] = null;
       delete router[routerProp];
     });
     router = null;
-  };
+  }
 
-  return Router;
-}(Framework7Class); // Load
+} // Load
 
 
 Router.prototype.navigate = navigate;