ember-source 2.16.0.beta.1 → 2.16.0.beta.2

data/dist/ember.prod.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.16.0-beta.1
+ * @version   2.16.0-beta.2
  */
 
 var enifed, requireModule, Ember;
@@ -9487,7 +9487,6 @@ enifed('backburner', ['exports'], function (exports) {
             this.name = name;
             this.options = options;
             this.globalOptions = globalOptions;
-            this.globalOptions.onError = getOnError(globalOptions);
         }
 
         Queue.prototype.push = function (target, method, args, stack) {
@@ -9517,14 +9516,13 @@ enifed('backburner', ['exports'], function (exports) {
             var _options = this.options,
                 before = _options.before,
                 after = _options.after,
+                onError,
                 i;
 
             var target = void 0;
             var method = void 0;
             var args = void 0;
             var errorRecordedForStack = void 0;
-            var onError = this.globalOptions.onError;
-            var invoke = onError ? this.invokeWithOnError : this.invoke;
             this.targetQueues = Object.create(null);
             var queueItems = void 0;
             if (this._queueBeingFlushed.length > 0) {
@@ -9536,33 +9534,39 @@ enifed('backburner', ['exports'], function (exports) {
             if (before) {
                 before();
             }
-            for (i = this.index; i < queueItems.length; i += 4) {
-                this.index += 4;
-                target = queueItems[i];
-                method = queueItems[i + 1];
-                args = queueItems[i + 2];
-                errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
-                // method could have been nullified / canceled during flush
-                if (method !== null) {
-                    //
-                    //    ** Attention intrepid developer **
-                    //
-                    //    To find out the stack of this task when it was scheduled onto
-                    //    the run loop, add the following to your app.js:
-                    //
-                    //    Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production.
-                    //
-                    //    Once that is in place, when you are at a breakpoint and navigate
-                    //    here in the stack explorer, you can look at `errorRecordedForStack.stack`,
-                    //    which will be the captured stack when this job was scheduled.
-                    //
-                    //    One possible long-term solution is the following Chrome issue:
-                    //       https://bugs.chromium.org/p/chromium/issues/detail?id=332624
-                    //
-                    invoke(target, method, args, onError, errorRecordedForStack);
-                }
-                if (this.index !== this._queueBeingFlushed.length && this.globalOptions.mustYield && this.globalOptions.mustYield()) {
-                    return 1 /* Pause */;
+            var invoke = void 0;
+            if (queueItems.length > 0) {
+                onError = getOnError(this.globalOptions);
+
+                invoke = onError ? this.invokeWithOnError : this.invoke;
+                for (i = this.index; i < queueItems.length; i += 4) {
+                    this.index += 4;
+                    target = queueItems[i];
+                    method = queueItems[i + 1];
+                    args = queueItems[i + 2];
+                    errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
+                    // method could have been nullified / canceled during flush
+                    if (method !== null) {
+                        //
+                        //    ** Attention intrepid developer **
+                        //
+                        //    To find out the stack of this task when it was scheduled onto
+                        //    the run loop, add the following to your app.js:
+                        //
+                        //    Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production.
+                        //
+                        //    Once that is in place, when you are at a breakpoint and navigate
+                        //    here in the stack explorer, you can look at `errorRecordedForStack.stack`,
+                        //    which will be the captured stack when this job was scheduled.
+                        //
+                        //    One possible long-term solution is the following Chrome issue:
+                        //       https://bugs.chromium.org/p/chromium/issues/detail?id=332624
+                        //
+                        invoke(target, method, args, onError, errorRecordedForStack);
+                    }
+                    if (this.index !== this._queueBeingFlushed.length && this.globalOptions.mustYield && this.globalOptions.mustYield()) {
+                        return 1 /* Pause */;
+                    }
                 }
             }
             if (after) {
@@ -9773,7 +9777,6 @@ enifed('backburner', ['exports'], function (exports) {
 
     // accepts a function that when invoked will return an iterator
     // iterator will drain until completion
-    // accepts a function that when invoked will return an iterator
     var iteratorDrain = function (fn) {
         var iterator = fn();
         var result = iterator.next();
@@ -9783,7 +9786,6 @@ enifed('backburner', ['exports'], function (exports) {
         }
     };
 
-    var now = Date.now;
     var noop = function () {};
 
     var Backburner = function () {
@@ -9824,6 +9826,9 @@ enifed('backburner', ['exports'], function (exports) {
                 return platform.setTimeout(fn, 0);
             };
             platform.clearNext = _platform.clearNext || platform.clearTimeout;
+            platform.now = _platform.now || function () {
+                return Date.now();
+            };
             this._platform = platform;
             this._boundRunExpiredTimers = function () {
                 _this._runExpiredTimers();
@@ -10122,7 +10127,7 @@ enifed('backburner', ['exports'], function (exports) {
                 }
             }
             var onError = getOnError(this.options);
-            var executeAt = now() + wait;
+            var executeAt = this._platform.now() + wait;
             var fn = void 0;
             if (onError) {
                 fn = function () {
@@ -10342,7 +10347,7 @@ enifed('backburner', ['exports'], function (exports) {
             var l = timers.length;
             var i = 0;
             var defaultQueue = this.options.defaultQueue;
-            var n = now();
+            var n = this._platform.now();
             for (; i < l; i += 2) {
                 executeAt = timers[i];
 
@@ -10376,7 +10381,7 @@ enifed('backburner', ['exports'], function (exports) {
                 return;
             }
             var minExpiresAt = this._timers[0];
-            var n = now();
+            var n = this._platform.now();
             var wait = Math.max(0, minExpiresAt - n);
             this._timerTimeoutId = this._platform.setTimeout(this._boundRunExpiredTimers, wait);
         };
@@ -10400,7 +10405,7 @@ enifed('backburner', ['exports'], function (exports) {
 
     exports.default = Backburner;
 });
-enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment'], function (exports, _emberUtils, _emberDebug) {
+enifed('container', ['exports', 'ember-utils', 'ember-debug'], function (exports, _emberUtils, _emberDebug) {
   'use strict';
 
   exports.Container = exports.privatize = exports.Registry = undefined;
@@ -10727,7 +10732,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
       if (typeof this.class._initFactory === 'function') {
         this.class._initFactory(this);
       } else {
-        // in the non-Ember.Object case we need to still setOwner
+        // in the non-EmberObject case we need to still setOwner
         // this is required for supporting glimmer environment and
         // template instantiation which rely heavily on
         // `options[OWNER]` being passed into `create`
@@ -12631,7 +12636,7 @@ enifed('ember-application/system/engine-parent', ['exports', 'ember-utils'], fun
     @param {EngineInstance} engine An engine instance.
     @return {EngineInstance} The parent engine instance.
     @for Ember
-    @public
+    @private
   */
   function (engine) {
     return engine[ENGINE_PARENT];
@@ -12780,65 +12785,83 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
        * `name` allows you to specify under which name the initializer is registered.
       This must be a unique name, as trying to register two initializers with the
       same name will result in an error.
-       ```javascript
-      Ember.Application.initializer({
-        name: 'namedInitializer',
-         initialize: function(application) {
-          Ember.debug('Running namedInitializer!');
-        }
-      });
+       ```app/initializer/named-initializer.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('Running namedInitializer!');
+      }
+       export default {
+        name: 'named-initializer',
+        initialize
+      };
       ```
        * `before` and `after` are used to ensure that this initializer is ran prior
       or after the one identified by the value. This value can be a single string
       or an array of strings, referencing the `name` of other initializers.
        An example of ordering initializers, we create an initializer named `first`:
-       ```javascript
-      Ember.Application.initializer({
+       ```app/initializer/first.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('First initializer!');
+      }
+       export default {
         name: 'first',
-         initialize: function(application) {
-          Ember.debug('First initializer!');
-        }
-      });
-       // DEBUG: First initializer!
+        initialize
+      };
+      ```
+       ```bash
+      // DEBUG: First initializer!
       ```
        We add another initializer named `second`, specifying that it should run
       after the initializer named `first`:
-       ```javascript
-      Ember.Application.initializer({
+       ```app/initializer/second.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('Second initializer!');
+      }
+       export default {
         name: 'second',
         after: 'first',
-         initialize: function(application) {
-          Ember.debug('Second initializer!');
-        }
-      });
-       // DEBUG: First initializer!
+        initialize
+      };
+      ```
+       ```
+      // DEBUG: First initializer!
       // DEBUG: Second initializer!
       ```
        Afterwards we add a further initializer named `pre`, this time specifying
       that it should run before the initializer named `first`:
-       ```javascript
-      Ember.Application.initializer({
+       ```app/initializer/pre.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('Pre initializer!');
+      }
+       export default {
         name: 'pre',
         before: 'first',
-         initialize: function(application) {
-          Ember.debug('Pre initializer!');
-        }
-      });
-       // DEBUG: Pre initializer!
+        initialize
+      };
+      ```
+       ```bash
+      // DEBUG: Pre initializer!
       // DEBUG: First initializer!
       // DEBUG: Second initializer!
       ```
        Finally we add an initializer named `post`, specifying it should run after
       both the `first` and the `second` initializers:
-       ```javascript
-      Ember.Application.initializer({
+       ```app/initializer/post.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('Post initializer!');
+      }
+       export default {
         name: 'post',
         after: ['first', 'second'],
-         initialize: function(application) {
-          Ember.debug('Post initializer!');
-        }
-      });
-       // DEBUG: Pre initializer!
+        initialize
+      };
+      ```
+       ```bash
+      // DEBUG: Pre initializer!
       // DEBUG: First initializer!
       // DEBUG: Second initializer!
       // DEBUG: Post initializer!
@@ -12846,13 +12869,16 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
        * `initialize` is a callback function that receives one argument,
         `application`, on which you can operate.
        Example of using `application` to register an adapter:
-       ```javascript
-      Ember.Application.initializer({
-        name: 'api-adapter',
-         initialize: function(application) {
-          application.register('api-adapter:main', ApiAdapter);
-        }
-      });
+       ```app/initializer/api-adapter.js
+      import ApiAdapter from '../utils/api-adapter';
+       export function initialize(application) {
+        application.register('api-adapter:main', ApiAdapter);
+      }
+       export default {
+        name: 'post',
+        after: ['first', 'second'],
+        initialize
+      };
       ```
        @method initializer
       @param initializer {Object}
@@ -12872,13 +12898,15 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
        * `name` allows you to specify under which name the instanceInitializer is
       registered. This must be a unique name, as trying to register two
       instanceInitializer with the same name will result in an error.
-       ```javascript
-      Ember.Application.instanceInitializer({
-        name: 'namedinstanceInitializer',
-         initialize: function(application) {
-          Ember.debug('Running namedInitializer!');
-        }
-      });
+       ```app/initializer/named-instance-initializer.js
+      import { debug } from '@ember/debug';
+       export function initialize() {
+        debug('Running named-instance-initializer!');
+      }
+       export default {
+        name: 'named-instance-initializer',
+        initialize
+      };
       ```
        * `before` and `after` are used to ensure that this initializer is ran prior
       or after the one identified by the value. This value can be a single string
@@ -12886,10 +12914,9 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
        * See Ember.Application.initializer for discussion on the usage of before
       and after.
        Example instanceInitializer to preload data into the store.
-       ```javascript
-      Ember.Application.initializer({
-        name: 'preload-data',
-         initialize: function(application) {
+       ```app/initializer/preload-data.js
+      import $ from 'jquery';
+       export function initialize(application) {
           var userConfig, userConfigEncoded, store;
           // We have a HTML escaped JSON representation of the user's basic
           // configuration generated server side and stored in the DOM of the main
@@ -12898,17 +12925,19 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
           // needed for immediate rendering of the page. Keep in mind, this data,
           // like all local models and data can be manipulated by the user, so it
           // should not be relied upon for security or authorization.
-          //
-          // Grab the encoded data from the meta tag
-          userConfigEncoded = Ember.$('head meta[name=app-user-config]').attr('content');
-          // Unescape the text, then parse the resulting JSON into a real object
+           // Grab the encoded data from the meta tag
+          userConfigEncoded = $('head meta[name=app-user-config]').attr('content');
+           // Unescape the text, then parse the resulting JSON into a real object
           userConfig = JSON.parse(unescape(userConfigEncoded));
-          // Lookup the store
+           // Lookup the store
           store = application.lookup('service:store');
-          // Push the encoded JSON into the store
+           // Push the encoded JSON into the store
           store.pushPayload(userConfig);
-        }
-      });
+      }
+       export default {
+        name: 'named-instance-initializer',
+        initialize
+      };
       ```
        @method instanceInitializer
       @param instanceInitializer
@@ -12936,7 +12965,7 @@ enifed('ember-application/system/engine', ['exports', 'ember-babel', 'ember-util
 
     /**
       Set this to provide an alternate class to `Ember.DefaultResolver`
-        @deprecated Use 'Resolver' instead
+       @deprecated Use 'Resolver' instead
       @property resolver
       @public
     */
@@ -13091,12 +13120,16 @@ enifed('ember-application/system/resolver', ['exports', 'ember-utils', 'ember-me
     in a subclass. For example, you could enhance how a template
     is resolved like so:
   
-    ```javascript
-    App = Ember.Application.create({
-      Resolver: Ember.DefaultResolver.extend({
-        resolveTemplate: function(parsedName) {
+    ```app/app.js
+    import Application from '@ember/application';
+    import GlobalsResolver from '@ember/application/globals-resolver';
+  
+    App = Application.create({
+      Resolver: GlobalsResolver.extend({
+        resolveTemplate(parsedName) {
           let resolvedTemplate = this._super(parsedName);
           if (resolvedTemplate) { return resolvedTemplate; }
+  
           return Ember.TEMPLATES['not_found'];
         }
       })
@@ -13385,10 +13418,10 @@ enifed('ember-application/system/resolver', ['exports', 'ember-utils', 'ember-me
     },
 
     /**
-     @method _logLookup
-     @param {Boolean} found
-     @param {Object} parsedName
-     @private
+      @method _logLookup
+      @param {Boolean} found
+      @param {Object} parsedName
+      @private
     */
     _logLookup: function (found, parsedName) {
       var symbol = found ? '[✓]' : '[ ]';
@@ -13404,11 +13437,11 @@ enifed('ember-application/system/resolver', ['exports', 'ember-utils', 'ember-me
     },
 
     /**
-     Used to iterate all items of a given type.
-      @method knownForType
-     @param {String} type the type to search for
-     @private
-     */
+      Used to iterate all items of a given type.
+       @method knownForType
+      @param {String} type the type to search for
+      @private
+    */
     knownForType: function (type) {
       var namespace = (0, _emberMetal.get)(this, 'namespace'),
           index,
@@ -13435,16 +13468,15 @@ enifed('ember-application/system/resolver', ['exports', 'ember-utils', 'ember-me
     },
 
     /**
-     Converts provided name from the backing namespace into a container lookup name.
-      Examples:
-      App.FooBarHelper -> helper:foo-bar
-     App.THelper -> helper:t
-      @method translateToContainerFullname
-     @param {String} type
-     @param {String} name
-     @private
-     */
-
+      Converts provided name from the backing namespace into a container lookup name.
+       Examples:
+       * App.FooBarHelper -> helper:foo-bar
+      * App.THelper -> helper:t
+       @method translateToContainerFullname
+      @param {String} type
+      @param {String} name
+      @private
+    */
     translateToContainerFullname: function (type, name) {
       var suffix = _emberRuntime.String.classify(type);
       var namePrefix = name.slice(0, suffix.length * -1);
@@ -15587,9 +15619,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     `hello` for the `person-profile` component:
   
     ```app/components/person-profile.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       actions: {
         hello(name) {
           console.log("Hello", name);
@@ -15621,9 +15653,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     The following component class:
   
     ```app/components/emphasized-paragraph.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'em'
     });
     ```
@@ -15641,9 +15673,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     `classNames` property that is set to an array of strings:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNames: ['my-class', 'my-other-class']
     });
     ```
@@ -15660,9 +15692,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     attribute. These properties can be computed properties:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['propertyA', 'propertyB'],
       propertyA: 'from-a',
       propertyB: Ember.computed(function() {
@@ -15682,9 +15714,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     The class name will not be added if the value is `false` or `undefined`.
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['hovered'],
       hovered: true
     });
@@ -15701,9 +15733,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     preferred value after a ":" character when defining the binding:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['awesome:so-very-cool'],
       awesome: true
     });
@@ -15719,9 +15751,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     camelCase-style format will be converted to a dasherized format:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['isUrgent'],
       isUrgent: true
     });
@@ -15737,9 +15769,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     traversing a path relative to the component itself:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['messages.empty'],
       messages: Ember.Object.create({
         empty: true
@@ -15758,9 +15790,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     like this:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['isEnabled:enabled:disabled'],
       isEnabled: true
     });
@@ -15782,10 +15814,10 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     This syntax offers the convenience to add a class if a property is `false`:
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
     // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
-    export default Ember.Component.extend({
+    export default Component.extend({
       classNameBindings: ['isEnabled::disabled'],
       isEnabled: true
     });
@@ -15821,9 +15853,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     HTML associated attribute:
   
     ```app/components/my-anchor.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'a',
       attributeBindings: ['href'],
       href: 'http://google.com'
@@ -15840,9 +15872,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     the source property and the destination property:
   
     ```app/components/my-anchor.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'a',
       attributeBindings: ['url:href'],
       url: 'http://google.com'
@@ -15859,9 +15891,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     mapped, since `:` is not a valid character for properties in Javascript:
   
     ```app/components/my-use.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'use',
       attributeBindings: ['xlinkHref:xlink:href'],
       xlinkHref: '#triangle'
@@ -15878,9 +15910,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     the attribute will be present or absent depending on the value:
   
     ```app/components/my-text-input.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'input',
       attributeBindings: ['disabled'],
       disabled: false
@@ -15896,9 +15928,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     `attributeBindings` can refer to computed properties:
   
     ```app/components/my-text-input.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'input',
       attributeBindings: ['disabled'],
       disabled: Ember.computed(function() {
@@ -15915,9 +15947,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     return value of the `attributeBindings` monitored property:
   
     ```app/components/my-text-input.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       tagName: 'form',
       attributeBindings: ['novalidate'],
       novalidate: null
@@ -15945,10 +15977,10 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     ```
   
     ```app/components/person-profile.js
-      import Ember from 'ember';
+      import Component from '@ember/component';
       import layout from '../templates/components/person-profile';
   
-      export default Ember.Component.extend({
+      export default Component.extend({
         layout
       });
     ```
@@ -15978,9 +16010,9 @@ enifed('ember-glimmer/component', ['exports', 'ember-utils', 'ember-views', 'emb
     argument to this method.
   
     ```app/components/my-widget.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       click(event) {
         // will be called when an instance's
         // rendered element is clicked
@@ -16870,13 +16902,13 @@ enifed('ember-glimmer/components/link-to', ['exports', 'ember-console', 'ember-d
   
     ### Allowing Default Action
   
-   By default the `{{link-to}}` component prevents the default browser action
-   by calling `preventDefault()` as this sort of action bubbling is normally
-   handled internally and we do not want to take the browser to a new URL (for
-   example).
+    By default the `{{link-to}}` component prevents the default browser action
+    by calling `preventDefault()` as this sort of action bubbling is normally
+    handled internally and we do not want to take the browser to a new URL (for
+    example).
   
-   If you need to override this behavior specify `preventDefault=false` in
-   your template:
+    If you need to override this behavior specify `preventDefault=false` in
+    your template:
   
     ```handlebars
     {{#link-to 'photoGallery' aPhotoId preventDefault=false}}
@@ -17010,7 +17042,8 @@ enifed('ember-glimmer/components/text_field', ['exports', 'ember-metal', 'ember-
     layout: _empty.default,
     classNames: ['ember-text-field'],
     tagName: 'input',
-    attributeBindings: ['accept', 'autocomplete', 'autosave', 'dir', 'formaction', 'formenctype', 'formmethod', 'formnovalidate', 'formtarget', 'height', 'inputmode', 'lang', 'list', 'max', 'min', 'multiple', 'name', 'pattern', 'size', 'step', 'type', 'value', 'width'],
+    attributeBindings: ['accept', 'autocomplete', 'autosave', 'dir', 'formaction', 'formenctype', 'formmethod', 'formnovalidate', 'formtarget', 'height', 'inputmode', 'lang', 'list', 'type', // needs to be before min and max. See #15675
+    'max', 'min', 'multiple', 'name', 'pattern', 'size', 'step', 'value', 'width'],
 
     /**
       The `value` attribute of the input element. As the user inputs text, this
@@ -17397,9 +17430,10 @@ enifed('ember-glimmer/helper', ['exports', 'ember-utils', 'ember-runtime', '@gli
     The `helper` method create pure-function helpers without instances. For
     example:
   
-    ```js
-    // app/helpers/format-currency.js
-    export default Ember.Helper.helper(function(params, hash) {
+    ```app/helpers/format-currency.js
+    import { helper } from '@ember/component/helper';
+  
+    export default helper(function(params, hash) {
       let cents = params[0];
       let currency = hash.currency;
       return `${currency}${cents * 0.01}`;
@@ -17438,8 +17472,10 @@ enifed('ember-glimmer/helper', ['exports', 'ember-utils', 'ember-runtime', '@gli
   
     Helpers defined using a class must provide a `compute` function. For example:
   
-    ```js
-    export default Ember.Helper.extend({
+    ```app/helpers/format-currency.js
+    import Helper from '@ember/component/helper';
+  
+    export default Helper.extend({
       compute(params, hash) {
         let cents = params[0];
         let currency = hash.currency;
@@ -17678,10 +17714,10 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
   
     Here is an example action handler on a component:
   
-    ```js
-    import Ember from 'ember';
+    ```app/components/my-component.js
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       actions: {
         save() {
           this.get('model').save();
@@ -17710,8 +17746,10 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
     additional arguments are passed to the action function. This has interesting
     properties combined with currying of arguments. For example:
   
-    ```js
-    export default Ember.Component.extend({
+    ```app/components/my-component.js
+    import Component from '@ember/component';
+  
+    export default Component.extend({
       actions: {
         // Usage {{input on-input=(action (action 'setName' model) value="target.value")}}
         setName(model, name) {
@@ -17730,9 +17768,9 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
     with `on-input` above. For example:
   
     ```app/components/my-input.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       actions: {
         setName(model, name) {
           model.set('name', name);
@@ -17746,9 +17784,9 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
     ```
   
     ```app/components/my-component.js
-    import Ember from 'ember';
+    import Component from '@ember/component';
   
-    export default Ember.Component.extend({
+    export default Component.extend({
       click() {
         // Note that model is not passed, it was curried in the template
         this.sendAction('submit', 'bob');
@@ -17804,7 +17842,7 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
     ```
   
     ```app/helpers/disable-bubbling.js
-    import Ember from 'ember';
+    import { helper } from '@ember/component/helper';
   
     export function disableBubbling([action]) {
       return function(event) {
@@ -17812,7 +17850,7 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
         return action(event);
       };
     }
-    export default Ember.Helper.helper(disableBubbling);
+    export default helper(disableBubbling);
     ```
   
     If you need the default handler to trigger you should either register your
@@ -17869,10 +17907,11 @@ enifed('ember-glimmer/helpers/action', ['exports', 'ember-utils', 'ember-metal',
     ```
   
     ```app/controllers/application.js
-    import Ember from 'ember';
+    import Controller from '@ember/controller';
+    import { inject as service } from '@ember/service';
   
-    export default Ember.Controller.extend({
-      someService: Ember.inject.service()
+    export default Controller.extend({
+      someService: service()
     });
     ```
   
@@ -18313,7 +18352,7 @@ enifed('ember-glimmer/helpers/get', ['exports', 'ember-babel', 'ember-metal', 'e
       var path = this.lastPath = this.pathReference.value();
 
       if (path !== lastPath) {
-        if (path) {
+        if (path !== undefined && path !== null) {
           pathType = typeof path;
 
 
@@ -20147,10 +20186,31 @@ enifed('ember-glimmer/syntax/mount', ['exports', 'ember-debug', 'ember-glimmer/s
     {{mount "ember-chat"}}
     ```
   
-    Currently, the engine name is the only argument that can be passed to
-    `{{mount}}`.
+    Additionally, you can also pass in a `model` argument that will be
+    set as the engines model. This can be an existing object:
+    
+    ```
+    <div>
+      {{mount 'admin' model=userSettings}}
+    </div>
+    ```
+  
+    Or an inline `hash`, and you can even pass components:
+  
+    ```
+    <div>
+      <h1>Application template!</h1>
+      {{mount 'admin' model=(hash
+          title='Secret Admin'
+          signInButton=(component 'sign-in-button')
+      )}}
+    </div>
+    ```
   
     @method mount
+    @param {String} name Name of the engine to mount.
+    @param {Object} [model] Object that will be set as
+                            the model of the engine.
     @for Ember.Templates.helpers
     @category ember-application-engines
     @public
@@ -20258,9 +20318,10 @@ enifed('ember-glimmer/syntax/outlet', ['exports', '@glimmer/reference', 'ember-g
     Your routes can then render into a specific one of these `outlet`s by specifying the `outlet`
     attribute in your `renderTemplate` function:
   
-    ```javascript
-    // app/routes/menu.js
-    export default Ember.Route.extend({
+    ```app/routes/menu.js
+    import Route from '@ember/routing/route';
+  
+    export default Route.extend({
       renderTemplate() {
         this.render({ outlet: 'menu' });
       }
@@ -20372,8 +20433,10 @@ enifed('ember-glimmer/syntax/render', ['exports', '@glimmer/reference', 'ember-d
   
     Example:
   
-    ```javascript
-    App.NavigationController = Ember.Controller.extend({
+    ```app/controllers/navigation.js
+    import Controller from '@ember/controller';
+  
+    export default Controller.extend({
       who: "world"
     });
     ```
@@ -22906,7 +22969,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
 
   function defineProperty(obj, keyName, desc, data, meta$$1) {
-    if (meta$$1 === null || meta$$1 === undefined) {
+    if (meta$$1 === undefined) {
       meta$$1 = meta(obj);
     }
 
@@ -23008,7 +23071,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
         isDescriptor;
 
     // do nothing of this object has already been destroyed
-    if (!meta$$1 || meta$$1.isSourceDestroyed()) {
+    if (meta$$1 === undefined || meta$$1.isSourceDestroyed()) {
       return;
     }
 
@@ -23194,9 +23257,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       return;
     }
 
-    var meta$$1 = _meta || exports.peekMeta(obj);
+    var meta$$1 = _meta === undefined ? exports.peekMeta(obj) : _meta;
 
-    if (!meta$$1 || !meta$$1.readableChainWatchers()) {
+    if (meta$$1 === undefined || meta$$1.readableChainWatchers() === undefined) {
       return;
     }
 
@@ -24553,7 +24616,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   */
   function ComputedProperty(config, opts) {
     this.isDescriptor = true;
-    if (typeof config === 'function') {
+    var hasGetterOnly = typeof config === 'function';
+    if (hasGetterOnly) {
       this._getter = config;
     } else {
       false && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('Ember.computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
@@ -24571,8 +24635,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     this._suspended = undefined;
     this._meta = undefined;
     this._volatile = false;
+
     this._dependentKeys = opts && opts.dependentKeys;
-    this._readOnly = false;
+    this._readOnly = opts && hasGetterOnly && opts.readOnly === true;
   }
 
   ComputedProperty.prototype = new Descriptor();
@@ -24691,10 +24756,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     You can pass a hash of these values to a computed property like this:
   
     ```
-    person: Ember.computed(function() {
+    import { computed } from '@ember/object';
+    import Person from 'my-app/utils/person';
+  
+    person: computed(function() {
       let personId = this.get('personId');
-      return App.Person.create({ id: personId });
-    }).meta({ type: App.Person })
+      return Person.create({ id: personId });
+    }).meta({ type: Person })
     ```
   
     The hash that you pass to the `meta()` function will be saved on the
@@ -24726,12 +24794,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     // don't create objects just to invalidate
     var meta$$1 = exports.peekMeta(obj);
-    if (!meta$$1 || meta$$1.source !== obj) {
+    if (meta$$1 === undefined || meta$$1.source !== obj) {
       return;
     }
 
     var cache = meta$$1.readableCache();
-    if (cache && cache[keyName] !== undefined) {
+    if (cache !== undefined && cache[keyName] !== undefined) {
       cache[keyName] = undefined;
       removeDependentKeys(this, obj, keyName, meta$$1);
     }
@@ -24753,14 +24821,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
 
     var ret = this._getter.call(obj, keyName);
-    if (ret === undefined) {
-      cache[keyName] = UNDEFINED;
-    } else {
-      cache[keyName] = ret;
-    }
+    cache[keyName] = ret === undefined ? UNDEFINED : ret;
 
     var chainWatchers = meta$$1.readableChainWatchers();
-    if (chainWatchers) {
+    if (chainWatchers !== undefined) {
       chainWatchers.revalidate(keyName);
     }
     addDependentKeys(this, obj, keyName, meta$$1);
@@ -24810,15 +24874,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   ComputedPropertyPrototype._set = function (obj, keyName, value) {
-    // cache requires own meta
     var meta$$1 = meta(obj);
-    // either there is a writable cache or we need one to update
     var cache = meta$$1.writableCache();
     var hadCachedValue = false;
     var cachedValue = void 0;
-    if (cache[keyName] !== undefined) {
-      if (cache[keyName] !== UNDEFINED) {
-        cachedValue = cache[keyName];
+    var val = cache[keyName];
+    if (val !== undefined) {
+      if (val !== UNDEFINED) {
+        cachedValue = val;
       }
       hadCachedValue = true;
     }
@@ -25319,22 +25382,20 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   var onerror = void 0;
+  var onErrorTarget = {
+    get onerror() {
+      return dispatchOverride || onerror;
+    }
+  };
+
   // Ember.onerror getter
 
   // Ember.onerror setter
-  function setOnerror(handler) {
-    onerror = handler;
-  }
+
 
   var dispatchOverride = void 0;
   // dispatch error
-  function dispatchError(error) {
-    if (dispatchOverride) {
-      dispatchOverride(error);
-    } else {
-      defaultDispatch(error);
-    }
-  }
+
 
   // allows testing adapter to override dispatch
 
@@ -25402,7 +25463,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       var meta$$1 = exports.peekMeta(obj),
           map,
           val;
-      if (meta$$1) {
+      if (meta$$1 !== undefined) {
         map = meta$$1.readableWeak();
 
         if (map !== undefined) {
@@ -25450,7 +25511,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
       var meta$$1 = exports.peekMeta(obj),
           map;
-      if (meta$$1) {
+      if (meta$$1 !== undefined) {
         map = meta$$1.readableWeak();
 
         if (map !== undefined) {
@@ -25637,15 +25698,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   */
 
 
-  var onErrorTarget = {
-    get onerror() {
-      return dispatchError;
-    },
-    set onerror(handler) {
-      return setOnerror(handler);
-    }
-  };
-
   var backburner$1 = new Backburner(['sync', 'actions', 'destroy'], {
     GUID_KEY: emberUtils.GUID_KEY,
     sync: {
@@ -25757,16 +25809,26 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     We can use that setup option to do some additional setup for our component.
     The component itself could look something like the following:
   
-    ```javascript
-    App.RichTextEditorComponent = Ember.Component.extend({
+    ```app/components/rich-text-editor.js
+    import Component from '@ember/component';
+    import { bind } from '@ember/runloop';
+  
+    export default Component.extend({
       initializeTinyMCE: Ember.on('didInsertElement', function() {
         tinymce.init({
           selector: '#' + this.$().prop('id'),
           setup: Ember.run.bind(this, this.setupEditor)
         });
       }),
+      
+      didInsertElement() {
+        tinymce.init({
+          selector: '#' + this.$().prop('id'),
+          setup: Ember.run.bind(this, this.setupEditor)
+        });
+      }
   
-      setupEditor: function(editor) {
+      setupEditor(editor) {
         this.set('editor', editor);
   
         editor.on('change', function() {
@@ -25777,7 +25839,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     In this example, we use Ember.run.bind to bind the setupEditor method to the
-    context of the App.RichTextEditorComponent and to have the invocation of that
+    context of the RichTextEditor component and to have the invocation of that
     method be safely handled and executed by the Ember run loop.
   
     @method bind
@@ -26017,9 +26079,23 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     });
     ```
   
-    Also note that passing an anonymous function to `run.scheduleOnce` will
-    not prevent additional calls with an identical anonymous function from
-    scheduling the items multiple times, e.g.:
+    Also note that for `run.scheduleOnce` to prevent additional calls, you need to
+    pass the same function instance. The following case works as expected:
+  
+    ```javascript
+    function log() {
+      console.log('Logging only once');
+    }
+  
+    function scheduleIt() {
+      run.scheduleOnce('actions', myContext, log);
+    }
+  
+    scheduleIt();
+    scheduleIt();
+    ```
+  
+    But this other case will schedule the function multiple times:
   
     ```javascript
     function scheduleIt() {
@@ -26032,7 +26108,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     scheduleIt();
   
     // "Closure" will print twice, even though we're using `run.scheduleOnce`,
-    // because the function we pass to it is anonymous and won't match the
+    // because the function we pass to it won't match the
     // previously scheduled operation.
     ```
   
@@ -26080,8 +26156,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
     Example:
   
-    ```javascript
-    export default Ember.Component.extend({
+    ```app/components/my-component.js
+    import Component from '@ember/component';
+  
+    export Component.extend({
       didInsertElement() {
         this._super(...arguments);
         run.scheduleOnce('afterRender', this, 'processChildElements');
@@ -27590,16 +27668,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     if (baseValue === null || baseValue === undefined) {
       ret = emberUtils.makeArray(value);
-    } else {
-      if (isArray(baseValue)) {
-        if (value === null || value === undefined) {
-          ret = baseValue;
-        } else {
-          ret = a_concat.call(baseValue, value);
-        }
+    } else if (isArray(baseValue)) {
+      if (value === null || value === undefined) {
+        ret = baseValue;
       } else {
-        ret = a_concat.call(emberUtils.makeArray(baseValue), value);
+        ret = a_concat.call(baseValue, value);
       }
+    } else {
+      ret = a_concat.call(emberUtils.makeArray(baseValue), value);
     }
 
     return ret;
@@ -27656,7 +27732,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     } else {
       if (concats && concats.indexOf(key) >= 0 || key === 'concatenatedProperties' || key === 'mergedProperties') {
         value = applyConcatenatedProperties(base, key, value, values);
-      } else if (mergings && mergings.indexOf(key) >= 0) {
+      } else if (mergings && mergings.indexOf(key) > -1) {
         value = applyMergedProperties(base, key, value, values);
       } else if (isMethod(value)) {
         value = giveMethodSuper(base, key, value, values, descs);
@@ -27772,9 +27848,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return { desc: desc, value: value };
   }
 
-  function updateObserversAndListeners(obj, key, observerOrListener, pathsKey, updateMethod) {
-    var paths = observerOrListener[pathsKey],
-        i;
+  function updateObserversAndListeners(obj, key, paths, updateMethod) {
+    var i;
 
     if (paths) {
       for (i = 0; i < paths.length; i++) {
@@ -27786,16 +27861,16 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   function replaceObserversAndListeners(obj, key, observerOrListener) {
     var prev = obj[key];
 
-    if ('function' === typeof prev) {
-      updateObserversAndListeners(obj, key, prev, '__ember_observesBefore__', _removeBeforeObserver);
-      updateObserversAndListeners(obj, key, prev, '__ember_observes__', removeObserver);
-      updateObserversAndListeners(obj, key, prev, '__ember_listens__', removeListener);
+    if (typeof prev === 'function') {
+      updateObserversAndListeners(obj, key, prev.__ember_observesBefore__, _removeBeforeObserver);
+      updateObserversAndListeners(obj, key, prev.__ember_observes__, removeObserver);
+      updateObserversAndListeners(obj, key, prev.__ember_listens__, removeListener);
     }
 
-    if ('function' === typeof observerOrListener) {
-      updateObserversAndListeners(obj, key, observerOrListener, '__ember_observesBefore__', _addBeforeObserver);
-      updateObserversAndListeners(obj, key, observerOrListener, '__ember_observes__', addObserver);
-      updateObserversAndListeners(obj, key, observerOrListener, '__ember_listens__', addListener);
+    if (typeof observerOrListener === 'function') {
+      updateObserversAndListeners(obj, key, observerOrListener.__ember_observesBefore__, _addBeforeObserver);
+      updateObserversAndListeners(obj, key, observerOrListener.__ember_observes__, addObserver);
+      updateObserversAndListeners(obj, key, observerOrListener.__ember_listens__, addListener);
     }
   }
 
@@ -28007,7 +28082,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Mixin.mixins = function (obj) {
       var meta$$1 = exports.peekMeta(obj);
       var ret = [];
-      if (!meta$$1) {
+      if (meta$$1 === undefined) {
         return ret;
       }
 
@@ -28116,7 +28191,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       return _detect(obj, this, {});
     }
     var meta$$1 = exports.peekMeta(obj);
-    if (!meta$$1) {
+    if (meta$$1 === undefined) {
       return false;
     }
     return !!meta$$1.peekMixins(emberUtils.guidFor(this));
@@ -28194,15 +28269,21 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     Makes a method available via an additional name.
   
-    ```javascript
-    App.Person = Ember.Object.extend({
-      name: function() {
+    ```app/utils/person.js
+    import EmberObject, {
+      aliasMethod
+    } from '@ember/object';
+  
+    export default EmberObject.extend({
+      name() {
         return 'Tomhuda Katzdale';
       },
-      moniker: Ember.aliasMethod('name')
+      moniker: aliasMethod('name')
     });
+    ```
   
-    let goodGuy = App.Person.create();
+    ```javascript
+    let goodGuy = Person.create();
   
     goodGuy.name();    // 'Tomhuda Katzdale'
     goodGuy.moniker(); // 'Tomhuda Katzdale'
@@ -28533,8 +28614,16 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   exports.getOnerror = function () {
     return onerror;
   };
-  exports.setOnerror = setOnerror;
-  exports.dispatchError = dispatchError;
+  exports.setOnerror = function (handler) {
+    onerror = handler;
+  };
+  exports.dispatchError = function (error) {
+    if (dispatchOverride) {
+      dispatchOverride(error);
+    } else {
+      defaultDispatch(error);
+    }
+  };
   exports.setDispatchOverride = function (handler) {
     dispatchOverride = handler;
   };
@@ -28561,7 +28650,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   exports.addListener = addListener;
   exports.hasListeners = function (obj, eventName) {
     var meta$$1 = exports.peekMeta(obj);
-    if (!meta$$1) {
+    if (meta$$1 === undefined) {
       return false;
     }
     var matched = meta$$1.matchingListeners(eventName);
@@ -28577,8 +28666,16 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
         _len,
         args,
         _key;
+    var events = args;
+
+    false && !(typeof func === 'function') && emberDebug.assert('Ember.on expects function as last argument', typeof func === 'function');
+    false && !(events.length > 0 && events.every(function (p) {
+      return typeof p === 'string' && p.length;
+    })) && emberDebug.assert('Ember.on called without valid event names', events.length > 0 && events.every(function (p) {
+      return typeof p === 'string' && p.length;
+    }));
 
-    func.__ember_listens__ = args;
+    func.__ember_listens__ = events;
     return func;
   };
   exports.removeListener = removeListener;
@@ -28830,7 +28927,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     if (typeof value === 'object' && value !== null) {
       meta$$1 = exports.peekMeta(value);
 
-      return meta$$1 && meta$$1.isProxy();
+      return meta$$1 === undefined ? false : meta$$1.isProxy();
     }
 
     return false;
@@ -29503,14 +29600,14 @@ enifed('ember-routing/location/history_location', ['exports', 'ember-metal', 'em
   
     Example:
   
-    ```javascript
-    App.Router.map(function() {
+    ```app/router.js
+    Router.map(function() {
       this.route('posts', function() {
         this.route('new');
       });
     });
   
-    App.Router.reopen({
+    Router.reopen({
       location: 'history'
     });
     ```
@@ -29981,9 +30078,91 @@ enifed('ember-routing/services/router', ['exports', 'ember-runtime', 'ember-rout
   */
 
   var RouterService = _emberRuntime.Service.extend({
+
+    /**
+       Name of the current route.
+        This property represent the logical name of the route,
+       which is comma separated.
+       For the following router:
+        ```app/router.js
+       Router.map(function() {
+         this.route('about);
+         this.route('blog', function () {
+           this.route('post', { path: ':post_id' });
+         });
+       });
+       ```
+        It will return:
+        * `index` when you visit `/`
+       * `about` when you visit `/about`
+       * `blog.index` when you visit `/blog`
+       * `blog.post` when you visit `/blog/some-post-id`
+        @property currentRouteName
+       @type String
+       @public
+     */
     currentRouteName: (0, _emberRuntime.readOnly)('_router.currentRouteName'),
+
+    /**
+       Current URL for the application.
+       This property represent the URL path for this route.
+      For the following router:
+        ```app/router.js
+       Router.map(function() {
+         this.route('about);
+         this.route('blog', function () {
+           this.route('post', { path: ':post_id' });
+         });
+       });
+       ```
+        It will return:
+        * `/` when you visit `/`
+       * `/about` when you visit `/about`
+       * `/blog/index` when you visit `/blog`
+       * `/blog/post` when you visit `/blog/some-post-id`
+        @property currentURL
+       @type String
+       @public
+     */
     currentURL: (0, _emberRuntime.readOnly)('_router.currentURL'),
+
+    /**
+      The `location` property determines the type of URL's that your
+      application will use.
+      The following location types are currently available:
+      * `auto`
+      * `hash`
+      * `history`
+      * `none`
+       @property location
+      @default 'hash'
+      @see {Ember.Location}
+      @public
+    */
     location: (0, _emberRuntime.readOnly)('_router.location'),
+
+    /**
+      The `rootURL` property represents the URL of the root of
+      the application, '/' by default.
+      This prefix is assumed on all routes defined on this app.
+       IF you change the `rootURL` in your environment configuration
+      like so:
+       ```config/environment.js
+      'use strict';
+       module.exports = function(environment) {
+        let ENV = {
+          modulePrefix: 'router-service',
+          environment,
+          rootURL: '/my-root',
+        …
+        }
+      ]
+      ```
+       This property will return `/my-root`.
+       @property rootURL
+      @default '/'
+      @public
+    */
     rootURL: (0, _emberRuntime.readOnly)('_router.rootURL'),
     _router: null,
 
@@ -30838,10 +31017,10 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       A hook you can use to reset controller values either when the model
       changes or the route is exiting.
        ```app/routes/articles.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         resetController(controller, isExiting, transition) {
-          if (isExiting) {
+          if (isExiting && transition.targetName !== 'error') {
             controller.set('page', 1);
           }
         }
@@ -30877,8 +31056,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       The name of the template to use by default when rendering this routes
       template.
        ```app/routes/posts/list.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         templateName: 'posts/list'
       });
       ```
@@ -30924,8 +31103,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
        A good example is preventing navigation when a form is
       half-filled out:
        ```app/routes/contact-form.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         actions: {
           willTransition(transition) {
             if (this.controller.get('userHasEnteredData')) {
@@ -30962,8 +31141,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       however, it can be useful for tracking page views or resetting
       state on the controller.
        ```app/routes/login.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         actions: {
           didTransition() {
             this.controller.get('errors.base').clear();
@@ -30983,7 +31162,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       `Transition` object is the first parameter and the route that
       triggered the loading event is the second parameter.
        ```app/routes/application.js
-      export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         actions: {
           loading(transition, route) {
             let controller = this.controllerFor('foo');
@@ -31012,8 +31192,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       for rejected promises from the various hooks on the route,
       as well as any unhandled errors from child routes:
        ```app/routes/admin.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         beforeModel() {
           return Ember.RSVP.reject('bad things!');
         },
@@ -31037,8 +31217,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       specify your own global default error handler by overriding the
       `error` handler on `ApplicationRoute`:
        ```app/routes/application.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         actions: {
           error(error, transition) {
             this.controllerFor('banner').displayError(error.message);
@@ -31057,8 +31237,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       This event is triggered when the router enters the route. It is
       not executed when the model for the route changes.
        ```app/routes/application.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         collectAnalytics: Ember.on('activate', function(){
           collectAnalytics();
         })
@@ -31073,8 +31253,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       This event is triggered when the router completely exits this
       route. It is not executed when the model for the route changes.
        ```app/routes/index.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         trackPageLeaveAnalytics: Ember.on('deactivate', function(){
           trackPageLeaveAnalytics();
         })
@@ -31089,8 +31269,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       The controller associated with this route.
        Example
        ```app/routes/form.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         actions: {
           willTransition(transition) {
             if (this.controller.get('userHasEnteredData') &&
@@ -31406,8 +31586,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       logic that can only take place after the model has already
       resolved.
        ```app/routes/posts.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         afterModel(posts, transition) {
           if (posts.get('length') === 1) {
             this.transitionTo('post.show', posts.get('firstObject'));
@@ -31546,8 +31726,8 @@ enifed('ember-routing/system/route', ['exports', 'ember-utils', 'ember-metal', '
       });
        ```
        ```app/routes/post.js
-      import Ember from 'ember';
-       export default Ember.Route.extend({
+      import Route from '@ember/routing/route';
+       export default Route.extend({
         model(params) {
           // the server returns `{ id: 12 }`
           return Ember.$.getJSON('/posts/' + params.post_id);
@@ -31970,7 +32150,7 @@ enifed('ember-routing/system/router', ['exports', 'ember-utils', 'ember-console'
       * `hash` - use `#` to separate the server part of the URL from the Ember part: `/blog/#/posts/new`
       * `none` - do not store the Ember URL in the actual browser URL (mainly used for testing)
       * `auto` - use the best option based on browser capabilities: `history` if possible, then `hash` if possible, otherwise `none`
-       Note: If using ember-cli, this value is defaulted to `auto` by the `locationType` setting of `/config/environment.js`
+       This value is defaulted to `auto` by the `locationType` setting of `/config/environment.js`
        @property location
       @default 'hash'
       @see {Ember.Location}
@@ -32819,6 +32999,9 @@ enifed('ember-routing/system/router', ['exports', 'ember-utils', 'ember-console'
           errorRouteName = findRouteStateName(route, 'error');
 
           if (errorRouteName) {
+            _errorId = (0, _emberUtils.guidFor)(error);
+
+            router._markErrorAsHandled(_errorId);
             router.intermediateTransitionTo(errorRouteName, error);
             return false;
           }
@@ -32826,8 +33009,13 @@ enifed('ember-routing/system/router', ['exports', 'ember-utils', 'ember-console'
 
         // Check for an 'error' substate route
         var errorSubstateName = findRouteSubstateName(route, 'error'),
-            errorRouteName;
+            errorRouteName,
+            _errorId,
+            errorId;
         if (errorSubstateName) {
+          errorId = (0, _emberUtils.guidFor)(error);
+
+          router._markErrorAsHandled(errorId);
           router.intermediateTransitionTo(errorSubstateName, error);
           return false;
         }
@@ -34735,7 +34923,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function (dependentKey, propertyKey) {
-    return (0, _emberMetal.computed)(dependentKey + '.[]', function () {
+    var cp = new _emberMetal.ComputedProperty(function () {
       var uniq = (0, _native_array.A)();
       var seen = Object.create(null);
       var list = (0, _emberMetal.get)(this, dependentKey);
@@ -34749,7 +34937,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
         });
       }
       return uniq;
-    }).readOnly();
+    }, { dependentKeys: [dependentKey + '.[]'], readOnly: true });
+
+    return cp;
   }
 
   /**
@@ -34892,7 +35082,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
   exports.setDiff = function (setAProperty, setBProperty) {
     false && !(arguments.length === 2) && (0, _emberDebug.assert)('Ember.computed.setDiff requires exactly two dependent arrays.', arguments.length === 2);
 
-    return (0, _emberMetal.computed)(setAProperty + '.[]', setBProperty + '.[]', function () {
+    var cp = new _emberMetal.ComputedProperty(function () {
       var setA = this.get(setAProperty);
       var setB = this.get(setBProperty);
 
@@ -34906,7 +35096,12 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
       return setA.filter(function (x) {
         return setB.indexOf(x) === -1;
       });
-    }).readOnly();
+    }, {
+      dependentKeys: [setAProperty + '.[]', setBProperty + '.[]'],
+      readOnly: true
+    });
+
+    return cp;
   }
 
   /**
@@ -35046,9 +35241,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
         return initialValue;
       }
       return arr.reduce(callback, initialValue, this);
-    }, { dependentKeys: [dependentKey + '.[]'] });
+    }, { dependentKeys: [dependentKey + '.[]'], readOnly: true });
 
-    return cp.readOnly();
+    return cp;
   }
 
   function arrayMacro(dependentKey, callback) {
@@ -35068,9 +35263,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
       } else {
         return (0, _native_array.A)();
       }
-    }, { dependentKeys: [dependentKey] });
+    }, { dependentKeys: [dependentKey], readOnly: true });
 
-    return cp.readOnly();
+    return cp;
   }
 
   function multiArrayMacro(_dependentKeys, callback) {
@@ -35080,9 +35275,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
 
     var cp = new _emberMetal.ComputedProperty(function () {
       return (0, _native_array.A)(callback.call(this, _dependentKeys));
-    }, { dependentKeys: dependentKeys });
+    }, { dependentKeys: dependentKeys, readOnly: true });
 
-    return cp.readOnly();
+    return cp;
   }function map(dependentKey, callback) {
     return arrayMacro(dependentKey, function (value) {
       return value.map(callback, this);
@@ -35175,11 +35370,11 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
       activeObserversMap.set(this, activeObservers);
 
       return sortByNormalizedSortProperties(items, normalizedSortProperties);
-    }, { dependentKeys: [sortPropertiesKey + '.[]'] });
+    }, { dependentKeys: [sortPropertiesKey + '.[]'], readOnly: true });
 
     cp._activeObserverMap = undefined;
 
-    return cp.readOnly();
+    return cp;
   }
 
   function normalizeSortProperties(sortProperties) {
@@ -35206,7 +35401,6 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
           return direction === 'desc' ? -1 * result : result;
         }
       }
-
       return 0;
     }));
   }
@@ -35237,9 +35431,13 @@ enifed('ember-runtime/controllers/controller', ['exports', 'ember-debug', 'ember
   
     Example:
   
-    ```javascript
-    App.PostController = Ember.Controller.extend({
-      posts: Ember.inject.controller()
+    ```app/controllers/post.js
+    import Controller, {
+      inject as controller
+    } from '@ember/controller';
+  
+    export default Controller.extend({
+      posts: controller()
     });
     ```
   
@@ -35247,10 +35445,13 @@ enifed('ember-runtime/controllers/controller', ['exports', 'ember-debug', 'ember
     looks up the `posts` controller in the container, making it easy to
     reference other controllers. This is functionally equivalent to:
   
-    ```javascript
-    App.PostController = Ember.Controller.extend({
+    ```app/controllers/post.js
+    import Controller from '@ember/controller';
+    import { alias } from '@ember/object/computed';
+  
+    export default Controller.extend({
       needs: 'posts',
-      posts: Ember.computed.alias('controllers.posts')
+      posts: alias('controllers.posts')
     });
     ```
   
@@ -35378,15 +35579,18 @@ enifed('ember-runtime/ext/function', ['ember-environment', 'ember-metal', 'ember
       when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
       `true`, which is the default.
        Computed properties allow you to treat a function like a property:
-       ```javascript
-      MyApp.President = Ember.Object.extend({
+       ```app/utils/president.js
+      import EmberObject from '@ember/object';
+       export default EmberObject.extend({
         firstName: '',
         lastName:  '',
          fullName: function() {
           return this.get('firstName') + ' ' + this.get('lastName');
         }.property() // Call this flag to mark the function as a property
       });
-       let president = MyApp.President.create({
+      ```
+       ```javascript
+      let president = President.create({
         firstName: 'Barack',
         lastName: 'Obama'
       });
@@ -35398,8 +35602,9 @@ enifed('ember-runtime/ext/function', ['ember-environment', 'ember-metal', 'ember
       example, in the above example, the `fullName` property depends on
       `firstName` and `lastName` to determine its value. You can tell Ember
       about these dependencies like this:
-       ```javascript
-      MyApp.President = Ember.Object.extend({
+       ```app/utils/president.js
+      import EmberObject from '@ember/object';
+       export default EmberObject.extend({
         firstName: '',
         lastName:  '',
          fullName: function() {
@@ -35431,7 +35636,8 @@ enifed('ember-runtime/ext/function', ['ember-environment', 'ember-metal', 'ember
       call to the end of your method declarations in classes that you write.
       For example:
        ```javascript
-      Ember.Object.extend({
+      import EmberObject from '@ember/object';
+       EmberObject.extend({
         valueObserver: function() {
           // Executes whenever the "value" property changes
         }.observes('value')
@@ -35478,7 +35684,8 @@ enifed('ember-runtime/ext/function', ['ember-environment', 'ember-metal', 'ember
       call to the end of your method declarations in classes that you write.
       For example:
        ```javascript
-      Ember.Object.extend({
+      import EmberObject from '@ember/object';
+       EmberObject.extend({
         valueObserver: function() {
           // Executes immediately after the "value" property changes
         }.observesImmediately('value')
@@ -35501,7 +35708,8 @@ enifed('ember-runtime/ext/function', ['ember-environment', 'ember-metal', 'ember
        You can listen for events simply by adding the `on` call to the end of
       your method declarations in classes or mixins that you write. For example:
        ```javascript
-      Ember.Mixin.create({
+      import Mixin from '@ember/mixin';
+       Mixin.create({
         doSomethingWithElement: function() {
           // Executes whenever the "didInsertElement" event fires
         }.on('didInsertElement')
@@ -36507,7 +36715,7 @@ enifed('ember-runtime/mixins/array', ['exports', 'ember-utils', 'ember-metal', '
   exports.arrayContentWillChange = arrayContentWillChange;
   exports.arrayContentDidChange = arrayContentDidChange;
   exports.isEmberArray = function (obj) {
-    return obj && !!obj[EMBER_ARRAY];
+    return obj && obj[EMBER_ARRAY];
   }
 
   // ..........................................................
@@ -36582,11 +36790,7 @@ enifed('ember-runtime/mixins/array', ['exports', 'ember-utils', 'ember-metal', '
   }
 
   function objectAt(content, idx) {
-    if (content.objectAt) {
-      return content.objectAt(idx);
-    }
-
-    return content[idx];
+    return typeof content.objectAt === 'function' ? content.objectAt(idx) : content[idx];
   }
 
   function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
@@ -36674,7 +36878,7 @@ enifed('ember-runtime/mixins/array', ['exports', 'ember-utils', 'ember-metal', '
     (0, _emberMetal.sendEvent)(array, '@array:change', [array, startIdx, removeAmt, addAmt]);
 
     var meta = (0, _emberMetal.peekMeta)(array);
-    var cache = meta && meta.readableCache();
+    var cache = meta !== undefined ? meta.readableCache() : undefined;
     if (cache !== undefined) {
       length = (0, _emberMetal.get)(array, 'length');
       addedAmount = addAmt === -1 ? 0 : addAmt;
@@ -36736,17 +36940,13 @@ enifed('ember-runtime/mixins/array', ['exports', 'ember-utils', 'ember-metal', '
 
     if ((0, _emberMetal.isNone)(beginIndex)) {
       beginIndex = 0;
+    } else if (beginIndex < 0) {
+      beginIndex = length + beginIndex;
     }
 
     if ((0, _emberMetal.isNone)(endIndex) || endIndex > length) {
       endIndex = length;
-    }
-
-    if (beginIndex < 0) {
-      beginIndex = length + beginIndex;
-    }
-
-    if (endIndex < 0) {
+    } else if (endIndex < 0) {
       endIndex = length + endIndex;
     }
 
@@ -37743,22 +37943,22 @@ enifed('ember-runtime/mixins/evented', ['exports', 'ember-metal'], function (exp
   exports.default = _emberMetal.Mixin.create({
 
     /**
-     Subscribes to a named event with given function.
-      ```javascript
-     person.on('didLoad', function() {
-       // fired once the person has loaded
-     });
-     ```
-      An optional target can be passed in as the 2nd argument that will
-     be set as the "this" for the callback. This is a good way to give your
-     function access to the object triggering the event. When the target
-     parameter is used the callback becomes the third argument.
-      @method on
-     @param {String} name The name of the event
-     @param {Object} [target] The "this" binding for the callback
-     @param {Function} method The callback to execute
-     @return this
-     @public
+      Subscribes to a named event with given function.
+       ```javascript
+      person.on('didLoad', function() {
+        // fired once the person has loaded
+      });
+      ```
+       An optional target can be passed in as the 2nd argument that will
+      be set as the "this" for the callback. This is a good way to give your
+      function access to the object triggering the event. When the target
+      parameter is used the callback becomes the third argument.
+       @method on
+      @param {String} name The name of the event
+      @param {Object} [target] The "this" binding for the callback
+      @param {Function} method The callback to execute
+      @return this
+      @public
     */
     on: function (name, target, method) {
       (0, _emberMetal.addListener)(this, name, target, method);
@@ -38589,8 +38789,9 @@ enifed('ember-runtime/mixins/observable', ['exports', 'ember-metal', 'ember-debu
       observer should be prepared to handle that.
        ### Observer Methods
        Observer methods have the following signature:
-       ```javascript
-      export default Ember.Component.extend({
+       ```app/components/my-component.js
+      import Component from '@ember/component';
+       export default Component.extend({
         init() {
           this._super(...arguments);
           this.addObserver('foo', this, 'fooDidChange');
@@ -38779,7 +38980,7 @@ enifed('ember-runtime/mixins/promise_proxy', ['exports', 'ember-metal', 'ember-d
     let ObjectPromiseProxy = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);
   
     let proxy = ObjectPromiseProxy.create({
-      promise: Ember.RSVP.cast($.getJSON('/some/remote/data.json'))
+      promise: Ember.RSVP.resolve($.getJSON('/some/remote/data.json'))
     });
   
     proxy.then(function(json){
@@ -38802,7 +39003,7 @@ enifed('ember-runtime/mixins/promise_proxy', ['exports', 'ember-metal', 'ember-d
     When the $.getJSON completes, and the promise is fulfilled
     with json, the life cycle attributes will update accordingly.
     Note that $.getJSON doesn't return an ECMA specified promise,
-    it is useful to wrap this with an `RSVP.cast` so that it behaves
+    it is useful to wrap this with an `RSVP.resolve` so that it behaves
     as a spec compliant promise.
   
     ```javascript
@@ -40483,8 +40684,10 @@ enifed('ember-runtime/system/native_array', ['exports', 'ember-metal', 'ember-en
   
     Example
   
-    ```js
-    export default Ember.Component.extend({
+    ```app/components/my-component.js
+    import Component from '@ember/component';
+  
+    export default Component.extend({
       tagName: 'ul',
       classNames: ['pagination'],
   
@@ -40600,9 +40803,12 @@ enifed('ember-runtime/system/service', ['exports', 'ember-runtime/system/object'
   
     Example:
   
-    ```javascript
-    App.ApplicationRoute = Ember.Route.extend({
-      authManager: Ember.inject.service('auth'),
+    ```app/routes/application.js
+    import Route from '@ember/routing/route';
+    import { inject as service } from '@ember/service';
+  
+    export default Route.extend({
+      authManager: service('auth'),
   
       model() {
         return this.get('authManager').findCurrentUser();
@@ -41288,17 +41494,20 @@ enifed('ember-utils', ['exports'], function (exports) {
     `audioType` passed as an attribute:
   
     ```app/components/play-audio.js
-    import Ember from 'ember';
-  
+    import Component from '@ember/component';
+    import { computed } from '@ember/object';
+    import { getOwner } from '@ember/application';
+    
     // Usage:
     //
     //   {{play-audio audioType=model.audioType audioFile=model.file}}
     //
-    export default Ember.Component.extend({
-      audioService: Ember.computed('audioType', function() {
-        let owner = Ember.getOwner(this);
+    export default Component.extend({
+      audioService: computed('audioType', function() {
+        let owner = getOwner(this);
         return owner.lookup(`service:${this.get('audioType')}`);
       }),
+  
       click() {
         let player = this.get('audioService');
         player.play(this.get('audioFile'));
@@ -41804,7 +42013,7 @@ enifed('ember-utils', ['exports'], function (exports) {
   exports.canInvoke = canInvoke;
   exports.tryInvoke = function (obj, methodName, args) {
     if (canInvoke(obj, methodName)) {
-      return args ? applyStr(obj, methodName, args) : applyStr(obj, methodName);
+      return applyStr(obj, methodName, args);
     }
   };
   exports.makeArray = function (obj) {
@@ -42036,9 +42245,9 @@ enifed('ember-views/mixins/action_support', ['exports', 'ember-utils', 'ember-me
        For example a component for playing or pausing music may translate click events
       into action notifications of "play" or "stop" depending on some internal state
       of the component:
-       ```javascript
-      // app/components/play-button.js
-      export default Ember.Component.extend({
+       ```app/components/play-button.js
+      import Component from '@ember/component';
+       export default Component.extend({
         click() {
           if (this.get('isPlaying')) {
             this.sendAction('play');
@@ -42056,9 +42265,9 @@ enifed('ember-views/mixins/action_support', ['exports', 'ember-utils', 'ember-me
        When the component receives a browser `click` event it translate this
       interaction into application-specific semantics ("play" or "stop") and
       calls the specified action.
-       ```javascript
-      // app/controller/application.js
-      export default Ember.Controller.extend({
+       ```app/controller/application.js
+      import Controller from '@ember/controller';
+       export default Controller.extend({
         actions: {
           musicStarted() {
             // called when the play button is clicked
@@ -42073,9 +42282,9 @@ enifed('ember-views/mixins/action_support', ['exports', 'ember-utils', 'ember-me
       ```
        If no action is passed to `sendAction` a default name of "action"
       is assumed.
-       ```javascript
-      // app/components/next-button.js
-      export default Ember.Component.extend({
+       ```app/components/next-button.js
+      import Component from '@ember/component';
+       export default Component.extend({
         click() {
           this.sendAction();
         }
@@ -42085,9 +42294,9 @@ enifed('ember-views/mixins/action_support', ['exports', 'ember-utils', 'ember-me
       {{! app/templates/application.hbs }}
       {{next-button action=(action "playNextSongInAlbum")}}
       ```
-       ```javascript
-      // app/controllers/application.js
-      App.ApplicationController = Ember.Controller.extend({
+       ```app/controllers/application.js
+      import Controller from '@ember/controller';
+       export default Controller.extend({
         actions: {
           playNextSongInAlbum() {
             ...
@@ -42623,8 +42832,9 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-utils', 'ember-meta
       is a string value, the value of that string will be applied as the value
       for an attribute of the property's name.
        The following example creates a tag like `<div priority="high" />`.
-       ```javascript
-      Ember.Component.extend({
+       ```app/components/my-component.js
+      import Component from '@ember/component';
+       export default Component.extend({
         attributeBindings: ['priority'],
         priority: 'high'
       });
@@ -42633,8 +42843,9 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-utils', 'ember-meta
       an HTML Boolean attribute. It will be present if the property is `true`
       and omitted if the property is `false`.
        The following example creates markup like `<div visible />`.
-       ```javascript
-      Ember.Component.extend({
+       ```app/components/my-component.js
+      import Component from '@ember/component';
+       export default Component.extend({
         attributeBindings: ['visible'],
         visible: true
       });
@@ -42642,8 +42853,9 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-utils', 'ember-meta
        If you would prefer to use a custom value instead of the property name,
       you can create the same markup as the last example with a binding like
       this:
-       ```javascript
-      Ember.Component.extend({
+       ```app/components/my-component.js
+      import Component from '@ember/component';
+       export default Component.extend({
         attributeBindings: ['isVisible:visible'],
         isVisible: true
       });
@@ -43962,15 +44174,15 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   computed.collect = _emberRuntime.collect;
 
   /**
-   Defines the hash of localized strings for the current language. Used by
-   the `Ember.String.loc()` helper. To localize, add string values to this
-   hash.
+    Defines the hash of localized strings for the current language. Used by
+    the `Ember.String.loc()` helper. To localize, add string values to this
+    hash.
   
-   @property STRINGS
-   @for Ember
-   @type Object
-   @private
-   */
+    @property STRINGS
+    @for Ember
+    @type Object
+    @private
+  */
   Object.defineProperty(_emberMetal.default, 'STRINGS', {
     configurable: false,
     get: _emberRuntime.getStrings,
@@ -43978,19 +44190,19 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   });
 
   /**
-   Whether searching on the global for new Namespace instances is enabled.
+    Whether searching on the global for new Namespace instances is enabled.
   
-   This is only exported here as to not break any addons.  Given the new
-   visit API, you will have issues if you treat this as a indicator of
-   booted.
+    This is only exported here as to not break any addons.  Given the new
+    visit API, you will have issues if you treat this as a indicator of
+    booted.
   
-   Internally this is only exposing a flag in Namespace.
+    Internally this is only exposing a flag in Namespace.
   
-   @property BOOTED
-   @for Ember
-   @type Boolean
-   @private
-   */
+    @property BOOTED
+    @for Ember
+    @type Boolean
+    @private
+  */
   Object.defineProperty(_emberMetal.default, 'BOOTED', {
     configurable: false,
     enumerable: false,
@@ -44027,15 +44239,15 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   _emberRuntime.String.isHTMLSafe = _emberGlimmer.isHTMLSafe;
 
   /**
-   Global hash of shared templates. This will automatically be populated
-   by the build tools so that you can store your Handlebars templates in
-   separate files that get loaded into JavaScript at buildtime.
+    Global hash of shared templates. This will automatically be populated
+    by the build tools so that you can store your Handlebars templates in
+    separate files that get loaded into JavaScript at buildtime.
   
-   @property TEMPLATES
-   @for Ember
-   @type Object
-   @private
-   */
+    @property TEMPLATES
+    @for Ember
+    @type Object
+    @private
+  */
   Object.defineProperty(_emberMetal.default, 'TEMPLATES', {
     get: _emberGlimmer.getTemplates,
     set: _emberGlimmer.setTemplates,
@@ -44046,11 +44258,12 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   exports.VERSION = _version.default;
 
   /**
-   The semantic version
-   @property VERSION
-   @type String
-   @public
-   */
+    The semantic version
+  
+    @property VERSION
+    @type String
+    @public
+  */
   _emberMetal.default.VERSION = _version.default;
 
   _emberMetal.libraries.registerCoreLibrary('Ember', _version.default);
@@ -44058,13 +44271,14 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   // require the main entry points for each of these packages
   // this is so that the global exports occur properly
 
+
   /**
-   Alias for jQuery
+    Alias for jQuery
   
-   @method $
-   @for Ember
-   @public
-   */
+    @method $
+    @for Ember
+    @public
+  */
   _emberMetal.default.$ = _emberViews.jQuery;
 
   _emberMetal.default.ViewTargetActionSupport = _emberViews.ViewTargetActionSupport;
@@ -44125,7 +44339,7 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   (0, _emberRuntime.runLoadHooks)('Ember');
 
   /**
-  @module ember
+    @module ember
   */
   exports.default = _emberMetal.default;
 
@@ -44139,7 +44353,7 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.16.0-beta.1";
+  exports.default = "2.16.0-beta.2";
 });
 enifed('node-module', ['exports'], function(_exports) {
   var IS_NODE = typeof module === 'object' && typeof module.require === 'function';