ember-source 3.24.0 → 3.24.4

package/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   3.24.0
+ * @version   3.24.4
  */
 /*globals process */
 var define, require, Ember; // Used in @ember/-internals/environment/lib/global.js
@@ -4355,7 +4355,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@ember/polyfills", "@glim
     init() {
       this._super(...arguments);
 
-      (true && !(!this._isEngine || this._engineMountPoint !== undefined) && (0, _debug.assert)('You attempted to use the <LinkTo> component within a routeless engine, this is not supported. ' + 'If you are using the ember-engines addon, use the <LinkToExternal> component instead. ' + 'See https://ember-engines.com/docs/links for more info.', !this._isEngine || this._engineMountPoint !== undefined)); // Map desired event name to invoke function
+      this.assertLinkToOrigin(); // Map desired event name to invoke function
 
       var {
         eventName
@@ -4377,7 +4377,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@ember/polyfills", "@glim
       var {
         route
       } = this;
-      return this._namespaceRoute(route === UNDEFINED ? this._currentRoute : route);
+      return route === UNDEFINED ? this._currentRoute : this._namespaceRoute(route);
     }),
     _models: (0, _metal.computed)('model', 'models', function computeLinkToComponentModels() {
       var {
@@ -4467,6 +4467,10 @@ define("@ember/-internals/glimmer/index", ["exports", "@ember/polyfills", "@glim
       return this._isActive(target);
     }),
 
+    assertLinkToOrigin() {
+      (true && !(!this._isEngine || this._engineMountPoint !== undefined) && (0, _debug.assert)('You attempted to use the <LinkTo> component within a routeless engine, this is not supported. ' + 'If you are using the ember-engines addon, use the <LinkToExternal> component instead. ' + 'See https://ember-engines.com/docs/links for more info.', !this._isEngine || this._engineMountPoint !== undefined));
+    },
+
     _isActive(routerState) {
       if (this.loading) {
         return false;
@@ -18468,7 +18472,7 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
     currentRoute: (0, _computed.readOnly)('_router.currentRoute')
   });
 });
-define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/object/computed", "@ember/polyfills", "@ember/service"], function (_exports, _computed, _polyfills, _service) {
+define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/-internals/owner", "@ember/-internals/utils", "@ember/object/computed", "@ember/polyfills", "@ember/service"], function (_exports, _owner, _utils, _computed, _polyfills, _service) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -18479,7 +18483,7 @@ define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/obj
   /**
   @module ember
   */
-
+  var ROUTER = (0, _utils.symbol)('ROUTER');
   /**
     The Routing service is used by LinkComponent, and provides facilities for
     the component/view layer to interact with the router.
@@ -18490,7 +18494,21 @@ define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/obj
     @private
     @class RoutingService
   */
+
   class RoutingService extends _service.default {
+    get router() {
+      var router = this[ROUTER];
+
+      if (router !== undefined) {
+        return router;
+      }
+
+      var owner = (0, _owner.getOwner)(this);
+      router = owner.lookup('router:main');
+      router.setupRouter();
+      return this[ROUTER] = router;
+    }
+
     hasRoute(routeName) {
       return this.router.hasRoute(routeName);
     }
@@ -18509,13 +18527,7 @@ define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/obj
       this.router._prepareQueryParams(routeName, models, queryParams);
     }
 
-    generateURL(routeName, models, queryParams) {
-      var router = this.router; // return early when the router microlib is not present, which is the case for {{link-to}} in integration tests
-
-      if (!router._routerMicrolib) {
-        return;
-      }
-
+    _generateURL(routeName, models, queryParams) {
       var visibleQueryParams = {};
 
       if (queryParams) {
@@ -18523,11 +18535,25 @@ define("@ember/-internals/routing/lib/services/routing", ["exports", "@ember/obj
         this.normalizeQueryParams(routeName, models, visibleQueryParams);
       }
 
-      return router.generate(routeName, ...models, {
+      return this.router.generate(routeName, ...models, {
         queryParams: visibleQueryParams
       });
     }
 
+    generateURL(routeName, models, queryParams) {
+      if (this.router._initialTransitionStarted) {
+        return this._generateURL(routeName, models, queryParams);
+      } else {
+        // Swallow error when transition has not started.
+        // When rendering in tests without visit(), we cannot infer the route context which <LinkTo/> needs be aware of
+        try {
+          return this._generateURL(routeName, models, queryParams);
+        } catch (_e) {
+          return;
+        }
+      }
+    }
+
     isActiveForRoute(contexts, queryParams, routeName, routerState) {
       var handlers = this.router._routerMicrolib.recognizer.handlersFor(routeName);
 
@@ -21598,6 +21624,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
     constructor() {
       super(...arguments);
       this._didSetupRouter = false;
+      this._initialTransitionStarted = false;
       this.currentURL = null;
       this.currentRouteName = null;
       this.currentPath = null;
@@ -21726,7 +21753,13 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
         }
 
         routeWillChange(transition) {
-          router.trigger('routeWillChange', transition);
+          router.trigger('routeWillChange', transition); // in case of intermediate transition we update the current route
+          // to make router.currentRoute.name consistent with router.currentRouteName
+          // see https://github.com/emberjs/ember.js/issues/19449
+
+          if (transition.isIntermediate) {
+            router.set('currentRoute', transition.to);
+          }
         }
 
         routeDidChange(transition) {
@@ -21973,6 +22006,8 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
     }
 
     _doURLTransition(routerJsMethod, url) {
+      this._initialTransitionStarted = true;
+
       var transition = this._routerMicrolib[routerJsMethod](url || '/');
 
       didBeginTransition(transition, this);
@@ -22090,6 +22125,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
 
     reset() {
       this._didSetupRouter = false;
+      this._initialTransitionStarted = false;
 
       if (this._routerMicrolib) {
         this._routerMicrolib.reset();
@@ -22299,6 +22335,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       var targetRouteName = _targetRouteName || (0, _utils.getActiveTargetName)(this._routerMicrolib);
 
       (true && !(Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)) && (0, _debug.assert)(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)));
+      this._initialTransitionStarted = true;
       var queryParams = {};
 
       this._processActiveTransitionQueryParams(targetRouteName, models, queryParams, _queryParams);
@@ -36727,9 +36764,7 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
     registry.injection('route', '_bucketCache', (0, _container.privatize)`-bucket-cache:main`);
     registry.injection('route', '_router', 'router:main'); // Register the routing service...
 
-    registry.register('service:-routing', _routing.RoutingService); // Then inject the app router into it
-
-    registry.injection('service:-routing', 'router', 'router:main'); // DEBUGGING
+    registry.register('service:-routing', _routing.RoutingService); // DEBUGGING
 
     registry.register('resolver-for-debugging:main', registry.resolver, {
       instantiate: false
@@ -49403,31 +49438,29 @@ define("@glimmer/runtime", ["exports", "@glimmer/util", "@glimmer/global-context
     var attribute = vm.elements().setDynamicAttribute(name, value, !!trusting, namespace);
 
     if (!(0, _reference.isConstRef)(reference)) {
-      vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute));
+      vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute, vm.env));
     }
   });
 
   class UpdateDynamicAttributeOpcode extends UpdatingOpcode {
-    constructor(reference, attribute) {
+    constructor(reference, attribute, env) {
       super();
-      this.reference = reference;
-      this.attribute = attribute;
       this.type = 'patch-element';
-      this.lastValue = (0, _reference.valueForRef)(reference);
-    }
+      var initialized = false;
+      this.updateRef = (0, _reference.createComputeRef)(() => {
+        var value = (0, _reference.valueForRef)(reference);
 
-    evaluate(vm) {
-      var {
-        attribute,
-        reference,
-        lastValue
-      } = this;
-      var currentValue = (0, _reference.valueForRef)(reference);
+        if (initialized === true) {
+          attribute.update(value, env);
+        } else {
+          initialized = true;
+        }
+      });
+      (0, _reference.valueForRef)(this.updateRef);
+    }
 
-      if (currentValue !== lastValue) {
-        attribute.update(currentValue, vm.env);
-        this.lastValue = currentValue;
-      }
+    evaluate() {
+      (0, _reference.valueForRef)(this.updateRef);
     }
 
   }
@@ -49883,7 +49916,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/util", "@glimmer/global-context
       var attribute = vm.elements().setDynamicAttribute(name, (0, _reference.valueForRef)(value), trusting, namespace);
 
       if (!(0, _reference.isConstRef)(value)) {
-        vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute));
+        vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute, vm.env));
       }
     }
   }
@@ -59685,7 +59718,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "3.24.0";
+  var _default = "3.24.4";
   _exports.default = _default;
 });
 define("node-module/index", ["exports"], function (_exports) {
@@ -60623,24 +60656,26 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
   _exports.logAbort = logAbort;
   _exports.InternalRouteInfo = _exports.TransitionError = _exports.TransitionState = _exports.QUERY_PARAMS_SYMBOL = _exports.PARAMS_SYMBOL = _exports.STATE_SYMBOL = _exports.InternalTransition = _exports.default = void 0;
 
-  var TransitionAbortedError = function () {
-    TransitionAbortedError.prototype = Object.create(Error.prototype);
-    TransitionAbortedError.prototype.constructor = TransitionAbortedError;
+  function buildTransitionAborted() {
+    var error = new Error('TransitionAborted');
+    error.name = 'TransitionAborted';
+    error.code = 'TRANSITION_ABORTED';
+    return error;
+  }
 
-    function TransitionAbortedError(message) {
-      var error = Error.call(this, message);
-      this.name = 'TransitionAborted';
-      this.message = message || 'TransitionAborted';
+  function isTransitionAborted(maybeError) {
+    return typeof maybeError === 'object' && maybeError !== null && maybeError.code === 'TRANSITION_ABORTED';
+  }
 
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, TransitionAbortedError);
-      } else {
-        this.stack = error.stack;
-      }
-    }
+  function isAbortable(maybeAbortable) {
+    return typeof maybeAbortable === 'object' && maybeAbortable !== null && typeof maybeAbortable.isAborted === 'boolean';
+  }
 
-    return TransitionAbortedError;
-  }();
+  function throwIfAborted(maybe) {
+    if (isAbortable(maybe) && maybe.isAborted) {
+      throw buildTransitionAborted();
+    }
+  }
 
   var slice = Array.prototype.slice;
   var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -60798,7 +60833,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
   _exports.PARAMS_SYMBOL = PARAMS_SYMBOL;
   var QUERY_PARAMS_SYMBOL = `__QPS__-2619863929824844-32323`;
   /**
-    A Transition is a thennable (a promise-like object) that represents
+    A Transition is a thenable (a promise-like object) that represents
     an attempt to transition to another route. It can be aborted, either
     explicitly via `abort` or by attempting another transition while a
     previous one is still underway. An aborted transition can also
@@ -60829,6 +60864,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       this.isCausedByInitialTransition = false;
       this.isCausedByAbortingReplaceTransition = false;
       this._visibleQueryParams = {};
+      this.isIntermediate = false;
       this[STATE_SYMBOL] = state || router.state;
       this.intent = intent;
       this.router = router;
@@ -60892,14 +60928,9 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
         }
 
         this.sequence = router.currentSequence++;
-        this.promise = state.resolve(() => {
-          if (this.isAborted) {
-            return _rsvp.Promise.reject(false, promiseLabel('Transition aborted - reject'));
-          }
-
-          return _rsvp.Promise.resolve(true);
-        }, this).catch(result => {
-          return _rsvp.Promise.reject(this.router.transitionDidError(result, this));
+        this.promise = state.resolve(this).catch(result => {
+          var error = this.router.transitionDidError(result, this);
+          throw error;
         }, promiseLabel('Handle Abort'));
       } else {
         this.promise = _rsvp.Promise.resolve(this[STATE_SYMBOL]);
@@ -60933,7 +60964,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       A standard promise hook that resolves if the transition
       succeeds and rejects if it fails/redirects/aborts.
          Forwards to the internal `promise` property which you can
-      use in situations where you want to pass around a thennable,
+      use in situations where you want to pass around a thenable,
       but not the Transition itself.
          @method then
       @param {Function} onFulfilled
@@ -60966,7 +60997,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
     }
     /**
          Forwards to the internal `promise` property which you can
-      use in situations where you want to pass around a thennable,
+      use in situations where you want to pass around a thenable,
       but not the Transition itself.
          @method finally
       @param {Function} callback
@@ -61151,7 +61182,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
   function logAbort(transition) {
     log(transition.router, transition.sequence, 'detected abort.');
-    return new TransitionAbortedError();
+    return buildTransitionAborted();
   }
 
   function isTransition(obj) {
@@ -61324,8 +61355,14 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       return this.params || {};
     }
 
-    resolve(shouldContinue, transition) {
-      return _rsvp.Promise.resolve(this.routePromise).then(route => this.checkForAbort(shouldContinue, route)).then(() => this.runBeforeModelHook(transition)).then(() => this.checkForAbort(shouldContinue, null)).then(() => this.getModel(transition)).then(resolvedModel => this.checkForAbort(shouldContinue, resolvedModel)).then(resolvedModel => this.runAfterModelHook(transition, resolvedModel)).then(resolvedModel => this.becomeResolved(transition, resolvedModel));
+    resolve(transition) {
+      return _rsvp.Promise.resolve(this.routePromise).then(route => {
+        throwIfAborted(transition);
+        return route;
+      }).then(() => this.runBeforeModelHook(transition)).then(() => throwIfAborted(transition)).then(() => this.getModel(transition)).then(resolvedModel => {
+        throwIfAborted(transition);
+        return resolvedModel;
+      }).then(resolvedModel => this.runAfterModelHook(transition, resolvedModel)).then(resolvedModel => this.becomeResolved(transition, resolvedModel));
     }
 
     becomeResolved(transition, resolvedContext) {
@@ -61354,7 +61391,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       return resolved;
     }
 
-    shouldSupercede(routeInfo) {
+    shouldSupersede(routeInfo) {
       // Prefer this newer routeInfo over `other` if:
       // 1) The other one doesn't exist
       // 2) The names don't match
@@ -61450,14 +61487,6 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       });
     }
 
-    checkForAbort(shouldContinue, value) {
-      return _rsvp.Promise.resolve(shouldContinue()).then(function () {
-        // We don't care about shouldContinue's resolve value;
-        // pass along the original value passed to this fn.
-        return value;
-      }, null);
-    }
-
     stashResolvedModel(transition, resolvedModel) {
       transition.resolvedModels = transition.resolvedModels || {};
       transition.resolvedModels[this.name] = resolvedModel;
@@ -61498,7 +61527,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       this.context = context;
     }
 
-    resolve(_shouldContinue, transition) {
+    resolve(transition) {
       // A ResolvedRouteInfo just resolved with itself.
       if (transition && transition.resolvedModels) {
         transition.resolvedModels[this.name] = this.context;
@@ -61641,6 +61670,54 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
   }
 
+  function handleError(currentState, transition, error) {
+    // This is the only possible
+    // reject value of TransitionState#resolve
+    var routeInfos = currentState.routeInfos;
+    var errorHandlerIndex = transition.resolveIndex >= routeInfos.length ? routeInfos.length - 1 : transition.resolveIndex;
+    var wasAborted = transition.isAborted;
+    throw new TransitionError(error, currentState.routeInfos[errorHandlerIndex].route, wasAborted, currentState);
+  }
+
+  function resolveOneRouteInfo(currentState, transition) {
+    if (transition.resolveIndex === currentState.routeInfos.length) {
+      // This is is the only possible
+      // fulfill value of TransitionState#resolve
+      return;
+    }
+
+    var routeInfo = currentState.routeInfos[transition.resolveIndex];
+    return routeInfo.resolve(transition).then(proceed.bind(null, currentState, transition), null, currentState.promiseLabel('Proceed'));
+  }
+
+  function proceed(currentState, transition, resolvedRouteInfo) {
+    var wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved; // Swap the previously unresolved routeInfo with
+    // the resolved routeInfo
+
+    currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
+
+    if (!wasAlreadyResolved) {
+      // Call the redirect hook. The reason we call it here
+      // vs. afterModel is so that redirects into child
+      // routes don't re-run the model hooks for this
+      // already-resolved route.
+      var {
+        route
+      } = resolvedRouteInfo;
+
+      if (route !== undefined) {
+        if (route.redirect) {
+          route.redirect(resolvedRouteInfo.context, transition);
+        }
+      }
+    } // Proceed after ensuring that the redirect hook
+    // didn't abort this transition by transitioning elsewhere.
+
+
+    throwIfAborted(transition);
+    return resolveOneRouteInfo(currentState, transition);
+  }
+
   class TransitionState {
     constructor() {
       this.routeInfos = [];
@@ -61661,7 +61738,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       return promiseLabel("'" + targetName + "': " + label);
     }
 
-    resolve(shouldContinue, transition) {
+    resolve(transition) {
       // First, calculate params for this state. This is useful
       // information to provide to the various route hooks.
       var params = this.params;
@@ -61669,67 +61746,9 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
         params[routeInfo.name] = routeInfo.params || {};
         return true;
       });
-      transition.resolveIndex = 0;
-      var currentState = this;
-      var wasAborted = false; // The prelude RSVP.resolve() asyncs us into the promise land.
-
-      return _rsvp.Promise.resolve(null, this.promiseLabel('Start transition')).then(resolveOneRouteInfo, null, this.promiseLabel('Resolve route')).catch(handleError, this.promiseLabel('Handle error'));
-
-      function innerShouldContinue() {
-        return _rsvp.Promise.resolve(shouldContinue(), currentState.promiseLabel('Check if should continue')).catch(function (reason) {
-          // We distinguish between errors that occurred
-          // during resolution (e.g. before"Model/model/afterModel),
-          // and aborts due to a rejecting promise from shouldContinue().
-          wasAborted = true;
-          return _rsvp.Promise.reject(reason);
-        }, currentState.promiseLabel('Handle abort'));
-      }
-
-      function handleError(error) {
-        // This is the only possible
-        // reject value of TransitionState#resolve
-        var routeInfos = currentState.routeInfos;
-        var errorHandlerIndex = transition.resolveIndex >= routeInfos.length ? routeInfos.length - 1 : transition.resolveIndex;
-        return _rsvp.Promise.reject(new TransitionError(error, currentState.routeInfos[errorHandlerIndex].route, wasAborted, currentState));
-      }
-
-      function proceed(resolvedRouteInfo) {
-        var wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved; // Swap the previously unresolved routeInfo with
-        // the resolved routeInfo
-
-        currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
-
-        if (!wasAlreadyResolved) {
-          // Call the redirect hook. The reason we call it here
-          // vs. afterModel is so that redirects into child
-          // routes don't re-run the model hooks for this
-          // already-resolved route.
-          var {
-            route
-          } = resolvedRouteInfo;
-
-          if (route !== undefined) {
-            if (route.redirect) {
-              route.redirect(resolvedRouteInfo.context, transition);
-            }
-          }
-        } // Proceed after ensuring that the redirect hook
-        // didn't abort this transition by transitioning elsewhere.
-
-
-        return innerShouldContinue().then(resolveOneRouteInfo, null, currentState.promiseLabel('Resolve route'));
-      }
+      transition.resolveIndex = 0; // The prelude RSVP.resolve() async moves us into the promise land.
 
-      function resolveOneRouteInfo() {
-        if (transition.resolveIndex === currentState.routeInfos.length) {
-          // This is is the only possible
-          // fulfill value of TransitionState#resolve
-          return currentState;
-        }
-
-        var routeInfo = currentState.routeInfos[transition.resolveIndex];
-        return routeInfo.resolve(innerShouldContinue, transition).then(proceed, null, currentState.promiseLabel('Proceed'));
-      }
+      return _rsvp.Promise.resolve(null, this.promiseLabel('Start transition')).then(resolveOneRouteInfo.bind(null, this, transition), null, this.promiseLabel('Resolve route')).catch(handleError.bind(null, this, transition), this.promiseLabel('Handle error')).then(() => this);
     }
 
   }
@@ -61821,7 +61840,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
         var handlerToUse = oldHandlerInfo;
 
-        if (i >= invalidateIndex || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {
+        if (i >= invalidateIndex || newHandlerInfo.shouldSupersede(oldHandlerInfo)) {
           invalidateIndex = Math.min(i, invalidateIndex);
           handlerToUse = newHandlerInfo;
         }
@@ -61842,6 +61861,11 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       }
 
       merge(newState.queryParams, this.queryParams || {});
+
+      if (isIntermediate && oldState.queryParams) {
+        merge(newState.queryParams, oldState.queryParams);
+      }
+
       return newState;
     }
 
@@ -61994,14 +62018,14 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
         if (route) {
           checkHandlerAccessibility(route);
         } else {
-          // If the hanlder is being loaded asynchronously, check if we can
+          // If the handler is being loaded asynchronously, check if we can
           // access it after it has resolved
           newRouteInfo.routePromise = newRouteInfo.routePromise.then(checkHandlerAccessibility);
         }
 
         var oldRouteInfo = oldState.routeInfos[i];
 
-        if (statesDiffer || newRouteInfo.shouldSupercede(oldRouteInfo)) {
+        if (statesDiffer || newRouteInfo.shouldSupersede(oldRouteInfo)) {
           statesDiffer = true;
           newState.routeInfos[i] = newRouteInfo;
         } else {
@@ -62039,13 +62063,13 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
     map(callback) {
       this.recognizer.map(callback, function (recognizer, routes) {
-        for (var i = routes.length - 1, proceed = true; i >= 0 && proceed; --i) {
+        for (var i = routes.length - 1, _proceed = true; i >= 0 && _proceed; --i) {
           var route = routes[i];
           var handler = route.handler;
           recognizer.add(routes, {
             as: handler
           });
-          proceed = route.path === '/' || route.path === '' || handler.slice(-6) === '.index';
+          _proceed = route.path === '/' || route.path === '' || handler.slice(-6) === '.index';
         }
       });
     }
@@ -62154,6 +62178,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
       if (isIntermediate) {
         var transition = new Transition(this, undefined, newState);
+        transition.isIntermediate = true;
         this.toReadOnlyInfos(transition, newState);
         this.setupContexts(newState, transition);
         this.routeWillChange(transition);
@@ -62260,7 +62285,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
 
         return routeInfos[routeInfos.length - 1].route;
       } catch (e) {
-        if (!(e instanceof TransitionAbortedError)) {
+        if (!isTransitionAborted(e)) {
           var infos = transition[STATE_SYMBOL].routeInfos;
           transition.trigger(true, 'error', e, transition, infos[infos.length - 1].route);
           transition.abort();
@@ -62390,10 +62415,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
           }
         }
 
-        if (transition && transition.isAborted) {
-          throw new TransitionAbortedError();
-        }
-
+        throwIfAborted(transition);
         route.context = context;
 
         if (route.contextDidChange !== undefined) {
@@ -62404,10 +62426,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
           route.setup(context, transition);
         }
 
-        if (transition && transition.isAborted) {
-          throw new TransitionAbortedError();
-        }
-
+        throwIfAborted(transition);
         currentRouteInfos.push(routeInfo);
         return route;
       } // If the route doesn't exist, it means we haven't resolved the route promise yet
@@ -62537,7 +62556,7 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
         // button
 
         var initial = transition.isCausedByInitialTransition; // say you are at / and you click a link to route /foo. In /foo's
-        // route, the transition is aborted using replacewith('/bar').
+        // route, the transition is aborted using replaceWith('/bar').
         // Because the current url is still /, the history entry for / is
         // removed from the history. Clicking back will take you to the page
         // you were on before /, which is often not even the app, thus killing
@@ -62789,10 +62808,10 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
       }
 
       var targetHandler = targetRouteInfos[targetRouteInfos.length - 1].name;
-      var recogHandlers = this.recognizer.handlersFor(targetHandler);
+      var recognizerHandlers = this.recognizer.handlersFor(targetHandler);
       var index = 0;
 
-      for (len = recogHandlers.length; index < len; ++index) {
+      for (len = recognizerHandlers.length; index < len; ++index) {
         routeInfo = targetRouteInfos[index];
 
         if (routeInfo.name === routeName) {
@@ -62800,16 +62819,16 @@ define("router_js", ["exports", "@ember/polyfills", "rsvp", "route-recognizer"],
         }
       }
 
-      if (index === recogHandlers.length) {
+      if (index === recognizerHandlers.length) {
         // The provided route name isn't even in the route hierarchy.
         return false;
       }
 
       var testState = new TransitionState();
       testState.routeInfos = targetRouteInfos.slice(0, index + 1);
-      recogHandlers = recogHandlers.slice(0, index + 1);
+      recognizerHandlers = recognizerHandlers.slice(0, index + 1);
       var intent = new NamedTransitionIntent(this, targetHandler, undefined, contexts);
-      var newState = intent.applyToHandlers(testState, recogHandlers, targetHandler, true, true);
+      var newState = intent.applyToHandlers(testState, recognizerHandlers, targetHandler, true, true);
       var routesEqual = routeInfosEqual(newState.routeInfos, testState.routeInfos);
 
       if (!queryParams || !routesEqual) {