dune-dashboard 1.0.0

data/vendor/assets/components/ember-simple-auth/simple-auth.amd.js

@@ -0,0 +1,1450 @@
+(function(global) {
+  var define = global.define;
+  var require = global.require;
+  var Ember = global.Ember;
+  if (typeof Ember === 'undefined' && typeof require !== 'undefined') {
+    Ember = require('ember');
+  }
+
+Ember.libraries.register('Ember Simple Auth', '0.6.4');
+
+define("simple-auth/authenticators/base", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      The base for all authenticators. __This serves as a starting point for
+      implementing custom authenticators and must not be used directly.__
+
+      The authenticator authenticates the session. The actual mechanism used to do
+      this might e.g. be posting a set of credentials to a server and in exchange
+      retrieving an access token, initiating authentication against an external
+      provider like Facebook etc. and depends on the specific authenticator. Any
+      data that the authenticator receives upon successful authentication and
+      resolves with from the
+      [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)
+      method is stored in the session and can then be used by the authorizer (see
+      [`Authorizers.Base`](#SimpleAuth-Authorizers-Base)).
+
+      The authenticator also decides whether a set of data that was restored from
+      the session store (see
+      [`Stores.Base`](#SimpleAuth-Stores-Base)) is sufficient for the session to be
+      authenticated or not.
+
+      __Custom authenticators have to be registered with Ember's dependency
+      injection container__ so that the session can retrieve an instance, e.g.:
+
+      ```javascript
+      import Base from 'simple-auth/authenticators/base';
+
+      var CustomAuthenticator = Base.extend({
+        ...
+      });
+
+      Ember.Application.initializer({
+        name: 'authentication',
+        initialize: function(container, application) {
+          container.register('authenticator:custom', CustomAuthenticator);
+        }
+      });
+      ```
+
+      ```javascript
+      // app/controllers/login.js
+      import AuthenticationControllerMixin from 'simple-auth/mixins/authentication-controller-mixin';
+
+      export default Ember.Controller.extend(AuthenticationControllerMixin, {
+        authenticator: 'authenticator:custom'
+      });
+      ```
+
+      @class Base
+      @namespace SimpleAuth.Authenticators
+      @module simple-auth/authenticators/base
+      @extends Ember.Object
+      @uses Ember.Evented
+    */
+    __exports__["default"] = Ember.Object.extend(Ember.Evented, {
+      /**
+        __Triggered when the data that constitutes the session is updated by the
+        authenticator__. This might happen e.g. because the authenticator refreshes
+        it or an event from is triggered from an external authentication provider.
+        The session automatically catches that event, passes the updated data back
+        to the authenticator's
+        [SimpleAuth.Authenticators.Base#restore](#SimpleAuth-Authenticators-Base-restore)
+        method and handles the result of that invocation accordingly.
+
+        @event sessionDataUpdated
+        @param {Object} data The updated session data
+      */
+      /**
+        __Triggered when the data that constitutes the session is invalidated by
+        the authenticator__. This might happen e.g. because the date expires or an
+        event is triggered from an external authentication provider. The session
+        automatically catches that event and invalidates itself.
+
+        @event sessionDataInvalidated
+        @param {Object} data The updated session data
+      */
+
+      /**
+        Restores the session from a set of properties. __This method is invoked by
+        the session either after the application starts up and session data was
+        restored from the store__ or when properties in the store have changed due
+        to external events (e.g. in another tab) and the new set of properties
+        needs to be re-checked for whether it still constitutes an authenticated
+        session.
+
+        __This method returns a promise. A resolving promise will result in the
+        session being authenticated.__ Any properties the promise resolves with
+        will be saved in and accessible via the session. In most cases the `data`
+        argument will simply be forwarded through the promise. A rejecting promise
+        indicates that authentication failed and the session will remain unchanged.
+
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
+        rejecting promise.
+
+        @method restore
+        @param {Object} data The data to restore the session from
+        @return {Ember.RSVP.Promise} A promise that when it resolves results in the session being authenticated
+      */
+      restore: function(data) {
+        return new Ember.RSVP.reject();
+      },
+
+      /**
+        Authenticates the session with the specified `options`. These options vary
+        depending on the actual authentication mechanism the authenticator
+        implements (e.g. a set of credentials or a Facebook account id etc.). __The
+        session will invoke this method when an action in the appliaction triggers
+        authentication__ (see
+        [SimpleAuth.AuthenticationControllerMixin.actions#authenticate](#SimpleAuth-AuthenticationControllerMixin-authenticate)).
+
+        __This method returns a promise. A resolving promise will result in the
+        session being authenticated.__ Any properties the promise resolves with
+        will be saved in and accessible via the session. A rejecting promise
+        indicates that authentication failed and the session will remain unchanged.
+
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
+        rejecting promise and thus never authenticates the session.
+
+        @method authenticate
+        @param {Object} options The options to authenticate the session with
+        @return {Ember.RSVP.Promise} A promise that when it resolves results in the session being authenticated
+      */
+      authenticate: function(options) {
+        return new Ember.RSVP.reject();
+      },
+
+      /**
+        This callback is invoked when the session is invalidated. While the session
+        will invalidate itself and clear all session properties, it might be
+        necessary for some authenticators to perform additional tasks (e.g.
+        invalidating an access token on the server), which should be done in this
+        method.
+
+        __This method returns a promise. A resolving promise will result in the
+        session being invalidated.__ A rejecting promise will result in the session
+        invalidation being intercepted and the session being left authenticated.
+
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
+        resolving promise and thus never intercepts session invalidation.
+
+        @method invalidate
+        @param {Object} data The data that the session currently holds
+        @return {Ember.RSVP.Promise} A promise that when it resolves results in the session being invalidated
+      */
+      invalidate: function(data) {
+        return new Ember.RSVP.resolve();
+      }
+    });
+  });
+define("simple-auth/authorizers/base", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      The base for all authorizers. __This serves as a starting point for
+      implementing custom authorizers and must not be used directly.__
+
+      __The authorizer preprocesses all XHR requests__ (except ones to 3rd party
+      origins, see
+      [Configuration.crossOriginWhitelist](#SimpleAuth-Configuration-crossOriginWhitelist))
+      and makes sure they have the required data attached that allows the server to
+      identify the user making the request. This data might be an HTTP header,
+      query string parameters in the URL, cookies etc. __The authorizer has to fit
+      the authenticator__ (see
+      [SimpleAuth.Authenticators.Base](#SimpleAuth-Authenticators-Base))
+      as it relies on data that the authenticator acquires during authentication.
+
+      @class Base
+      @namespace SimpleAuth.Authorizers
+      @module simple-auth/authorizers/base
+      @extends Ember.Object
+    */
+    __exports__["default"] = Ember.Object.extend({
+      /**
+        The session the authorizer gets the data it needs to authorize requests
+        from.
+
+        @property session
+        @readOnly
+        @type SimpleAuth.Session
+        @default the session instance
+      */
+      session: null,
+
+      /**
+        Authorizes an XHR request by adding some sort of secret information that
+        allows the server to identify the user making the request (e.g. a token in
+        the `Authorization` header or some other secret in the query string etc.).
+
+        `SimpleAuth.Authorizers.Base`'s implementation does nothing.
+
+        @method authorize
+        @param {jqXHR} jqXHR The XHR request to authorize (see http://api.jquery.com/jQuery.ajax/#jqXHR)
+        @param {Object} requestOptions The options as provided to the `$.ajax` method (see http://api.jquery.com/jQuery.ajaxPrefilter/)
+      */
+      authorize: function(jqXHR, requestOptions) {
+      }
+    });
+  });
+define("simple-auth/configuration", 
+  ["./utils/get-global-config","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var getGlobalConfig = __dependency1__["default"];
+
+    /**
+      Ember Simple Auth's configuration object.
+
+      To change any of these values, define a global environment object for Ember
+      Simple Auth and define the values there:
+
+      ```javascript
+      window.ENV = window.ENV || {};
+      window.ENV['simple-auth'] = {
+        authenticationRoute: 'sign-in'
+      };
+      ```
+
+      @class Configuration
+      @namespace SimpleAuth
+      @module simple-auth/configuration
+    */
+    __exports__["default"] = {
+      /**
+        The route to transition to for authentication.
+
+        @property authenticationRoute
+        @readOnly
+        @static
+        @type String
+        @default 'login'
+      */
+      authenticationRoute: 'login',
+
+      /**
+        The route to transition to after successful authentication.
+
+        @property routeAfterAuthentication
+        @readOnly
+        @static
+        @type String
+        @default 'index'
+      */
+      routeAfterAuthentication: 'index',
+
+      /**
+        The name of the property that the session is injected with into routes and
+        controllers.
+
+        @property sessionPropertyName
+        @readOnly
+        @static
+        @type String
+        @default 'session'
+      */
+      sessionPropertyName: 'session',
+
+      /**
+        The authorizer factory to use as it is registered with Ember's container,
+        see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register);
+        when the application does not interact with a server that requires
+        authorized requests, no auzthorizer is needed.
+
+        @property authorizer
+        @readOnly
+        @static
+        @type String
+        @default null
+      */
+      authorizer: null,
+
+      /**
+        The session factory to use as it is registered with Ember's container,
+        see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register).
+
+        @property session
+        @readOnly
+        @static
+        @type String
+        @default 'simple-auth-session:main'
+      */
+      session: 'simple-auth-session:main',
+
+      /**
+        The store factory to use as it is registered with Ember's container, see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register).
+
+        @property store
+        @readOnly
+        @static
+        @type String
+        @default simple-auth-session-store:local-storage
+      */
+      store: 'simple-auth-session-store:local-storage',
+
+      /**
+        Ember Simple Auth will never authorize requests going to a different origin
+        than the one the Ember.js application was loaded from; to explicitely
+        enable authorization for additional origins, whitelist those origins with
+        this setting. _Beware that origins consist of protocol, host and port (port
+        can be left out when it is 80 for HTTP or 443 for HTTPS)_
+
+        @property crossOriginWhitelist
+        @readOnly
+        @static
+        @type Array
+        @default []
+      */
+      crossOriginWhitelist: [],
+
+      /**
+        @property applicationRootUrl
+        @private
+      */
+      applicationRootUrl: null,
+
+      /**
+        @method load
+        @private
+      */
+      load: function(container) {
+        var globalConfig              = getGlobalConfig('simple-auth');
+        this.authenticationRoute      = globalConfig.authenticationRoute || this.authenticationRoute;
+        this.routeAfterAuthentication = globalConfig.routeAfterAuthentication || this.routeAfterAuthentication;
+        this.sessionPropertyName      = globalConfig.sessionPropertyName || this.sessionPropertyName;
+        this.authorizer               = globalConfig.authorizer || this.authorizer;
+        this.session                  = globalConfig.session || this.session;
+        this.store                    = globalConfig.store || this.store;
+        this.crossOriginWhitelist     = globalConfig.crossOriginWhitelist || this.crossOriginWhitelist;
+        this.applicationRootUrl       = container.lookup('router:main').get('rootURL') || '/';
+      }
+    };
+  });
+define("simple-auth/ember", 
+  ["./initializer"],
+  function(__dependency1__) {
+    "use strict";
+    var initializer = __dependency1__["default"];
+
+    Ember.onLoad('Ember.Application', function(Application) {
+      Application.initializer(initializer);
+    });
+  });
+define("simple-auth/initializer", 
+  ["./setup","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var setup = __dependency1__["default"];
+
+    __exports__["default"] = {
+      name:       'simple-auth',
+      initialize: function(container, application) {
+        setup(container, application);
+      }
+    };
+  });
+define("simple-auth/mixins/application-route-mixin", 
+  ["./../configuration","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Configuration = __dependency1__["default"];
+
+    /**
+      The mixin for the application route; defines actions to authenticate the
+      session as well as to invalidate it. These actions can be used in all
+      templates like this:
+
+      ```handlebars
+      {{#if session.isAuthenticated}}
+        <a {{ action 'invalidateSession' }}>Logout</a>
+      {{else}}
+        <a {{ action 'authenticateSession' }}>Login</a>
+      {{/if}}
+      ```
+
+      or in the case that the application uses a dedicated route for logging in:
+
+      ```handlebars
+      {{#if session.isAuthenticated}}
+        <a {{ action 'invalidateSession' }}>Logout</a>
+      {{else}}
+        {{#link-to 'login'}}Login{{/link-to}}
+      {{/if}}
+      ```
+
+      This mixin also defines actions that are triggered whenever the session is
+      successfully authenticated or invalidated and whenever authentication or
+      invalidation fails. These actions provide a good starting point for adding
+      custom behavior to these events.
+
+      __When this mixin is used and the application's `ApplicationRoute` defines
+      the `beforeModel` method, that method has to call `_super`.__
+
+      Using this mixin is optional. Without using it, the session's events will not
+      be automatically translated into route actions but would have to be handled
+      inidivially, e.g. in an initializer:
+
+      ```javascript
+      Ember.Application.initializer({
+        name:       'authentication',
+        after:      'simple-auth',
+        initialize: function(container, application) {
+          var applicationRoute = container.lookup('route:application');
+          var session          = container.lookup('simple-auth-session:main');
+          // handle the session events
+          session.on('sessionAuthenticationSucceeded', function() {
+            applicationRoute.transitionTo('index');
+          });
+        }
+      });
+      ```
+
+      @class ApplicationRouteMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/application-route-mixin
+      @extends Ember.Mixin
+      @static
+    */
+    __exports__["default"] = Ember.Mixin.create({
+      /**
+        @method beforeModel
+        @private
+      */
+      beforeModel: function(transition) {
+        this._super(transition);
+        if (!this.get('_authEventListenersAssigned')) {
+          this.set('_authEventListenersAssigned', true);
+          var _this = this;
+          Ember.A([
+            'sessionAuthenticationSucceeded',
+            'sessionAuthenticationFailed',
+            'sessionInvalidationSucceeded',
+            'sessionInvalidationFailed',
+            'authorizationFailed'
+          ]).forEach(function(event) {
+            _this.get(Configuration.sessionPropertyName).on(event, function(error) {
+              Array.prototype.unshift.call(arguments, event);
+              transition.send.apply(transition, arguments);
+            });
+          });
+        }
+      },
+
+      actions: {
+        /**
+          This action triggers transition to the
+          [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+          It can be used in templates as shown above. It is also triggered
+          automatically by the
+          [`AuthenticatedRouteMixin`](#SimpleAuth-AuthenticatedRouteMixin) whenever
+          a route that requries authentication is accessed but the session is not
+          currently authenticated.
+
+          __For an application that works without an authentication route (e.g.
+          because it opens a new window to handle authentication there), this is
+          the action to override, e.g.:__
+
+          ```javascript
+          App.ApplicationRoute = Ember.Route.extend(SimpleAuth.ApplicationRouteMixin, {
+            actions: {
+              authenticateSession: function() {
+                this.get('session').authenticate('authenticator:custom', {});
+              }
+            }
+          });
+          ```
+
+          @method actions.authenticateSession
+        */
+        authenticateSession: function() {
+          this.transitionTo(Configuration.authenticationRoute);
+        },
+
+        /**
+          This action is triggered whenever the session is successfully
+          authenticated. If there is a transition that was previously intercepted
+          by
+          [`AuthenticatedRouteMixin#beforeModel`](#SimpleAuth-AuthenticatedRouteMixin-beforeModel)
+          it will retry it. If there is no such transition, this action transitions
+          to the
+          [`Configuration.routeAfterAuthentication`](#SimpleAuth-Configuration-routeAfterAuthentication).
+
+          @method actions.sessionAuthenticationSucceeded
+        */
+        sessionAuthenticationSucceeded: function() {
+          var attemptedTransition = this.get(Configuration.sessionPropertyName).get('attemptedTransition');
+          if (attemptedTransition) {
+            attemptedTransition.retry();
+            this.get(Configuration.sessionPropertyName).set('attemptedTransition', null);
+          } else {
+            this.transitionTo(Configuration.routeAfterAuthentication);
+          }
+        },
+
+        /**
+          This action is triggered whenever session authentication fails. The
+          `error` argument is the error object that the promise the authenticator
+          returns rejects with. (see
+          [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
+
+          It can be overridden to display error messages etc.:
+
+          ```javascript
+          App.ApplicationRoute = Ember.Route.extend(SimpleAuth.ApplicationRouteMixin, {
+            actions: {
+              sessionAuthenticationFailed: function(error) {
+                this.controllerFor('application').set('loginErrorMessage', error.message);
+              }
+            }
+          });
+          ```
+
+          @method actions.sessionAuthenticationFailed
+          @param {any} error The error the promise returned by the authenticator rejects with, see [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)
+        */
+        sessionAuthenticationFailed: function(error) {
+        },
+
+        /**
+          This action invalidates the session (see
+          [`Session#invalidate`](#SimpleAuth-Session-invalidate)).
+          If invalidation succeeds, it reloads the application (see
+          [`ApplicationRouteMixin#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
+
+          @method actions.invalidateSession
+        */
+        invalidateSession: function() {
+          this.get(Configuration.sessionPropertyName).invalidate();
+        },
+
+        /**
+          This action is invoked whenever the session is successfully invalidated.
+          It reloads the Ember.js application by redirecting the browser to the
+          application's root URL so that all in-memory data (such as Ember Data
+          stores etc.) gets cleared. The root URL is automatically retrieved from
+          the Ember.js application's router (see
+          http://emberjs.com/guides/routing/#toc_specifying-a-root-url).
+
+          @method actions.sessionInvalidationSucceeded
+        */
+        sessionInvalidationSucceeded: function() {
+          window.location.replace(Configuration.applicationRootUrl);
+        },
+
+        /**
+          This action is invoked whenever session invalidation fails. This mainly
+          serves as an extension point to add custom behavior and does nothing by
+          default.
+
+          @method actions.sessionInvalidationFailed
+          @param {any} error The error the promise returned by the authenticator rejects with, see [`Authenticators.Base#invalidate`](#SimpleAuth-Authenticators-Base-invalidate)
+        */
+        sessionInvalidationFailed: function(error) {
+        },
+
+        /**
+          This action is invoked when an authorization error occurs (which is
+          the case __when the server responds with HTTP status 401__). It
+          invalidates the session and reloads the application (see
+          [`ApplicationRouteMixin#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
+
+          @method actions.authorizationFailed
+        */
+        authorizationFailed: function() {
+          if (this.get(Configuration.sessionPropertyName).get('isAuthenticated')) {
+            this.get(Configuration.sessionPropertyName).invalidate();
+          }
+        }
+      }
+    });
+  });
+define("simple-auth/mixins/authenticated-route-mixin", 
+  ["./../configuration","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Configuration = __dependency1__["default"];
+
+    /**
+      This mixin is for routes that require the session to be authenticated to be
+      accessible. Including this mixin in a route automatically adds a hook that
+      enforces the session to be authenticated and redirects to the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute)
+      if it is not.
+
+      ```javascript
+      // app/routes/protected.js
+      import AuthenticatedRouteMixin from 'simple-auth/mixins/authenticated-route-mixin';
+
+      export default Ember.Route.extend(AuthenticatedRouteMixin);
+      ```
+
+      `AuthenticatedRouteMixin` performs the redirect in the `beforeModel` method
+      so that in all methods executed after that the session is guaranteed to be
+      authenticated. __If `beforeModel` is overridden, ensure that the custom
+      implementation calls `this._super(transition)`__ so that the session
+      enforcement code is actually executed.
+
+      @class AuthenticatedRouteMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/authenticated-route-mixin
+      @extends Ember.Mixin
+      @static
+    */
+    __exports__["default"] = Ember.Mixin.create({
+      /**
+        This method implements the enforcement of the session being authenticated.
+        If the session is not authenticated, the current transition will be aborted
+        and a redirect will be triggered to the
+        [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+        The method also saves the intercepted transition so that it can be retried
+        after the session has been authenticated (see
+        [`ApplicationRouteMixin#sessionAuthenticationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)).
+
+        @method beforeModel
+        @param {Transition} transition The transition that lead to this route
+      */
+      beforeModel: function(transition) {
+        this._super(transition);
+        if (!this.get(Configuration.sessionPropertyName).get('isAuthenticated')) {
+          transition.abort();
+          this.get(Configuration.sessionPropertyName).set('attemptedTransition', transition);
+          transition.send('authenticateSession');
+        }
+      }
+    });
+  });
+define("simple-auth/mixins/authentication-controller-mixin", 
+  ["./../configuration","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Configuration = __dependency1__["default"];
+
+    /**
+      This mixin is for the controller that handles the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+      It provides the `authenticate` action that will authenticate the session with
+      the configured authenticator (see
+      [`AuthenticationControllerMixin#authenticator`](#SimpleAuth-AuthenticationControllerMixin-authenticator)).
+
+      @class AuthenticationControllerMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/authentication-controller-mixin
+      @extends Ember.Mixin
+    */
+    __exports__["default"] = Ember.Mixin.create({
+      /**
+        The authenticator factory to use as it is registered with Ember's
+        container, see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register).
+
+        @property authenticator
+        @type String
+        @default null
+      */
+      authenticator: null,
+
+      actions: {
+        /**
+          This action will authenticate the session with the configured
+          authenticator (see
+          [`AuthenticationControllerMixin#authenticator`](#SimpleAuth-AuthenticationControllerMixin-authenticator),
+          [`Session#authenticate`](#SimpleAuth-Session-authenticate)).
+
+          @method actions.authenticate
+          @param {Object} options Any options the authenticator needs to authenticate the session
+        */
+        authenticate: function(options) {
+          var authenticator = this.get('authenticator');
+          Ember.assert('AuthenticationControllerMixin/LoginControllerMixin require the authenticator property to be set on the controller', !Ember.isEmpty(authenticator));
+          return this.get(Configuration.sessionPropertyName).authenticate(this.get('authenticator'), options);
+        }
+      }
+    });
+  });
+define("simple-auth/mixins/login-controller-mixin", 
+  ["./../configuration","./authentication-controller-mixin","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Configuration = __dependency1__["default"];
+    var AuthenticationControllerMixin = __dependency2__["default"];
+
+    /**
+      This mixin is for the controller that handles the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute)
+      if the used authentication mechanism works with a login form that asks for
+      user credentials. It provides the `authenticate` action that will
+      authenticate the session with the configured authenticator when invoked.
+      __This is a specialization of
+      [`AuthenticationControllerMixin`](#SimpleAuth-AuthenticationControllerMixin).__
+
+      Accompanying the controller that this mixin is mixed in the application needs
+      to have a `login` template with the fields `identification` and `password` as
+      well as an actionable button or link that triggers the `authenticate` action,
+      e.g.:
+
+      ```handlebars
+      <form {{action 'authenticate' on='submit'}}>
+        <label for="identification">Login</label>
+        {{input id='identification' placeholder='Enter Login' value=identification}}
+        <label for="password">Password</label>
+        {{input id='password' placeholder='Enter Password' type='password' value=password}}
+        <button type="submit">Login</button>
+      </form>
+      ```
+
+      @class LoginControllerMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/login-controller-mixin
+      @extends SimpleAuth.AuthenticationControllerMixin
+    */
+    __exports__["default"] = Ember.Mixin.create(AuthenticationControllerMixin, {
+      actions: {
+        /**
+          This action will authenticate the session with the configured
+          authenticator (see
+          [AuthenticationControllerMixin#authenticator](#SimpleAuth-Authentication-authenticator))
+          if both `identification` and `password` are non-empty. It passes both
+          values to the authenticator.
+
+          __The action also resets the `password` property so sensitive data does
+          not stay in memory for longer than necessary.__
+
+          @method actions.authenticate
+        */
+        authenticate: function() {
+          var data = this.getProperties('identification', 'password');
+          this.set('password', null);
+          return this._super(data);
+        }
+      }
+    });
+  });
+define("simple-auth/session", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      __The session provides access to the current authentication state as well as
+      any data the authenticator resolved with__ (see
+      [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
+      It is created when Ember Simple Auth is set up and __injected into all
+      controllers and routes so that these parts of the application can always
+      access the current authentication state and other data__, depending on the
+      authenticator in use and whether the session is actually authenticated (see
+      [`Authenticators.Base`](#SimpleAuth-Authenticators-Base)).
+
+      The session also provides methods to authenticate and to invalidate itself
+      (see
+      [`Session#authenticate`](#SimpleAuth-Session-authenticate),
+      [`Session#invaldiate`](#SimpleAuth-Session-invaldiate)).
+      These methods are usually invoked through actions from routes or controllers.
+      To authenticate the session manually, simple call the
+      [`Session#authenticate`](#SimpleAuth-Session-authenticate)
+      method with the authenticator factory to use as well as any options the
+      authenticator needs to authenticate the session:
+
+      ```javascript
+      this.get('session').authenticate('authenticator:custom', { some: 'option' }).then(function() {
+        // authentication was successful
+      }, function() {
+        // authentication failed
+      });
+      ```
+
+      The session also observes the store and - if it is authenticated - the
+      authenticator for changes (see
+      [`Authenticators.Base`](#SimpleAuth-Authenticators-Base)
+      end [`Stores.Base`](#SimpleAuth-Stores-Base)).
+
+      @class Session
+      @namespace SimpleAuth
+      @module simple-auth/session
+      @extends Ember.ObjectProxy
+      @uses Ember.Evented
+    */
+    __exports__["default"] = Ember.ObjectProxy.extend(Ember.Evented, {
+      /**
+        Triggered __whenever the session is successfully authenticated__. When the
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionAuthenticationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)
+        will be invoked whenever this event is triggered.
+
+        @event sessionAuthenticationSucceeded
+      */
+      /**
+        Triggered __whenever an attempt to authenticate the session fails__. When
+        the application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionAuthenticationFailed`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationFailed)
+        will be invoked whenever this event is triggered.
+
+        @event sessionAuthenticationFailed
+        @param {Object} error The error object; this depends on the authenticator in use, see [SimpleAuth.Authenticators.Base#authenticate](#SimpleAuth-Authenticators-Base-authenticate)
+      */
+      /**
+        Triggered __whenever the session is successfully invalidated__. When the
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)
+        will be invoked whenever this event is triggered.
+
+        @event sessionInvalidationSucceeded
+      */
+      /**
+        Triggered __whenever an attempt to invalidate the session fails__. When the
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionInvalidationFailed`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationFailed)
+        will be invoked whenever this event is triggered.
+
+        @event sessionInvalidationFailed
+        @param {Object} error The error object; this depends on the authenticator in use, see [SimpleAuth.Authenticators.Base#invalidate](#SimpleAuth-Authenticators-Base-invalidate)
+      */
+      /**
+        Triggered __whenever the server rejects the authorization information
+        passed with a request and responds with status 401__. When the application
+        uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#authorizationFailed`](#SimpleAuth-ApplicationRouteMixin-authorizationFailed)
+        will be invoked whenever this event is triggered.
+
+        @event authorizationFailed
+      */
+
+      /**
+        The authenticator factory to use as it is registered with Ember's
+        container, see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register).
+        This is only set when the session is currently authenticated.
+
+        @property authenticator
+        @type String
+        @readOnly
+        @default null
+      */
+      authenticator: null,
+      /**
+        The store used to persist session properties.
+
+        @property store
+        @type SimpleAuth.Stores.Base
+        @readOnly
+        @default null
+      */
+      store: null,
+      /**
+        The Ember.js container,
+
+        @property container
+        @type Container
+        @readOnly
+        @default null
+      */
+      container: null,
+      /**
+        Returns whether the session is currently authenticated.
+
+        @property isAuthenticated
+        @type Boolean
+        @readOnly
+        @default false
+      */
+      isAuthenticated: false,
+      /**
+        @property attemptedTransition
+        @private
+      */
+      attemptedTransition: null,
+      /**
+        @property content
+        @private
+      */
+      content: {},
+
+      /**
+        Authenticates the session with an `authenticator` and appropriate
+        `options`. __This delegates the actual authentication work to the
+        `authenticator`__ and handles the returned promise accordingly (see
+        [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
+        All data the authenticator resolves with will be saved in the session.
+
+        __This method returns a promise itself. A resolving promise indicates that
+        the session was successfully authenticated__ while a rejecting promise
+        indicates that authentication failed and the session remains
+        unauthenticated.
+
+        @method authenticate
+        @param {String} authenticator The authenticator factory to use as it is registered with Ember's container, see [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register)
+        @param {Object} options The options to pass to the authenticator; depending on the type of authenticator these might be a set of credentials, a Facebook OAuth Token, etc.
+        @return {Ember.RSVP.Promise} A promise that resolves when the session was authenticated successfully
+      */
+      authenticate: function(authenticator, options) {
+        Ember.assert('Session#authenticate requires the authenticator factory to be specified, was ' + authenticator, !Ember.isEmpty(authenticator));
+        var _this = this;
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          _this.container.lookup(authenticator).authenticate(options).then(function(content) {
+            _this.setup(authenticator, content, true);
+            resolve();
+          }, function(error) {
+            _this.clear();
+            _this.trigger('sessionAuthenticationFailed', error);
+            reject(error);
+          });
+        });
+      },
+
+      /**
+        Invalidates the session with the authenticator it is currently
+        authenticated with (see
+        [`Session#authenticator`](#SimpleAuth-Session-authenticator)). __This
+        invokes the authenticator's `invalidate` method and handles the returned
+        promise accordingly__ (see
+        [`Authenticators.Base#invalidate`](#SimpleAuth-Authenticators-Base-invalidate)).
+
+        __This method returns a promise itself. A resolving promise indicates that
+        the session was successfully invalidated__ while a rejecting promise
+        indicates that the promise returned by the `authenticator` rejected and
+        thus invalidation was cancelled. In that case the session remains
+        authenticated. Once the session is successfully invalidated it clears all
+        of its data.
+
+        @method invalidate
+        @return {Ember.RSVP.Promise} A promise that resolves when the session was invalidated successfully
+      */
+      invalidate: function() {
+        Ember.assert('Session#invalidate requires the session to be authenticated', this.get('isAuthenticated'));
+        var _this = this;
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          var authenticator = _this.container.lookup(_this.authenticator);
+          authenticator.invalidate(_this.content).then(function() {
+            authenticator.off('sessionDataUpdated');
+            _this.clear(true);
+            resolve();
+          }, function(error) {
+            _this.trigger('sessionInvalidationFailed', error);
+            reject(error);
+          });
+        });
+      },
+
+      /**
+        @method restore
+        @private
+      */
+      restore: function() {
+        var _this = this;
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          var restoredContent = _this.store.restore();
+          var authenticator   = restoredContent.authenticator;
+          if (!!authenticator) {
+            delete restoredContent.authenticator;
+            _this.container.lookup(authenticator).restore(restoredContent).then(function(content) {
+              _this.setup(authenticator, content);
+              resolve();
+            }, function() {
+              _this.store.clear();
+              reject();
+            });
+          } else {
+            _this.store.clear();
+            reject();
+          }
+        });
+      },
+
+      /**
+        @method setup
+        @private
+      */
+      setup: function(authenticator, content, trigger) {
+        content = Ember.merge(Ember.merge({}, this.content), content);
+        trigger = !!trigger && !this.get('isAuthenticated');
+        this.beginPropertyChanges();
+        this.setProperties({
+          isAuthenticated: true,
+          authenticator:   authenticator,
+          content:         content
+        });
+        this.bindToAuthenticatorEvents();
+        this.updateStore();
+        this.endPropertyChanges();
+        if (trigger) {
+          this.trigger('sessionAuthenticationSucceeded');
+        }
+      },
+
+      /**
+        @method clear
+        @private
+      */
+      clear: function(trigger) {
+        trigger = !!trigger && this.get('isAuthenticated');
+        this.beginPropertyChanges();
+        this.setProperties({
+          isAuthenticated: false,
+          authenticator:   null,
+          content:         {}
+        });
+        this.store.clear();
+        this.endPropertyChanges();
+        if (trigger) {
+          this.trigger('sessionInvalidationSucceeded');
+        }
+      },
+
+      /**
+        @method setUnknownProperty
+        @private
+      */
+      setUnknownProperty: function(key, value) {
+        var result = this._super(key, value);
+        this.updateStore();
+        return result;
+      },
+
+      /**
+        @method updateStore
+        @private
+      */
+      updateStore: function() {
+        var data = this.content;
+        if (!Ember.isEmpty(this.authenticator)) {
+          data = Ember.merge({ authenticator: this.authenticator }, data);
+        }
+        if (!Ember.isEmpty(data)) {
+          this.store.persist(data);
+        }
+      },
+
+      /**
+        @method bindToAuthenticatorEvents
+        @private
+      */
+      bindToAuthenticatorEvents: function() {
+        var _this = this;
+        var authenticator = this.container.lookup(this.authenticator);
+        authenticator.off('sessionDataUpdated');
+        authenticator.off('sessionDataInvalidated');
+        authenticator.on('sessionDataUpdated', function(content) {
+          _this.setup(_this.authenticator, content);
+        });
+        authenticator.on('sessionDataInvalidated', function(content) {
+          _this.clear(true);
+        });
+      },
+
+      /**
+        @method bindToStoreEvents
+        @private
+      */
+      bindToStoreEvents: function() {
+        var _this = this;
+        this.store.on('sessionDataUpdated', function(content) {
+          var authenticator = content.authenticator;
+          if (!!authenticator) {
+            delete content.authenticator;
+            _this.container.lookup(authenticator).restore(content).then(function(content) {
+              _this.setup(authenticator, content, true);
+            }, function() {
+              _this.clear(true);
+            });
+          } else {
+            _this.clear(true);
+          }
+        });
+      }.observes('store')
+    });
+  });
+define("simple-auth/setup", 
+  ["./configuration","./session","./stores/local-storage","./stores/ephemeral","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    var Configuration = __dependency1__["default"];
+    var Session = __dependency2__["default"];
+    var LocalStorage = __dependency3__["default"];
+    var Ephemeral = __dependency4__["default"];
+
+    function extractLocationOrigin(location) {
+      if (Ember.typeOf(location) === 'string') {
+        var link = document.createElement('a');
+        link.href = location;
+        //IE requires the following line when url is relative.
+        //First assignment of relative url to link.href results in absolute url on link.href but link.hostname and other properties are not set
+        //Second assignment of absolute url to link.href results in link.hostname and other properties being set as expected
+        link.href = link.href;
+        location = link;
+      }
+      var port = location.port;
+      if (Ember.isEmpty(port)) {
+        //need to include the port whether its actually present or not as some versions of IE will always set it
+        port = location.protocol === 'http:' ? '80' : (location.protocol === 'https:' ? '443' : '');
+      }
+      return location.protocol + '//' + location.hostname + (port !== '' ? ':' + port : '');
+    }
+
+    var urlOrigins     = {};
+    var crossOriginWhitelist;
+    function shouldAuthorizeRequest(options) {
+      if (options.crossDomain === false) {
+        return true;
+      }
+      var urlOrigin = urlOrigins[options.url] = urlOrigins[options.url] || extractLocationOrigin(options.url);
+      return crossOriginWhitelist.indexOf(urlOrigin) > -1;
+    }
+
+    function registerFactories(container) {
+      container.register('simple-auth-session-store:local-storage', LocalStorage);
+      container.register('simple-auth-session-store:ephemeral', Ephemeral);
+      container.register('simple-auth-session:main', Session);
+    }
+
+    /**
+      @method setup
+      @private
+    **/
+    __exports__["default"] = function(container, application) {
+      Configuration.load(container);
+      application.deferReadiness();
+      registerFactories(container);
+
+      var store   = container.lookup(Configuration.store);
+      var session = container.lookup(Configuration.session);
+      session.setProperties({ store: store, container: container });
+      Ember.A(['controller', 'route']).forEach(function(component) {
+        container.injection(component, Configuration.sessionPropertyName, Configuration.session);
+      });
+
+      crossOriginWhitelist = Ember.A(Configuration.crossOriginWhitelist).map(function(origin) {
+        return extractLocationOrigin(origin);
+      });
+
+      if (!Ember.isEmpty(Configuration.authorizer)) {
+        var authorizer = container.lookup(Configuration.authorizer);
+        if (!!authorizer) {
+          authorizer.set('session', session);
+          Ember.$.ajaxPrefilter(function(options, originalOptions, jqXHR) {
+            if (!authorizer.isDestroyed && shouldAuthorizeRequest(options)) {
+              authorizer.authorize(jqXHR, options);
+            }
+          });
+          Ember.$(document).ajaxError(function(event, jqXHR, setting, exception) {
+            if (jqXHR.status === 401) {
+              session.trigger('authorizationFailed');
+            }
+          });
+        }
+      } else {
+        Ember.Logger.debug('No authorizer factory was configured for Ember Simple Auth - specify one if backend requests need to be authorized.');
+      }
+
+      var advanceReadiness = function() {
+        application.advanceReadiness();
+      };
+      session.restore().then(advanceReadiness, advanceReadiness);
+    }
+  });
+define("simple-auth/stores/base", 
+  ["../utils/flat-objects-are-equal","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var flatObjectsAreEqual = __dependency1__["default"];
+
+    /**
+      The base for all store types. __This serves as a starting point for
+      implementing custom stores and must not be used directly.__
+
+      Stores are used to persist the session's state so it survives a page reload
+      and is synchronized across multiple tabs or windows of the same application.
+      The store to be used with the application can be configured in the global
+      configuration object:
+
+      ```js
+      window.ENV = window.ENV || {};
+      window.ENV['simple-auth'] = {
+        store: 'simple-auth-session-store:local-storage'
+      }
+      ```
+
+      @class Base
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/base
+      @extends Ember.Object
+      @uses Ember.Evented
+    */
+    __exports__["default"] = Ember.Object.extend(Ember.Evented, {
+      /**
+        __Triggered when the data that constitutes the session changes in the
+        store. This usually happens because the session is authenticated or
+        invalidated in another tab or window.__ The session automatically catches
+        that event, passes the updated data to its authenticator's
+        [`Authenticators.Base#restore`](#SimpleAuth-Authenticators-Base-restore)
+        method and handles the result of that invocation accordingly.
+
+        @event sessionDataUpdated
+        @param {Object} data The updated session data
+      */
+
+      /**
+        Persists the `data` in the store. This actually replaces all currently
+        stored data.
+
+        `Stores.Base`'s implementation does nothing.
+
+        @method persist
+        @param {Object} data The data to persist
+      */
+      persist: function(data) {
+      },
+
+      /**
+        Restores all data currently saved in the store as a plain object.
+
+        `Stores.Base`'s implementation always returns an empty plain Object.
+
+        @method restore
+        @return {Object} The data currently persisted in the store.
+      */
+      restore: function() {
+        return {};
+      },
+
+      /**
+        Clears the store.
+
+        `Stores.Base`'s implementation does nothing.
+
+        @method clear
+      */
+      clear: function() {
+      }
+    });
+  });
+define("simple-auth/stores/ephemeral", 
+  ["./base","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Base = __dependency1__["default"];
+
+    /**
+      Store that saves its data in memory and thus __is not actually persistent__.
+      It does also not synchronize the session's state across multiple tabs or
+      windows as those cannot share memory.
+
+      __This store is mainly useful for testing.__
+
+      _The factory for this store is registered as
+      `'simple-auth-session-store:ephemeral'` in Ember's container._
+
+      @class Ephemeral
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/ephemeral
+      @extends Stores.Base
+    */
+    __exports__["default"] = Base.extend({
+      /**
+        @method init
+        @private
+      */
+      init: function() {
+        this.clear();
+      },
+
+      /**
+        Persists the `data`.
+
+        @method persist
+        @param {Object} data The data to persist
+      */
+      persist: function(data) {
+        this._data = JSON.stringify(data || {});
+      },
+
+      /**
+        Restores all data currently saved as a plain object.
+
+        @method restore
+        @return {Object} All data currently persisted
+      */
+      restore: function() {
+        return JSON.parse(this._data) || {};
+      },
+
+      /**
+        Clears the store.
+
+        @method clear
+      */
+      clear: function() {
+        delete this._data;
+        this._data = '{}';
+      }
+    });
+  });
+define("simple-auth/stores/local-storage", 
+  ["./base","../utils/flat-objects-are-equal","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Base = __dependency1__["default"];
+    var flatObjectsAreEqual = __dependency2__["default"];
+
+    /**
+      Store that saves its data in the browser's `localStorage`.
+
+      _The factory for this store is registered as
+      `'simple-auth-session-store:local-storage'` in Ember's container._
+
+      __`Stores.LocalStorage` is Ember Simple Auth's default store.__
+
+      @class LocalStorage
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/local-storage
+      @extends Stores.Base
+    */
+    __exports__["default"] = Base.extend({
+      /**
+        The key the store stores the data in.
+
+        @property key
+        @type String
+        @default 'ember_simple_auth:session'
+      */
+      key: 'ember_simple_auth:session',
+
+      /**
+        @method init
+        @private
+      */
+      init: function() {
+        this.bindToStorageEvents();
+      },
+
+      /**
+        Persists the `data` in the `localStorage`.
+
+        @method persist
+        @param {Object} data The data to persist
+      */
+      persist: function(data) {
+        data = JSON.stringify(data || {});
+        localStorage.setItem(this.key, data);
+        this._lastData = this.restore();
+      },
+
+      /**
+        Restores all data currently saved in the `localStorage` identified by the
+        `keyPrefix` as one plain object.
+
+        @method restore
+        @return {Object} All data currently persisted in the `localStorage`
+      */
+      restore: function() {
+        var data = localStorage.getItem(this.key);
+        return JSON.parse(data) || {};
+      },
+
+      /**
+        Clears the store by deleting all `localStorage` keys prefixed with the
+        `keyPrefix`.
+
+        @method clear
+      */
+      clear: function() {
+        localStorage.removeItem(this.key);
+        this._lastData = null;
+      },
+
+      /**
+        @method bindToStorageEvents
+        @private
+      */
+      bindToStorageEvents: function() {
+        var _this = this;
+        Ember.$(window).bind('storage', function(e) {
+          var data = _this.restore();
+          if (!flatObjectsAreEqual(data, _this._lastData)) {
+            _this._lastData = data;
+            _this.trigger('sessionDataUpdated', data);
+          }
+        });
+      }
+    });
+  });
+define("simple-auth/utils/flat-objects-are-equal", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      @method flatObjectsAreEqual
+      @private
+    */
+    __exports__["default"] = function(a, b) {
+      function sortObject(object) {
+        var array = [];
+        for (var property in object) {
+          array.push([property, object[property]]);
+        }
+        return array.sort(function(a, b) {
+          if (a[0] < b[0]) {
+            return -1;
+          } else if (a[0] > b[0]) {
+            return 1;
+          } else {
+            return 0;
+          }
+        });
+      }
+      return JSON.stringify(sortObject(a)) === JSON.stringify(sortObject(b));
+    }
+  });
+define("simple-auth/utils/get-global-config", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {};
+
+    __exports__["default"] = function(scope) {
+      return(global.ENV || {})[scope] || {};
+    }
+  });
+define("simple-auth/utils/is-secure-url", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      @method isSecureUrl
+      @private
+    */
+    __exports__["default"] = function(url) {
+      var link  = document.createElement('a');
+      link.href = url;
+      link.href = link.href;
+      return link.protocol == 'https:';
+    }
+  });
+})((typeof global !== 'undefined') ? global : window);