discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/router.js

@@ -1,2454 +0,0 @@
-import { Promise } from 'rsvp';
-import RouteRecognizer from 'route-recognizer';
-
-const slice = Array.prototype.slice;
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
-/**
-  Determines if an object is Promise by checking if it is "thenable".
-**/
-function isPromise(obj) {
-  return (
-    ((typeof obj === 'object' && obj !== null) || typeof obj === 'function') &&
-    typeof obj.then === 'function'
-  );
-}
-
-function merge(hash, other) {
-  for (let prop in other) {
-    if (hasOwnProperty.call(other, prop)) {
-      hash[prop] = other[prop];
-    }
-  }
-}
-
-/**
-  @private
-
-  Extracts query params from the end of an array
-**/
-function extractQueryParams(array) {
-  let len = array && array.length,
-    head,
-    queryParams;
-
-  if (
-    len &&
-    len > 0 &&
-    array[len - 1] &&
-    hasOwnProperty.call(array[len - 1], 'queryParams')
-  ) {
-    queryParams = array[len - 1].queryParams;
-    head = slice.call(array, 0, len - 1);
-    return [head, queryParams];
-  } else {
-    return [array, null];
-  }
-}
-
-/**
-  @private
-
-  Coerces query param properties and array elements into strings.
-**/
-function coerceQueryParamsToString(queryParams) {
-  for (let key in queryParams) {
-    let val = queryParams[key];
-    if (typeof val === 'number') {
-      queryParams[key] = '' + val;
-    } else if (Array.isArray(val)) {
-      for (let i = 0, l = val.length; i < l; i++) {
-        val[i] = '' + val[i];
-      }
-    }
-  }
-}
-/**
-  @private
- */
-function log(router, sequence, msg) {
-  if (!router.log) {
-    return;
-  }
-
-  if (arguments.length === 3) {
-    router.log('Transition #' + sequence + ': ' + msg);
-  } else {
-    msg = sequence;
-    router.log(msg);
-  }
-}
-
-function isParam(object) {
-  return (
-    typeof object === 'string' ||
-    object instanceof String ||
-    typeof object === 'number' ||
-    object instanceof Number
-  );
-}
-
-function forEach(array, callback) {
-  for (
-    let i = 0, l = array.length;
-    i < l && false !== callback(array[i]);
-    i++
-  ) {
-    // empty intentionally
-  }
-}
-
-function trigger(router, handlerInfos, ignoreFailure, args) {
-  if (router.triggerEvent) {
-    router.triggerEvent(handlerInfos, ignoreFailure, args);
-    return;
-  }
-
-  let name = args.shift();
-
-  if (!handlerInfos) {
-    if (ignoreFailure) {
-      return;
-    }
-    throw new Error(
-      "Could not trigger event '" + name + "'. There are no active handlers"
-    );
-  }
-
-  let eventWasHandled = false;
-
-  function delayedEvent(name, args, handler) {
-    handler.events[name].apply(handler, args);
-  }
-
-  for (let i = handlerInfos.length - 1; i >= 0; i--) {
-    let handlerInfo = handlerInfos[i],
-      handler = handlerInfo.handler;
-
-    // If there is no handler, it means the handler hasn't resolved yet which
-    // means that we should trigger the event later when the handler is available
-    if (!handler) {
-      handlerInfo.handlerPromise.then(delayedEvent.bind(null, name, args));
-      continue;
-    }
-
-    if (handler.events && handler.events[name]) {
-      if (handler.events[name].apply(handler, args) === true) {
-        eventWasHandled = true;
-      } else {
-        return;
-      }
-    }
-  }
-
-  // In the case that we got an UnrecognizedURLError as an event with no handler,
-  // let it bubble up
-  if (name === 'error' && args[0].name === 'UnrecognizedURLError') {
-    throw args[0];
-  } else if (!eventWasHandled && !ignoreFailure) {
-    throw new Error("Nothing handled the event '" + name + "'.");
-  }
-}
-
-function getChangelist(oldObject, newObject) {
-  let key;
-  let results = {
-    all: {},
-    changed: {},
-    removed: {},
-  };
-
-  merge(results.all, newObject);
-
-  let didChange = false;
-  coerceQueryParamsToString(oldObject);
-  coerceQueryParamsToString(newObject);
-
-  // Calculate removals
-  for (key in oldObject) {
-    if (hasOwnProperty.call(oldObject, key)) {
-      if (!hasOwnProperty.call(newObject, key)) {
-        didChange = true;
-        results.removed[key] = oldObject[key];
-      }
-    }
-  }
-
-  // Calculate changes
-  for (key in newObject) {
-    if (hasOwnProperty.call(newObject, key)) {
-      if (Array.isArray(oldObject[key]) && Array.isArray(newObject[key])) {
-        if (oldObject[key].length !== newObject[key].length) {
-          results.changed[key] = newObject[key];
-          didChange = true;
-        } else {
-          for (let i = 0, l = oldObject[key].length; i < l; i++) {
-            if (oldObject[key][i] !== newObject[key][i]) {
-              results.changed[key] = newObject[key];
-              didChange = true;
-            }
-          }
-        }
-      } else if (oldObject[key] !== newObject[key]) {
-        results.changed[key] = newObject[key];
-        didChange = true;
-      }
-    }
-  }
-
-  return didChange ? results : undefined;
-}
-
-function promiseLabel(label) {
-  return 'Router: ' + label;
-}
-
-function resolveHook(obj, hookName) {
-  if (!obj) {
-    return;
-  }
-  let underscored = '_' + hookName;
-  return (obj[underscored] && underscored) || (obj[hookName] && hookName);
-}
-
-function callHook(obj, _hookName, arg1, arg2) {
-  let hookName = resolveHook(obj, _hookName);
-  return hookName && obj[hookName].call(obj, arg1, arg2);
-}
-
-function applyHook(obj, _hookName, args) {
-  let hookName = resolveHook(obj, _hookName);
-  if (hookName) {
-    if (args.length === 0) {
-      return obj[hookName].call(obj);
-    } else if (args.length === 1) {
-      return obj[hookName].call(obj, args[0]);
-    } else if (args.length === 2) {
-      return obj[hookName].call(obj, args[0], args[1]);
-    } else {
-      return obj[hookName].apply(obj, args);
-    }
-  }
-}
-
-class TransitionState {
-  constructor() {
-    this.handlerInfos = [];
-    this.queryParams = {};
-    this.params = {};
-  }
-
-  promiseLabel(label) {
-    let targetName = '';
-    forEach(this.handlerInfos, function(handlerInfo) {
-      if (targetName !== '') {
-        targetName += '.';
-      }
-      targetName += handlerInfo.name;
-    });
-    return promiseLabel("'" + targetName + "': " + label);
-  }
-
-  resolve(shouldContinue, payload = {}) {
-    // First, calculate params for this state. This is useful
-    // information to provide to the various route hooks.
-    let params = this.params;
-    forEach(this.handlerInfos, function(handlerInfo) {
-      params[handlerInfo.name] = handlerInfo.params || {};
-    });
-
-    payload.resolveIndex = 0;
-
-    let currentState = this;
-    let wasAborted = false;
-
-    // The prelude RSVP.resolve() asyncs us into the promise land.
-    return Promise.resolve(null, this.promiseLabel('Start transition'))
-      .then(resolveOneHandlerInfo, null, this.promiseLabel('Resolve handler'))
-      .catch(handleError, this.promiseLabel('Handle error'));
-
-    function innerShouldContinue() {
-      return 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 Promise.reject(reason);
-      }, currentState.promiseLabel('Handle abort'));
-    }
-
-    function handleError(error) {
-      // This is the only possible
-      // reject value of TransitionState#resolve
-      let handlerInfos = currentState.handlerInfos;
-      let errorHandlerIndex =
-        payload.resolveIndex >= handlerInfos.length
-          ? handlerInfos.length - 1
-          : payload.resolveIndex;
-      return Promise.reject({
-        error: error,
-        handlerWithError: currentState.handlerInfos[errorHandlerIndex].handler,
-        wasAborted: wasAborted,
-        state: currentState,
-      });
-    }
-
-    function proceed(resolvedHandlerInfo) {
-      let wasAlreadyResolved =
-        currentState.handlerInfos[payload.resolveIndex].isResolved;
-
-      // Swap the previously unresolved handlerInfo with
-      // the resolved handlerInfo
-      currentState.handlerInfos[payload.resolveIndex++] = resolvedHandlerInfo;
-
-      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.
-        let handler = resolvedHandlerInfo.handler;
-        callHook(handler, 'redirect', resolvedHandlerInfo.context, payload);
-      }
-
-      // Proceed after ensuring that the redirect hook
-      // didn't abort this transition by transitioning elsewhere.
-      return innerShouldContinue().then(
-        resolveOneHandlerInfo,
-        null,
-        currentState.promiseLabel('Resolve handler')
-      );
-    }
-
-    function resolveOneHandlerInfo() {
-      if (payload.resolveIndex === currentState.handlerInfos.length) {
-        // This is is the only possible
-        // fulfill value of TransitionState#resolve
-        return {
-          error: null,
-          state: currentState,
-        };
-      }
-
-      let handlerInfo = currentState.handlerInfos[payload.resolveIndex];
-
-      return handlerInfo
-        .resolve(innerShouldContinue, payload)
-        .then(proceed, null, currentState.promiseLabel('Proceed'));
-    }
-  }
-}
-
-function TransitionAbortedError(message) {
-  if (!(this instanceof TransitionAbortedError)) {
-    return new TransitionAbortedError(message);
-  }
-
-  var error = Error.call(this, message);
-
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, TransitionAbortedError);
-  } else {
-    this.stack = error.stack;
-  }
-
-  this.description = error.description;
-  this.fileName = error.fileName;
-  this.lineNumber = error.lineNumber;
-  this.message = error.message || 'TransitionAborted';
-  this.name = 'TransitionAborted';
-  this.number = error.number;
-  this.code = error.code;
-}
-
-TransitionAbortedError.prototype = Object.create(Error.prototype);
-
-/**
-  A Transition is a thennable (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
-  be `retry()`d later.
-
-  @class Transition
-  @constructor
-  @param {Object} router
-  @param {Object} intent
-  @param {Object} state
-  @param {Object} error
-  @private
- */
-class Transition {
-  constructor(router, intent, state, error, previousTransition) {
-    this.state = state || router.state;
-    this.intent = intent;
-    this.router = router;
-    this.data = (this.intent && this.intent.data) || {};
-    this.resolvedModels = {};
-    this.queryParams = {};
-    this.promise = undefined;
-    this.error = undefined;
-    this.params = undefined;
-    this.handlerInfos = undefined;
-    this.targetName = undefined;
-    this.pivotHandler = undefined;
-    this.sequence = undefined;
-    this.isAborted = false;
-    this.isActive = true;
-    this.urlMethod = 'update';
-    this.resolveIndex = 0;
-    this.queryParamsOnly = false;
-    this.isTransition = true;
-
-    if (error) {
-      this.promise = Promise.reject(error);
-      this.error = error;
-      return;
-    }
-
-    // if you're doing multiple redirects, need the new transition to know if it
-    // is actually part of the first transition or not. Any further redirects
-    // in the initial transition also need to know if they are part of the
-    // initial transition
-    this.isCausedByAbortingTransition = !!previousTransition;
-    this.isCausedByInitialTransition =
-      previousTransition &&
-      (previousTransition.isCausedByInitialTransition ||
-        previousTransition.sequence === 0);
-    // Every transition in the chain is a replace
-    this.isCausedByAbortingReplaceTransition =
-      previousTransition &&
-      (previousTransition.urlMethod == 'replace' &&
-        (!previousTransition.isCausedByAbortingTransition ||
-          previousTransition.isCausedByAbortingReplaceTransition));
-
-    if (state) {
-      this.params = state.params;
-      this.queryParams = state.queryParams;
-      this.handlerInfos = state.handlerInfos;
-
-      let len = state.handlerInfos.length;
-      if (len) {
-        this.targetName = state.handlerInfos[len - 1].name;
-      }
-
-      for (let i = 0; i < len; ++i) {
-        let handlerInfo = state.handlerInfos[i];
-
-        // TODO: this all seems hacky
-        if (!handlerInfo.isResolved) {
-          break;
-        }
-        this.pivotHandler = handlerInfo.handler;
-      }
-
-      this.sequence = router.currentSequence++;
-      this.promise = state
-        .resolve(() => {
-          if (this.isAborted) {
-            return Promise.reject(
-              undefined,
-              promiseLabel('Transition aborted - reject')
-            );
-          }
-        }, this)
-        .catch(result => {
-          if (result.wasAborted || this.isAborted) {
-            return Promise.reject(logAbort(this));
-          } else {
-            this.trigger('error', result.error, this, result.handlerWithError);
-            this.abort();
-            return Promise.reject(result.error);
-          }
-        }, promiseLabel('Handle Abort'));
-    } else {
-      this.promise = Promise.resolve(this.state);
-      this.params = {};
-    }
-  }
-
-  isExiting(handler) {
-    let handlerInfos = this.handlerInfos;
-    for (let i = 0, len = handlerInfos.length; i < len; ++i) {
-      let handlerInfo = handlerInfos[i];
-      if (handlerInfo.name === handler || handlerInfo.handler === handler) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-    The Transition's internal promise. Calling `.then` on this property
-    is that same as calling `.then` on the Transition object itself, but
-    this property is exposed for when you want to pass around a
-    Transition's promise, but not the Transition object itself, since
-    Transition object can be externally `abort`ed, while the promise
-    cannot.
-
-    @property promise
-    @type {Object}
-    @public
-   */
-
-  /**
-    Custom state can be stored on a Transition's `data` object.
-    This can be useful for decorating a Transition within an earlier
-    hook and shared with a later hook. Properties set on `data` will
-    be copied to new transitions generated by calling `retry` on this
-    transition.
-
-    @property data
-    @type {Object}
-    @public
-   */
-
-  /**
-    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,
-    but not the Transition itself.
-
-    @method then
-    @param {Function} onFulfilled
-    @param {Function} onRejected
-    @param {String} label optional string for labeling the promise.
-    Useful for tooling.
-    @return {Promise}
-    @public
-   */
-  then(onFulfilled, onRejected, label) {
-    return this.promise.then(onFulfilled, onRejected, label);
-  }
-
-  /**
-
-    Forwards to the internal `promise` property which you can
-    use in situations where you want to pass around a thennable,
-    but not the Transition itself.
-
-    @method catch
-    @param {Function} onRejection
-    @param {String} label optional string for labeling the promise.
-    Useful for tooling.
-    @return {Promise}
-    @public
-   */
-  catch(onRejection, label) {
-    return this.promise.catch(onRejection, label);
-  }
-
-  /**
-
-    Forwards to the internal `promise` property which you can
-    use in situations where you want to pass around a thennable,
-    but not the Transition itself.
-
-    @method finally
-    @param {Function} callback
-    @param {String} label optional string for labeling the promise.
-    Useful for tooling.
-    @return {Promise}
-    @public
-   */
-  finally(callback, label) {
-    return this.promise.finally(callback, label);
-  }
-
-  /**
-    Aborts the Transition. Note you can also implicitly abort a transition
-    by initiating another transition while a previous one is underway.
-
-    @method abort
-    @return {Transition} this transition
-    @public
-   */
-  abort() {
-    if (this.isAborted) {
-      return this;
-    }
-    log(
-      this.router,
-      this.sequence,
-      this.targetName + ': transition was aborted'
-    );
-    this.intent.preTransitionState = this.router.state;
-    this.isAborted = true;
-    this.isActive = false;
-    this.router.activeTransition = null;
-    return this;
-  }
-
-  /**
-
-    Retries a previously-aborted transition (making sure to abort the
-    transition if it's still active). Returns a new transition that
-    represents the new attempt to transition.
-
-    @method retry
-    @return {Transition} new transition
-    @public
-   */
-  retry() {
-    // TODO: add tests for merged state retry()s
-    this.abort();
-    let newTransition = this.router.transitionByIntent(this.intent, false);
-
-    // inheriting a `null` urlMethod is not valid
-    // the urlMethod is only set to `null` when
-    // the transition is initiated *after* the url
-    // has been updated (i.e. `router.handleURL`)
-    //
-    // in that scenario, the url method cannot be
-    // inherited for a new transition because then
-    // the url would not update even though it should
-    if (this.urlMethod !== null) {
-      newTransition.method(this.urlMethod);
-    }
-    return newTransition;
-  }
-
-  /**
-
-    Sets the URL-changing method to be employed at the end of a
-    successful transition. By default, a new Transition will just
-    use `updateURL`, but passing 'replace' to this method will
-    cause the URL to update using 'replaceWith' instead. Omitting
-    a parameter will disable the URL change, allowing for transitions
-    that don't update the URL at completion (this is also used for
-    handleURL, since the URL has already changed before the
-    transition took place).
-
-    @method method
-    @param {String} method the type of URL-changing method to use
-      at the end of a transition. Accepted values are 'replace',
-      falsy values, or any other non-falsy value (which is
-      interpreted as an updateURL transition).
-
-    @return {Transition} this transition
-    @public
-   */
-  method(method) {
-    this.urlMethod = method;
-    return this;
-  }
-
-  /**
-
-    Fires an event on the current list of resolved/resolving
-    handlers within this transition. Useful for firing events
-    on route hierarchies that haven't fully been entered yet.
-
-    Note: This method is also aliased as `send`
-
-    @method trigger
-    @param {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error
-    @param {String} name the name of the event to fire
-    @public
-   */
-  trigger(ignoreFailure) {
-    let args = slice.call(arguments);
-    if (typeof ignoreFailure === 'boolean') {
-      args.shift();
-    } else {
-      // Throw errors on unhandled trigger events by default
-      ignoreFailure = false;
-    }
-    trigger(
-      this.router,
-      this.state.handlerInfos.slice(0, this.resolveIndex + 1),
-      ignoreFailure,
-      args
-    );
-  }
-
-  /**
-    Transitions are aborted and their promises rejected
-    when redirects occur; this method returns a promise
-    that will follow any redirects that occur and fulfill
-    with the value fulfilled by any redirecting transitions
-    that occur.
-
-    @method followRedirects
-    @return {Promise} a promise that fulfills with the same
-      value that the final redirecting transition fulfills with
-    @public
-   */
-  followRedirects() {
-    let router = this.router;
-    return this.promise.catch(function(reason) {
-      if (router.activeTransition) {
-        return router.activeTransition.followRedirects();
-      }
-      return Promise.reject(reason);
-    });
-  }
-
-  toString() {
-    return 'Transition (sequence ' + this.sequence + ')';
-  }
-
-  /**
-    @private
-   */
-  log(message) {
-    log(this.router, this.sequence, message);
-  }
-}
-
-// Alias 'trigger' as 'send'
-Transition.prototype.send = Transition.prototype.trigger;
-
-/**
-  @private
-
-  Logs and returns an instance of TransitionAborted.
- */
-function logAbort(transition) {
-  log(transition.router, transition.sequence, 'detected abort.');
-  return new TransitionAbortedError();
-}
-
-class TransitionIntent {
-  constructor() {
-    this.data = this.data || {};
-  }
-}
-
-const DEFAULT_HANDLER = Object.freeze({});
-
-class HandlerInfo {
-  constructor(props = {}) {
-    // initialize local properties to ensure consistent object shape
-    this._handler = DEFAULT_HANDLER;
-    this._handlerPromise = null;
-    this.factory = null; // Injected by the handler info factory
-    this.name = props.name;
-
-    for (let prop in props) {
-      if (prop === 'handler') {
-        this._processHandler(props.handler);
-      } else {
-        this[prop] = props[prop];
-      }
-    }
-  }
-
-  getHandler() {}
-
-  fetchHandler() {
-    let handler = this.getHandler(this.name);
-    return this._processHandler(handler);
-  }
-
-  _processHandler(handler) {
-    // Setup a handlerPromise so that we can wait for asynchronously loaded handlers
-    this.handlerPromise = Promise.resolve(handler);
-
-    // Wait until the 'handler' property has been updated when chaining to a handler
-    // that is a promise
-    if (isPromise(handler)) {
-      this.handlerPromise = this.handlerPromise.then(h => {
-        return this.updateHandler(h);
-      });
-      // set to undefined to avoid recursive loop in the handler getter
-      return (this.handler = undefined);
-    } else if (handler) {
-      return this.updateHandler(handler);
-    }
-  }
-
-  log(payload, message) {
-    if (payload.log) {
-      payload.log(this.name + ': ' + message);
-    }
-  }
-
-  promiseLabel(label) {
-    return promiseLabel("'" + this.name + "' " + label);
-  }
-
-  getUnresolved() {
-    return this;
-  }
-
-  serialize() {
-    return this.params || {};
-  }
-
-  updateHandler(handler) {
-    // Store the name of the handler on the handler for easy checks later
-    handler._handlerName = this.name;
-    return (this.handler = handler);
-  }
-
-  resolve(shouldContinue, payload) {
-    let checkForAbort = this.checkForAbort.bind(this, shouldContinue);
-    let beforeModel = this.runBeforeModelHook.bind(this, payload);
-    let model = this.getModel.bind(this, payload);
-    let afterModel = this.runAfterModelHook.bind(this, payload);
-    let becomeResolved = this.becomeResolved.bind(this, payload);
-
-    return Promise.resolve(
-      this.handlerPromise,
-      this.promiseLabel('Start handler')
-    )
-      .then(checkForAbort, null, this.promiseLabel('Check for abort'))
-      .then(beforeModel, null, this.promiseLabel('Before model'))
-      .then(
-        checkForAbort,
-        null,
-        this.promiseLabel("Check if aborted during 'beforeModel' hook")
-      )
-      .then(model, null, this.promiseLabel('Model'))
-      .then(
-        checkForAbort,
-        null,
-        this.promiseLabel("Check if aborted in 'model' hook")
-      )
-      .then(afterModel, null, this.promiseLabel('After model'))
-      .then(
-        checkForAbort,
-        null,
-        this.promiseLabel("Check if aborted in 'afterModel' hook")
-      )
-      .then(becomeResolved, null, this.promiseLabel('Become resolved'));
-  }
-
-  runBeforeModelHook(payload) {
-    if (payload.trigger) {
-      payload.trigger(true, 'willResolveModel', payload, this.handler);
-    }
-    return this.runSharedModelHook(payload, 'beforeModel', []);
-  }
-
-  runAfterModelHook(payload, resolvedModel) {
-    // Stash the resolved model on the payload.
-    // This makes it possible for users to swap out
-    // the resolved model in afterModel.
-    let name = this.name;
-    this.stashResolvedModel(payload, resolvedModel);
-
-    return this.runSharedModelHook(payload, 'afterModel', [resolvedModel]).then(
-      function() {
-        // Ignore the fulfilled value returned from afterModel.
-        // Return the value stashed in resolvedModels, which
-        // might have been swapped out in afterModel.
-        return payload.resolvedModels[name];
-      },
-      null,
-      this.promiseLabel('Ignore fulfillment value and return model value')
-    );
-  }
-
-  runSharedModelHook(payload, hookName, args) {
-    this.log(payload, 'calling ' + hookName + ' hook');
-
-    if (this.queryParams) {
-      args.push(this.queryParams);
-    }
-    args.push(payload);
-
-    var result = applyHook(this.handler, hookName, args);
-
-    if (result && result.isTransition) {
-      result = null;
-    }
-
-    return Promise.resolve(
-      result,
-      this.promiseLabel('Resolve value returned from one of the model hooks')
-    );
-  }
-
-  // overridden by subclasses
-  getModel() {}
-
-  checkForAbort(shouldContinue, promiseValue) {
-    return Promise.resolve(
-      shouldContinue(),
-      this.promiseLabel('Check for abort')
-    ).then(
-      function() {
-        // We don't care about shouldContinue's resolve value;
-        // pass along the original value passed to this fn.
-        return promiseValue;
-      },
-      null,
-      this.promiseLabel('Ignore fulfillment value and continue')
-    );
-  }
-
-  stashResolvedModel(payload, resolvedModel) {
-    payload.resolvedModels = payload.resolvedModels || {};
-    payload.resolvedModels[this.name] = resolvedModel;
-  }
-
-  becomeResolved(payload, resolvedContext) {
-    var params = this.serialize(resolvedContext);
-
-    if (payload) {
-      this.stashResolvedModel(payload, resolvedContext);
-      payload.params = payload.params || {};
-      payload.params[this.name] = params;
-    }
-
-    var resolution = {
-      name: this.name,
-      handler: this.handler,
-      params: params,
-    };
-
-    // Don't set a context on the resolution unless we actually have one.
-    var contextsMatch = resolvedContext === this.context;
-    if ('context' in this || !contextsMatch) {
-      resolution.context = resolvedContext;
-    }
-
-    return this.factory('resolved', resolution);
-  }
-
-  shouldSupercede(other) {
-    // Prefer this newer handlerInfo over `other` if:
-    // 1) The other one doesn't exist
-    // 2) The names don't match
-    // 3) This handler has a context that doesn't match
-    //    the other one (or the other one doesn't have one).
-    // 4) This handler has parameters that don't match the other.
-    if (!other) {
-      return true;
-    }
-
-    var contextsMatch = other.context === this.context;
-    return (
-      other.name !== this.name ||
-      ('context' in this && !contextsMatch) ||
-      (this.hasOwnProperty('params') && !paramsMatch(this.params, other.params))
-    );
-  }
-
-  get handler() {
-    // _handler could be set to either a handler object or undefined, so we
-    // compare against a default reference to know when it's been set
-    if (this._handler !== DEFAULT_HANDLER) {
-      return this._handler;
-    }
-
-    return this.fetchHandler();
-  }
-
-  set handler(handler) {
-    return (this._handler = handler);
-  }
-
-  get handlerPromise() {
-    if (this._handlerPromise !== null) {
-      return this._handlerPromise;
-    }
-
-    this.fetchHandler();
-
-    return this._handlerPromise;
-  }
-
-  set handlerPromise(handlerPromise) {
-    this._handlerPromise = handlerPromise;
-
-    return handlerPromise;
-  }
-}
-
-function paramsMatch(a, b) {
-  if (!a ^ !b) {
-    // Only one is null.
-    return false;
-  }
-
-  if (!a) {
-    // Both must be null.
-    return true;
-  }
-
-  // Note: this assumes that both params have the same
-  // number of keys, but since we're comparing the
-  // same handlers, they should.
-  for (var k in a) {
-    if (a.hasOwnProperty(k) && a[k] !== b[k]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-class ResolvedHandlerInfo extends HandlerInfo {
-  constructor(props) {
-    super(props);
-    this.isResolved = true;
-  }
-
-  resolve(shouldContinue, payload) {
-    // A ResolvedHandlerInfo just resolved with itself.
-    if (payload && payload.resolvedModels) {
-      payload.resolvedModels[this.name] = this.context;
-    }
-    return Promise.resolve(this, this.promiseLabel('Resolve'));
-  }
-
-  getUnresolved() {
-    return this.factory('param', {
-      name: this.name,
-      handler: this.handler,
-      params: this.params,
-    });
-  }
-}
-
-class UnresolvedHandlerInfoByObject extends HandlerInfo {
-  constructor(props) {
-    super(props);
-    this.names = this.names || [];
-  }
-
-  getModel(payload) {
-    this.log(payload, this.name + ': resolving provided model');
-    return Promise.resolve(this.context);
-  }
-
-  /**
-    @private
-
-    Serializes a handler using its custom `serialize` method or
-    by a default that looks up the expected property name from
-    the dynamic segment.
-
-    @param {Object} model the model to be serialized for this handler
-  */
-  serialize(_model) {
-    var model = _model || this.context,
-      names = this.names;
-
-    var object = {};
-    if (isParam(model)) {
-      object[names[0]] = model;
-      return object;
-    }
-
-    // Use custom serialize if it exists.
-    if (this.serializer) {
-      // invoke this.serializer unbound (getSerializer returns a stateless function)
-      return this.serializer.call(null, model, names);
-    } else if (this.handler && this.handler.serialize) {
-      return this.handler.serialize(model, names);
-    }
-
-    if (names.length !== 1) {
-      return;
-    }
-
-    var name = names[0];
-
-    if (/_id$/.test(name)) {
-      object[name] = model.id;
-    } else {
-      object[name] = model;
-    }
-    return object;
-  }
-}
-
-// Generated by URL transitions and non-dynamic route segments in named Transitions.
-class UnresolvedHandlerInfoByParam extends HandlerInfo {
-  constructor(props) {
-    super(props);
-    this.params = this.params || {};
-  }
-
-  getModel(payload) {
-    var fullParams = this.params;
-    if (payload && payload.queryParams) {
-      fullParams = {};
-      merge(fullParams, this.params);
-      fullParams.queryParams = payload.queryParams;
-    }
-
-    var handler = this.handler;
-    var hookName =
-      resolveHook(handler, 'deserialize') || resolveHook(handler, 'model');
-
-    return this.runSharedModelHook(payload, hookName, [fullParams]);
-  }
-}
-
-handlerInfoFactory.klasses = {
-  resolved: ResolvedHandlerInfo,
-  param: UnresolvedHandlerInfoByParam,
-  object: UnresolvedHandlerInfoByObject,
-};
-
-function handlerInfoFactory(name, props) {
-  let klass = handlerInfoFactory.klasses[name];
-  let handlerInfo = new klass(props || {});
-  handlerInfo.factory = handlerInfoFactory;
-  return handlerInfo;
-}
-
-class NamedTransitionIntent extends TransitionIntent {
-  constructor(props) {
-    super(props);
-
-    this.name = props.name;
-    this.pivotHandler = props.pivotHandler;
-    this.contexts = props.contexts || [];
-    this.queryParams = props.queryParams;
-  }
-
-  applyToState(
-    oldState,
-    recognizer,
-    getHandler,
-    isIntermediate,
-    getSerializer
-  ) {
-    var partitionedArgs = extractQueryParams([this.name].concat(this.contexts)),
-      pureArgs = partitionedArgs[0],
-      handlers = recognizer.handlersFor(pureArgs[0]);
-
-    var targetRouteName = handlers[handlers.length - 1].handler;
-
-    return this.applyToHandlers(
-      oldState,
-      handlers,
-      getHandler,
-      targetRouteName,
-      isIntermediate,
-      null,
-      getSerializer
-    );
-  }
-
-  applyToHandlers(
-    oldState,
-    handlers,
-    getHandler,
-    targetRouteName,
-    isIntermediate,
-    checkingIfActive,
-    getSerializer
-  ) {
-    var i, len;
-    var newState = new TransitionState();
-    var objects = this.contexts.slice(0);
-
-    var invalidateIndex = handlers.length;
-
-    // Pivot handlers are provided for refresh transitions
-    if (this.pivotHandler) {
-      for (i = 0, len = handlers.length; i < len; ++i) {
-        if (handlers[i].handler === this.pivotHandler._handlerName) {
-          invalidateIndex = i;
-          break;
-        }
-      }
-    }
-
-    for (i = handlers.length - 1; i >= 0; --i) {
-      var result = handlers[i];
-      var name = result.handler;
-
-      var oldHandlerInfo = oldState.handlerInfos[i];
-      var newHandlerInfo = null;
-
-      if (result.names.length > 0) {
-        if (i >= invalidateIndex) {
-          newHandlerInfo = this.createParamHandlerInfo(
-            name,
-            getHandler,
-            result.names,
-            objects,
-            oldHandlerInfo
-          );
-        } else {
-          var serializer = getSerializer(name);
-          newHandlerInfo = this.getHandlerInfoForDynamicSegment(
-            name,
-            getHandler,
-            result.names,
-            objects,
-            oldHandlerInfo,
-            targetRouteName,
-            i,
-            serializer
-          );
-        }
-      } else {
-        // This route has no dynamic segment.
-        // Therefore treat as a param-based handlerInfo
-        // with empty params. This will cause the `model`
-        // hook to be called with empty params, which is desirable.
-        newHandlerInfo = this.createParamHandlerInfo(
-          name,
-          getHandler,
-          result.names,
-          objects,
-          oldHandlerInfo
-        );
-      }
-
-      if (checkingIfActive) {
-        // If we're performing an isActive check, we want to
-        // serialize URL params with the provided context, but
-        // ignore mismatches between old and new context.
-        newHandlerInfo = newHandlerInfo.becomeResolved(
-          null,
-          newHandlerInfo.context
-        );
-        var oldContext = oldHandlerInfo && oldHandlerInfo.context;
-        if (
-          result.names.length > 0 &&
-          'context' in oldHandlerInfo &&
-          newHandlerInfo.context === oldContext
-        ) {
-          // If contexts match in isActive test, assume params also match.
-          // This allows for flexibility in not requiring that every last
-          // handler provide a `serialize` method
-          newHandlerInfo.params = oldHandlerInfo && oldHandlerInfo.params;
-        }
-        newHandlerInfo.context = oldContext;
-      }
-
-      var handlerToUse = oldHandlerInfo;
-      if (
-        i >= invalidateIndex ||
-        newHandlerInfo.shouldSupercede(oldHandlerInfo)
-      ) {
-        invalidateIndex = Math.min(i, invalidateIndex);
-        handlerToUse = newHandlerInfo;
-      }
-
-      if (isIntermediate && !checkingIfActive) {
-        handlerToUse = handlerToUse.becomeResolved(null, handlerToUse.context);
-      }
-
-      newState.handlerInfos.unshift(handlerToUse);
-    }
-
-    if (objects.length > 0) {
-      throw new Error(
-        'More context objects were passed than there are dynamic segments for the route: ' +
-          targetRouteName
-      );
-    }
-
-    if (!isIntermediate) {
-      this.invalidateChildren(newState.handlerInfos, invalidateIndex);
-    }
-
-    merge(newState.queryParams, this.queryParams || {});
-
-    return newState;
-  }
-
-  invalidateChildren(handlerInfos, invalidateIndex) {
-    for (var i = invalidateIndex, l = handlerInfos.length; i < l; ++i) {
-      var handlerInfo = handlerInfos[i];
-      handlerInfos[i] = handlerInfo.getUnresolved();
-    }
-  }
-
-  getHandlerInfoForDynamicSegment(
-    name,
-    getHandler,
-    names,
-    objects,
-    oldHandlerInfo,
-    targetRouteName,
-    i,
-    serializer
-  ) {
-    var objectToUse;
-    if (objects.length > 0) {
-      // Use the objects provided for this transition.
-      objectToUse = objects[objects.length - 1];
-      if (isParam(objectToUse)) {
-        return this.createParamHandlerInfo(
-          name,
-          getHandler,
-          names,
-          objects,
-          oldHandlerInfo
-        );
-      } else {
-        objects.pop();
-      }
-    } else if (oldHandlerInfo && oldHandlerInfo.name === name) {
-      // Reuse the matching oldHandlerInfo
-      return oldHandlerInfo;
-    } else {
-      if (this.preTransitionState) {
-        var preTransitionHandlerInfo = this.preTransitionState.handlerInfos[i];
-        objectToUse =
-          preTransitionHandlerInfo && preTransitionHandlerInfo.context;
-      } else {
-        // Ideally we should throw this error to provide maximal
-        // information to the user that not enough context objects
-        // were provided, but this proves too cumbersome in Ember
-        // in cases where inner template helpers are evaluated
-        // before parent helpers un-render, in which cases this
-        // error somewhat prematurely fires.
-        //throw new Error("Not enough context objects were provided to complete a transition to " + targetRouteName + ". Specifically, the " + name + " route needs an object that can be serialized into its dynamic URL segments [" + names.join(', ') + "]");
-        return oldHandlerInfo;
-      }
-    }
-
-    return handlerInfoFactory('object', {
-      name: name,
-      getHandler: getHandler,
-      serializer: serializer,
-      context: objectToUse,
-      names: names,
-    });
-  }
-
-  createParamHandlerInfo(name, getHandler, names, objects, oldHandlerInfo) {
-    var params = {};
-
-    // Soak up all the provided string/numbers
-    var numNames = names.length;
-    while (numNames--) {
-      // Only use old params if the names match with the new handler
-      var oldParams =
-        (oldHandlerInfo &&
-          name === oldHandlerInfo.name &&
-          oldHandlerInfo.params) ||
-        {};
-
-      var peek = objects[objects.length - 1];
-      var paramName = names[numNames];
-      if (isParam(peek)) {
-        params[paramName] = '' + objects.pop();
-      } else {
-        // If we're here, this means only some of the params
-        // were string/number params, so try and use a param
-        // value from a previous handler.
-        if (oldParams.hasOwnProperty(paramName)) {
-          params[paramName] = oldParams[paramName];
-        } else {
-          throw new Error(
-            "You didn't provide enough string/numeric parameters to satisfy all of the dynamic segments for route " +
-              name
-          );
-        }
-      }
-    }
-
-    return handlerInfoFactory('param', {
-      name: name,
-      getHandler: getHandler,
-      params: params,
-    });
-  }
-}
-
-function UnrecognizedURLError(message) {
-  if (!(this instanceof UnrecognizedURLError)) {
-    return new UnrecognizedURLError(message);
-  }
-
-  var error = Error.call(this, message);
-
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, UnrecognizedURLError);
-  } else {
-    this.stack = error.stack;
-  }
-
-  this.description = error.description;
-  this.fileName = error.fileName;
-  this.lineNumber = error.lineNumber;
-  this.message = error.message || 'UnrecognizedURL';
-  this.name = 'UnrecognizedURLError';
-  this.number = error.number;
-  this.code = error.code;
-}
-
-UnrecognizedURLError.prototype = Object.create(Error.prototype);
-
-class URLTransitionIntent extends TransitionIntent {
-  constructor(props) {
-    super(props);
-    this.url = props.url;
-  }
-
-  applyToState(oldState, recognizer, getHandler) {
-    var newState = new TransitionState();
-
-    var results = recognizer.recognize(this.url),
-      i,
-      len;
-
-    if (!results) {
-      throw new UnrecognizedURLError(this.url);
-    }
-
-    var statesDiffer = false;
-    var url = this.url;
-
-    // Checks if a handler is accessible by URL. If it is not, an error is thrown.
-    // For the case where the handler is loaded asynchronously, the error will be
-    // thrown once it is loaded.
-    function checkHandlerAccessibility(handler) {
-      if (handler && handler.inaccessibleByURL) {
-        throw new UnrecognizedURLError(url);
-      }
-
-      return handler;
-    }
-
-    for (i = 0, len = results.length; i < len; ++i) {
-      var result = results[i];
-      var name = result.handler;
-      var newHandlerInfo = handlerInfoFactory('param', {
-        name: name,
-        getHandler: getHandler,
-        params: result.params,
-      });
-      var handler = newHandlerInfo.handler;
-
-      if (handler) {
-        checkHandlerAccessibility(handler);
-      } else {
-        // If the hanlder is being loaded asynchronously, check if we can
-        // access it after it has resolved
-        newHandlerInfo.handlerPromise = newHandlerInfo.handlerPromise.then(
-          checkHandlerAccessibility
-        );
-      }
-
-      var oldHandlerInfo = oldState.handlerInfos[i];
-      if (statesDiffer || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {
-        statesDiffer = true;
-        newState.handlerInfos[i] = newHandlerInfo;
-      } else {
-        newState.handlerInfos[i] = oldHandlerInfo;
-      }
-    }
-
-    merge(newState.queryParams, results.queryParams);
-
-    return newState;
-  }
-}
-
-var pop = Array.prototype.pop;
-
-class Router {
-  constructor(options = {}) {
-    this.getHandler = options.getHandler || this.getHandler;
-    this.getSerializer = options.getSerializer || this.getSerializer;
-    this.updateURL = options.updateURL || this.updateURL;
-    this.replaceURL = options.replaceURL || this.replaceURL;
-    this.didTransition = options.didTransition || this.didTransition;
-    this.willTransition = options.willTransition || this.willTransition;
-    this.delegate = options.delegate || this.delegate;
-    this.triggerEvent = options.triggerEvent || this.triggerEvent;
-    this.log = options.log || this.log;
-    this.dslCallBacks = []; // NOTE: set by Ember
-
-    this.state = undefined;
-    this.activeTransition = undefined;
-    this._changedQueryParams = undefined;
-    this.oldState = undefined;
-    this.currentHandlerInfos = undefined;
-    this.currentSequence = 0;
-
-    this.recognizer = new RouteRecognizer();
-    this.reset();
-  }
-
-  /**
-    The main entry point into the router. The API is essentially
-    the same as the `map` method in `route-recognizer`.
-
-    This method extracts the String handler at the last `.to()`
-    call and uses it as the name of the whole route.
-
-    @param {Function} callback
-  */
-  map(callback) {
-    this.recognizer.delegate = this.delegate;
-
-    this.recognizer.map(callback, function(recognizer, routes) {
-      for (var i = routes.length - 1, proceed = true; i >= 0 && proceed; --i) {
-        var route = routes[i];
-        recognizer.add(routes, { as: route.handler });
-        proceed =
-          route.path === '/' ||
-          route.path === '' ||
-          route.handler.slice(-6) === '.index';
-      }
-    });
-  }
-
-  hasRoute(route) {
-    return this.recognizer.hasRoute(route);
-  }
-
-  getHandler() {}
-
-  getSerializer() {}
-
-  queryParamsTransition(changelist, wasTransitioning, oldState, newState) {
-    let router = this;
-
-    fireQueryParamDidChange(this, newState, changelist);
-
-    if (!wasTransitioning && this.activeTransition) {
-      // One of the handlers in queryParamsDidChange
-      // caused a transition. Just return that transition.
-      return this.activeTransition;
-    } else {
-      // Running queryParamsDidChange didn't change anything.
-      // Just update query params and be on our way.
-
-      // We have to return a noop transition that will
-      // perform a URL update at the end. This gives
-      // the user the ability to set the url update
-      // method (default is replaceState).
-      let newTransition = new Transition(this);
-      newTransition.queryParamsOnly = true;
-
-      oldState.queryParams = finalizeQueryParamChange(
-        this,
-        newState.handlerInfos,
-        newState.queryParams,
-        newTransition
-      );
-
-      newTransition.promise = newTransition.promise.then(
-        function(result) {
-          updateURL(newTransition, oldState, true);
-          if (router.didTransition) {
-            router.didTransition(router.currentHandlerInfos);
-          }
-          return result;
-        },
-        null,
-        promiseLabel('Transition complete')
-      );
-      return newTransition;
-    }
-  }
-
-  // NOTE: this doesn't really belong here, but here
-  // it shall remain until our ES6 transpiler can
-  // handle cyclical deps.
-  transitionByIntent(intent /*, isIntermediate*/) {
-    try {
-      return getTransitionByIntent.apply(this, arguments);
-    } catch (e) {
-      return new Transition(this, intent, null, e);
-    }
-  }
-
-  /**
-    Clears the current and target route handlers and triggers exit
-    on each of them starting at the leaf and traversing up through
-    its ancestors.
-  */
-  reset() {
-    if (this.state) {
-      forEach(this.state.handlerInfos.slice().reverse(), function(handlerInfo) {
-        var handler = handlerInfo.handler;
-        callHook(handler, 'exit');
-      });
-    }
-
-    this.oldState = undefined;
-    this.state = new TransitionState();
-    this.currentHandlerInfos = null;
-  }
-
-  /**
-    var handler = handlerInfo.handler;
-    The entry point for handling a change to the URL (usually
-    via the back and forward button).
-
-    Returns an Array of handlers and the parameters associated
-    with those parameters.
-
-    @param {String} url a URL to process
-
-    @return {Array} an Array of `[handler, parameter]` tuples
-  */
-  handleURL(...args) {
-    // Perform a URL-based transition, but don't change
-    // the URL afterward, since it already happened.
-    let url = args[0];
-    if (url.charAt(0) !== '/') {
-      args[0] = '/' + url;
-    }
-
-    return doTransition(this, args).method(null);
-  }
-
-  /**
-    Hook point for updating the URL.
-
-    @param {String} url a URL to update to
-  */
-  updateURL() {
-    throw new Error('updateURL is not implemented');
-  }
-
-  /**
-    Hook point for replacing the current URL, i.e. with replaceState
-
-    By default this behaves the same as `updateURL`
-
-    @param {String} url a URL to update to
-  */
-  replaceURL(url) {
-    this.updateURL(url);
-  }
-
-  /**
-    Transition into the specified named route.
-
-    If necessary, trigger the exit callback on any handlers
-    that are no longer represented by the target route.
-
-    @param {String} name the name of the route
-  */
-  transitionTo(/*name*/) {
-    return doTransition(this, arguments);
-  }
-
-  intermediateTransitionTo(/*name*/) {
-    return doTransition(this, arguments, true);
-  }
-
-  refresh(pivotHandler) {
-    let previousTransition = this.activeTransition;
-    let state = previousTransition ? previousTransition.state : this.state;
-    let handlerInfos = state.handlerInfos;
-
-    log(this, 'Starting a refresh transition');
-    let intent = new NamedTransitionIntent({
-      name: handlerInfos[handlerInfos.length - 1].name,
-      pivotHandler: pivotHandler || handlerInfos[0].handler,
-      contexts: [], // TODO collect contexts...?
-      queryParams: this._changedQueryParams || state.queryParams || {},
-    });
-
-    let newTransition = this.transitionByIntent(intent, false);
-
-    // if the previous transition is a replace transition, that needs to be preserved
-    if (previousTransition && previousTransition.urlMethod === 'replace') {
-      newTransition.method(previousTransition.urlMethod);
-    }
-
-    return newTransition;
-  }
-
-  /**
-    Identical to `transitionTo` except that the current URL will be replaced
-    if possible.
-
-    This method is intended primarily for use with `replaceState`.
-
-    @param {String} name the name of the route
-  */
-  replaceWith(/*name*/) {
-    return doTransition(this, arguments).method('replace');
-  }
-
-  /**
-    Take a named route and context objects and generate a
-    URL.
-
-    @param {String} name the name of the route to generate
-      a URL for
-    @param {...Object} objects a list of objects to serialize
-
-    @return {String} a URL
-  */
-  generate(handlerName) {
-    let partitionedArgs = extractQueryParams(slice.call(arguments, 1)),
-      suppliedParams = partitionedArgs[0],
-      queryParams = partitionedArgs[1];
-
-    // Construct a TransitionIntent with the provided params
-    // and apply it to the present state of the router.
-    let intent = new NamedTransitionIntent({
-      name: handlerName,
-      contexts: suppliedParams,
-    });
-    let state = intent.applyToState(
-      this.state,
-      this.recognizer,
-      this.getHandler,
-      null,
-      this.getSerializer
-    );
-
-    let params = {};
-    for (var i = 0, len = state.handlerInfos.length; i < len; ++i) {
-      var handlerInfo = state.handlerInfos[i];
-      var handlerParams = handlerInfo.serialize();
-      merge(params, handlerParams);
-    }
-    params.queryParams = queryParams;
-
-    return this.recognizer.generate(handlerName, params);
-  }
-
-  applyIntent(handlerName, contexts) {
-    let intent = new NamedTransitionIntent({
-      name: handlerName,
-      contexts: contexts,
-    });
-
-    let state =
-      (this.activeTransition && this.activeTransition.state) || this.state;
-
-    return intent.applyToState(
-      state,
-      this.recognizer,
-      this.getHandler,
-      null,
-      this.getSerializer
-    );
-  }
-
-  isActiveIntent(handlerName, contexts, queryParams, _state) {
-    let state = _state || this.state,
-      targetHandlerInfos = state.handlerInfos,
-      handlerInfo,
-      len;
-
-    if (!targetHandlerInfos.length) {
-      return false;
-    }
-
-    let targetHandler = targetHandlerInfos[targetHandlerInfos.length - 1].name;
-    let recogHandlers = this.recognizer.handlersFor(targetHandler);
-
-    let index = 0;
-    for (len = recogHandlers.length; index < len; ++index) {
-      handlerInfo = targetHandlerInfos[index];
-      if (handlerInfo.name === handlerName) {
-        break;
-      }
-    }
-
-    if (index === recogHandlers.length) {
-      // The provided route name isn't even in the route hierarchy.
-      return false;
-    }
-
-    let testState = new TransitionState();
-    testState.handlerInfos = targetHandlerInfos.slice(0, index + 1);
-    recogHandlers = recogHandlers.slice(0, index + 1);
-
-    let intent = new NamedTransitionIntent({
-      name: targetHandler,
-      contexts: contexts,
-    });
-
-    let newState = intent.applyToHandlers(
-      testState,
-      recogHandlers,
-      this.getHandler,
-      targetHandler,
-      true,
-      true,
-      this.getSerializer
-    );
-
-    let handlersEqual = handlerInfosEqual(
-      newState.handlerInfos,
-      testState.handlerInfos
-    );
-    if (!queryParams || !handlersEqual) {
-      return handlersEqual;
-    }
-
-    // Get a hash of QPs that will still be active on new route
-    let activeQPsOnNewHandler = {};
-    merge(activeQPsOnNewHandler, queryParams);
-
-    let activeQueryParams = state.queryParams;
-    for (var key in activeQueryParams) {
-      if (
-        activeQueryParams.hasOwnProperty(key) &&
-        activeQPsOnNewHandler.hasOwnProperty(key)
-      ) {
-        activeQPsOnNewHandler[key] = activeQueryParams[key];
-      }
-    }
-
-    return handlersEqual && !getChangelist(activeQPsOnNewHandler, queryParams);
-  }
-
-  isActive(handlerName, ...args) {
-    let partitionedArgs = extractQueryParams(args);
-    return this.isActiveIntent(
-      handlerName,
-      partitionedArgs[0],
-      partitionedArgs[1]
-    );
-  }
-
-  trigger(...args) {
-    trigger(this, this.currentHandlerInfos, false, args);
-  }
-}
-
-function getTransitionByIntent(intent, isIntermediate) {
-  var wasTransitioning = !!this.activeTransition;
-  var oldState = wasTransitioning ? this.activeTransition.state : this.state;
-  var newTransition;
-
-  var newState = intent.applyToState(
-    oldState,
-    this.recognizer,
-    this.getHandler,
-    isIntermediate,
-    this.getSerializer
-  );
-  var queryParamChangelist = getChangelist(
-    oldState.queryParams,
-    newState.queryParams
-  );
-
-  if (handlerInfosEqual(newState.handlerInfos, oldState.handlerInfos)) {
-    // This is a no-op transition. See if query params changed.
-    if (queryParamChangelist) {
-      newTransition = this.queryParamsTransition(
-        queryParamChangelist,
-        wasTransitioning,
-        oldState,
-        newState
-      );
-      if (newTransition) {
-        newTransition.queryParamsOnly = true;
-        return newTransition;
-      }
-    }
-
-    // No-op. No need to create a new transition.
-    return this.activeTransition || new Transition(this);
-  }
-
-  if (isIntermediate) {
-    setupContexts(this, newState);
-    return;
-  }
-
-  // Create a new transition to the destination route.
-  newTransition = new Transition(
-    this,
-    intent,
-    newState,
-    undefined,
-    this.activeTransition
-  );
-
-  // transition is to same route with same params, only query params differ.
-  // not caught above probably because refresh() has been used
-  if (
-    handlerInfosSameExceptQueryParams(
-      newState.handlerInfos,
-      oldState.handlerInfos
-    )
-  ) {
-    newTransition.queryParamsOnly = true;
-  }
-
-  // Abort and usurp any previously active transition.
-  if (this.activeTransition) {
-    this.activeTransition.abort();
-  }
-  this.activeTransition = newTransition;
-
-  // Transition promises by default resolve with resolved state.
-  // For our purposes, swap out the promise to resolve
-  // after the transition has been finalized.
-  newTransition.promise = newTransition.promise.then(
-    function(result) {
-      return finalizeTransition(newTransition, result.state);
-    },
-    null,
-    promiseLabel('Settle transition promise when transition is finalized')
-  );
-
-  if (!wasTransitioning) {
-    notifyExistingHandlers(this, newState, newTransition);
-  }
-
-  fireQueryParamDidChange(this, newState, queryParamChangelist);
-
-  return newTransition;
-}
-
-/**
-  @private
-
-  Fires queryParamsDidChange event
-*/
-function fireQueryParamDidChange(router, newState, queryParamChangelist) {
-  // If queryParams changed trigger event
-  if (queryParamChangelist) {
-    // This is a little hacky but we need some way of storing
-    // changed query params given that no activeTransition
-    // is guaranteed to have occurred.
-    router._changedQueryParams = queryParamChangelist.all;
-    trigger(router, newState.handlerInfos, true, [
-      'queryParamsDidChange',
-      queryParamChangelist.changed,
-      queryParamChangelist.all,
-      queryParamChangelist.removed,
-    ]);
-    router._changedQueryParams = null;
-  }
-}
-
-/**
-  @private
-
-  Takes an Array of `HandlerInfo`s, figures out which ones are
-  exiting, entering, or changing contexts, and calls the
-  proper handler hooks.
-
-  For example, consider the following tree of handlers. Each handler is
-  followed by the URL segment it handles.
-
-  ```
-  |~index ("/")
-  | |~posts ("/posts")
-  | | |-showPost ("/:id")
-  | | |-newPost ("/new")
-  | | |-editPost ("/edit")
-  | |~about ("/about/:id")
-  ```
-
-  Consider the following transitions:
-
-  1. A URL transition to `/posts/1`.
-     1. Triggers the `*model` callbacks on the
-        `index`, `posts`, and `showPost` handlers
-     2. Triggers the `enter` callback on the same
-     3. Triggers the `setup` callback on the same
-  2. A direct transition to `newPost`
-     1. Triggers the `exit` callback on `showPost`
-     2. Triggers the `enter` callback on `newPost`
-     3. Triggers the `setup` callback on `newPost`
-  3. A direct transition to `about` with a specified
-     context object
-     1. Triggers the `exit` callback on `newPost`
-        and `posts`
-     2. Triggers the `serialize` callback on `about`
-     3. Triggers the `enter` callback on `about`
-     4. Triggers the `setup` callback on `about`
-
-  @param {Router} transition
-  @param {TransitionState} newState
-*/
-function setupContexts(router, newState, transition) {
-  var partition = partitionHandlers(router.state, newState);
-  var i, l, handler;
-
-  for (i = 0, l = partition.exited.length; i < l; i++) {
-    handler = partition.exited[i].handler;
-    delete handler.context;
-
-    callHook(handler, 'reset', true, transition);
-    callHook(handler, 'exit', transition);
-  }
-
-  var oldState = (router.oldState = router.state);
-  router.state = newState;
-  var currentHandlerInfos = (router.currentHandlerInfos = partition.unchanged.slice());
-
-  try {
-    for (i = 0, l = partition.reset.length; i < l; i++) {
-      handler = partition.reset[i].handler;
-      callHook(handler, 'reset', false, transition);
-    }
-
-    for (i = 0, l = partition.updatedContext.length; i < l; i++) {
-      handlerEnteredOrUpdated(
-        currentHandlerInfos,
-        partition.updatedContext[i],
-        false,
-        transition
-      );
-    }
-
-    for (i = 0, l = partition.entered.length; i < l; i++) {
-      handlerEnteredOrUpdated(
-        currentHandlerInfos,
-        partition.entered[i],
-        true,
-        transition
-      );
-    }
-  } catch (e) {
-    router.state = oldState;
-    router.currentHandlerInfos = oldState.handlerInfos;
-    throw e;
-  }
-
-  router.state.queryParams = finalizeQueryParamChange(
-    router,
-    currentHandlerInfos,
-    newState.queryParams,
-    transition
-  );
-}
-
-/**
-  @private
-
-  Helper method used by setupContexts. Handles errors or redirects
-  that may happen in enter/setup.
-*/
-function handlerEnteredOrUpdated(
-  currentHandlerInfos,
-  handlerInfo,
-  enter,
-  transition
-) {
-  var handler = handlerInfo.handler,
-    context = handlerInfo.context;
-
-  function _handlerEnteredOrUpdated(handler) {
-    if (enter) {
-      callHook(handler, 'enter', transition);
-    }
-
-    if (transition && transition.isAborted) {
-      throw new TransitionAbortedError();
-    }
-
-    handler.context = context;
-    callHook(handler, 'contextDidChange');
-
-    callHook(handler, 'setup', context, transition);
-    if (transition && transition.isAborted) {
-      throw new TransitionAbortedError();
-    }
-
-    currentHandlerInfos.push(handlerInfo);
-  }
-
-  // If the handler doesn't exist, it means we haven't resolved the handler promise yet
-  if (!handler) {
-    handlerInfo.handlerPromise = handlerInfo.handlerPromise.then(
-      _handlerEnteredOrUpdated
-    );
-  } else {
-    _handlerEnteredOrUpdated(handler);
-  }
-
-  return true;
-}
-
-/**
-  @private
-
-  This function is called when transitioning from one URL to
-  another to determine which handlers are no longer active,
-  which handlers are newly active, and which handlers remain
-  active but have their context changed.
-
-  Take a list of old handlers and new handlers and partition
-  them into four buckets:
-
-  * unchanged: the handler was active in both the old and
-    new URL, and its context remains the same
-  * updated context: the handler was active in both the
-    old and new URL, but its context changed. The handler's
-    `setup` method, if any, will be called with the new
-    context.
-  * exited: the handler was active in the old URL, but is
-    no longer active.
-  * entered: the handler was not active in the old URL, but
-    is now active.
-
-  The PartitionedHandlers structure has four fields:
-
-  * `updatedContext`: a list of `HandlerInfo` objects that
-    represent handlers that remain active but have a changed
-    context
-  * `entered`: a list of `HandlerInfo` objects that represent
-    handlers that are newly active
-  * `exited`: a list of `HandlerInfo` objects that are no
-    longer active.
-  * `unchanged`: a list of `HanderInfo` objects that remain active.
-
-  @param {Array[HandlerInfo]} oldHandlers a list of the handler
-    information for the previous URL (or `[]` if this is the
-    first handled transition)
-  @param {Array[HandlerInfo]} newHandlers a list of the handler
-    information for the new URL
-
-  @return {Partition}
-*/
-function partitionHandlers(oldState, newState) {
-  var oldHandlers = oldState.handlerInfos;
-  var newHandlers = newState.handlerInfos;
-
-  var handlers = {
-    updatedContext: [],
-    exited: [],
-    entered: [],
-    unchanged: [],
-    reset: undefined,
-  };
-
-  var handlerChanged,
-    contextChanged = false,
-    i,
-    l;
-
-  for (i = 0, l = newHandlers.length; i < l; i++) {
-    var oldHandler = oldHandlers[i],
-      newHandler = newHandlers[i];
-
-    if (!oldHandler || oldHandler.handler !== newHandler.handler) {
-      handlerChanged = true;
-    }
-
-    if (handlerChanged) {
-      handlers.entered.push(newHandler);
-      if (oldHandler) {
-        handlers.exited.unshift(oldHandler);
-      }
-    } else if (contextChanged || oldHandler.context !== newHandler.context) {
-      contextChanged = true;
-      handlers.updatedContext.push(newHandler);
-    } else {
-      handlers.unchanged.push(oldHandler);
-    }
-  }
-
-  for (i = newHandlers.length, l = oldHandlers.length; i < l; i++) {
-    handlers.exited.unshift(oldHandlers[i]);
-  }
-
-  handlers.reset = handlers.updatedContext.slice();
-  handlers.reset.reverse();
-
-  return handlers;
-}
-
-function updateURL(transition, state /*, inputUrl*/) {
-  var urlMethod = transition.urlMethod;
-
-  if (!urlMethod) {
-    return;
-  }
-
-  var router = transition.router,
-    handlerInfos = state.handlerInfos,
-    handlerName = handlerInfos[handlerInfos.length - 1].name,
-    params = {};
-
-  for (var i = handlerInfos.length - 1; i >= 0; --i) {
-    var handlerInfo = handlerInfos[i];
-    merge(params, handlerInfo.params);
-    if (handlerInfo.handler.inaccessibleByURL) {
-      urlMethod = null;
-    }
-  }
-
-  if (urlMethod) {
-    params.queryParams = transition._visibleQueryParams || state.queryParams;
-    var url = router.recognizer.generate(handlerName, params);
-
-    // transitions during the initial transition must always use replaceURL.
-    // When the app boots, you are at a url, e.g. /foo. If some handler
-    // redirects to bar as part of the initial transition, you don't want to
-    // add a history entry for /foo. If you do, pressing back will immediately
-    // hit the redirect again and take you back to /bar, thus killing the back
-    // button
-    var initial = transition.isCausedByInitialTransition;
-
-    // say you are at / and you click a link to route /foo. In /foo's
-    // handler, 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
-    // the back button. That's why updateURL is always correct for an
-    // aborting transition that's not the initial transition
-    var replaceAndNotAborting =
-      urlMethod === 'replace' && !transition.isCausedByAbortingTransition;
-
-    // because calling refresh causes an aborted transition, this needs to be
-    // special cased - if the initial transition is a replace transition, the
-    // urlMethod should be honored here.
-    var isQueryParamsRefreshTransition =
-      transition.queryParamsOnly && urlMethod === 'replace';
-
-    // say you are at / and you a `replaceWith(/foo)` is called. Then, that
-    // transition is aborted with `replaceWith(/bar)`. At the end, we should
-    // end up with /bar replacing /. We are replacing the replace. We only
-    // will replace the initial route if all subsequent aborts are also
-    // replaces. However, there is some ambiguity around the correct behavior
-    // here.
-    var replacingReplace =
-      urlMethod === 'replace' && transition.isCausedByAbortingReplaceTransition;
-
-    if (
-      initial ||
-      replaceAndNotAborting ||
-      isQueryParamsRefreshTransition ||
-      replacingReplace
-    ) {
-      router.replaceURL(url);
-    } else {
-      router.updateURL(url);
-    }
-  }
-}
-
-/**
-  @private
-
-  Updates the URL (if necessary) and calls `setupContexts`
-  to update the router's array of `currentHandlerInfos`.
- */
-function finalizeTransition(transition, newState) {
-  try {
-    log(
-      transition.router,
-      transition.sequence,
-      'Resolved all models on destination route; finalizing transition.'
-    );
-
-    var router = transition.router,
-      handlerInfos = newState.handlerInfos;
-
-    // Run all the necessary enter/setup/exit hooks
-    setupContexts(router, newState, transition);
-
-    // Check if a redirect occurred in enter/setup
-    if (transition.isAborted) {
-      // TODO: cleaner way? distinguish b/w targetHandlerInfos?
-      router.state.handlerInfos = router.currentHandlerInfos;
-      return Promise.reject(logAbort(transition));
-    }
-
-    updateURL(transition, newState, transition.intent.url);
-
-    transition.isActive = false;
-    router.activeTransition = null;
-
-    trigger(router, router.currentHandlerInfos, true, ['didTransition']);
-
-    if (router.didTransition) {
-      router.didTransition(router.currentHandlerInfos);
-    }
-
-    log(router, transition.sequence, 'TRANSITION COMPLETE.');
-
-    // Resolve with the final handler.
-    return handlerInfos[handlerInfos.length - 1].handler;
-  } catch (e) {
-    if (!(e instanceof TransitionAbortedError)) {
-      //var erroneousHandler = handlerInfos.pop();
-      var infos = transition.state.handlerInfos;
-      transition.trigger(
-        true,
-        'error',
-        e,
-        transition,
-        infos[infos.length - 1].handler
-      );
-      transition.abort();
-    }
-
-    throw e;
-  }
-}
-
-/**
-  @private
-
-  Begins and returns a Transition based on the provided
-  arguments. Accepts arguments in the form of both URL
-  transitions and named transitions.
-
-  @param {Router} router
-  @param {Array[Object]} args arguments passed to transitionTo,
-    replaceWith, or handleURL
-*/
-function doTransition(router, args, isIntermediate) {
-  // Normalize blank transitions to root URL transitions.
-  var name = args[0] || '/';
-
-  var lastArg = args[args.length - 1];
-  var queryParams = {};
-  if (lastArg && lastArg.hasOwnProperty('queryParams')) {
-    queryParams = pop.call(args).queryParams;
-  }
-
-  var intent;
-  if (args.length === 0) {
-    log(router, 'Updating query params');
-
-    // A query param update is really just a transition
-    // into the route you're already on.
-    var handlerInfos = router.state.handlerInfos;
-    intent = new NamedTransitionIntent({
-      name: handlerInfos[handlerInfos.length - 1].name,
-      contexts: [],
-      queryParams: queryParams,
-    });
-  } else if (name.charAt(0) === '/') {
-    log(router, 'Attempting URL transition to ' + name);
-    intent = new URLTransitionIntent({ url: name });
-  } else {
-    log(router, 'Attempting transition to ' + name);
-    intent = new NamedTransitionIntent({
-      name: args[0],
-      contexts: slice.call(args, 1),
-      queryParams: queryParams,
-    });
-  }
-
-  return router.transitionByIntent(intent, isIntermediate);
-}
-
-function handlerInfosEqual(handlerInfos, otherHandlerInfos) {
-  if (handlerInfos.length !== otherHandlerInfos.length) {
-    return false;
-  }
-
-  for (var i = 0, len = handlerInfos.length; i < len; ++i) {
-    if (handlerInfos[i] !== otherHandlerInfos[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function handlerInfosSameExceptQueryParams(handlerInfos, otherHandlerInfos) {
-  if (handlerInfos.length !== otherHandlerInfos.length) {
-    return false;
-  }
-
-  for (var i = 0, len = handlerInfos.length; i < len; ++i) {
-    if (handlerInfos[i].name !== otherHandlerInfos[i].name) {
-      return false;
-    }
-
-    if (!paramsEqual(handlerInfos[i].params, otherHandlerInfos[i].params)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function paramsEqual(params, otherParams) {
-  if (!params && !otherParams) {
-    return true;
-  } else if ((!params && !!otherParams) || (!!params && !otherParams)) {
-    // one is falsy but other is not;
-    return false;
-  }
-  var keys = Object.keys(params);
-  var otherKeys = Object.keys(otherParams);
-
-  if (keys.length !== otherKeys.length) {
-    return false;
-  }
-
-  for (var i = 0, len = keys.length; i < len; ++i) {
-    var key = keys[i];
-
-    if (params[key] !== otherParams[key]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function finalizeQueryParamChange(
-  router,
-  resolvedHandlers,
-  newQueryParams,
-  transition
-) {
-  // We fire a finalizeQueryParamChange event which
-  // gives the new route hierarchy a chance to tell
-  // us which query params it's consuming and what
-  // their final values are. If a query param is
-  // no longer consumed in the final route hierarchy,
-  // its serialized segment will be removed
-  // from the URL.
-
-  for (var k in newQueryParams) {
-    if (newQueryParams.hasOwnProperty(k) && newQueryParams[k] === null) {
-      delete newQueryParams[k];
-    }
-  }
-
-  var finalQueryParamsArray = [];
-  trigger(router, resolvedHandlers, true, [
-    'finalizeQueryParamChange',
-    newQueryParams,
-    finalQueryParamsArray,
-    transition,
-  ]);
-
-  if (transition) {
-    transition._visibleQueryParams = {};
-  }
-
-  var finalQueryParams = {};
-  for (var i = 0, len = finalQueryParamsArray.length; i < len; ++i) {
-    var qp = finalQueryParamsArray[i];
-    finalQueryParams[qp.key] = qp.value;
-    if (transition && qp.visible !== false) {
-      transition._visibleQueryParams[qp.key] = qp.value;
-    }
-  }
-  return finalQueryParams;
-}
-
-function notifyExistingHandlers(router, newState, newTransition) {
-  var oldHandlers = router.state.handlerInfos,
-    i,
-    oldHandlerLen,
-    oldHandler,
-    newHandler;
-
-  oldHandlerLen = oldHandlers.length;
-  for (i = 0; i < oldHandlerLen; i++) {
-    oldHandler = oldHandlers[i];
-    newHandler = newState.handlerInfos[i];
-
-    if (!newHandler || oldHandler.name !== newHandler.name) {
-      break;
-    }
-
-    if (!newHandler.isResolved) {
-    }
-  }
-
-  trigger(router, oldHandlers, true, ['willTransition', newTransition]);
-
-  if (router.willTransition) {
-    router.willTransition(oldHandlers, newState.handlerInfos, newTransition);
-  }
-}
-
-export default Router;
-export { Transition };