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

data/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.16.0-beta.1
+ * @version   2.16.0-beta.2
  */
 
 var enifed, requireModule, Ember;
@@ -9157,7 +9157,6 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
             this.name = name;
             this.options = options;
             this.globalOptions = globalOptions;
-            this.globalOptions.onError = getOnError(globalOptions);
         }
 
         Queue.prototype.push = function push(target, method, args, stack) {
@@ -9192,8 +9191,6 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
             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) {
@@ -9205,33 +9202,38 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
             if (before) {
                 before();
             }
-            for (var 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) {
+                var onError = getOnError(this.globalOptions);
+                invoke = onError ? this.invokeWithOnError : this.invoke;
+                for (var 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) {
@@ -9432,7 +9434,6 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
 
     // 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();
@@ -9442,7 +9443,6 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
         }
     };
 
-    var now = Date.now;
     var noop = function () {};
 
     var Backburner = function () {
@@ -9483,6 +9483,9 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
                 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();
@@ -9768,7 +9771,7 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
                 }
             }
             var onError = getOnError(this.options);
-            var executeAt = now() + wait;
+            var executeAt = this._platform.now() + wait;
             var fn = void 0;
             if (onError) {
                 fn = function () {
@@ -9977,7 +9980,7 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
             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) {
                 var executeAt = timers[i];
                 if (executeAt <= n) {
@@ -10009,7 +10012,7 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
                 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);
         };
@@ -10031,7 +10034,7 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
 
     exports.default = Backburner;
 });
-enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'ember/features', 'ember-environment'], function (exports, _emberBabel, _emberUtils, _emberDebug, _features) {
+enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'ember/features'], function (exports, _emberBabel, _emberUtils, _emberDebug, _features) {
   'use strict';
 
   exports.Container = exports.privatize = exports.Registry = undefined;
@@ -10413,7 +10416,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
       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`
@@ -12351,7 +12354,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 getEngineParent(engine) {
     return engine[ENGINE_PARENT];
@@ -12499,65 +12502,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!
@@ -12565,13 +12586,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}
@@ -12591,13 +12615,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
@@ -12605,10 +12631,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
@@ -12617,17 +12642,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
@@ -12655,7 +12682,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
     */
@@ -12808,12 +12835,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'];
         }
       })
@@ -13111,10 +13142,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 ? '[✓]' : '[ ]';
@@ -13131,11 +13162,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');
       var suffix = _emberRuntime.String.classify(type);
@@ -13158,16 +13189,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);
@@ -15964,9 +15994,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);
@@ -15998,9 +16028,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'
     });
     ```
@@ -16018,9 +16048,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']
     });
     ```
@@ -16037,9 +16067,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() {
@@ -16059,9 +16089,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
     });
@@ -16078,9 +16108,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
     });
@@ -16096,9 +16126,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
     });
@@ -16114,9 +16144,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
@@ -16135,9 +16165,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
     });
@@ -16159,10 +16189,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
     });
@@ -16198,9 +16228,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'
@@ -16217,9 +16247,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'
@@ -16236,9 +16266,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'
@@ -16255,9 +16285,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
@@ -16273,9 +16303,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() {
@@ -16292,9 +16322,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
@@ -16322,10 +16352,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
       });
     ```
@@ -16355,9 +16385,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
@@ -17262,13 +17292,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}}
@@ -17402,7 +17432,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
@@ -17863,8 +17894,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;
@@ -17921,9 +17954,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}`;
@@ -18132,10 +18166,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();
@@ -18164,8 +18198,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) {
@@ -18184,9 +18220,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);
@@ -18200,9 +18236,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');
@@ -18258,7 +18294,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) {
@@ -18266,7 +18302,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
@@ -18323,10 +18359,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()
     });
     ```
   
@@ -18773,7 +18810,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) {
           var pathType = typeof path;
 
           if (pathType === 'string') {
@@ -20629,10 +20666,31 @@ enifed('ember-glimmer/syntax/mount', ['exports', 'ember-babel', 'ember-debug', '
     {{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
@@ -20805,9 +20863,10 @@ enifed('ember-glimmer/syntax/outlet', ['exports', 'ember-babel', '@glimmer/refer
     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' });
       }
@@ -20891,8 +20950,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"
     });
     ```
@@ -22995,7 +23056,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   */
   function hasListeners(obj, eventName) {
     var meta$$1 = exports.peekMeta(obj);
-    if (!meta$$1) {
+    if (meta$$1 === undefined) {
       return false;
     }
     var matched = meta$$1.matchingListeners(eventName);
@@ -23058,6 +23119,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     var func = args.pop();
     var events = args;
+
+    true && !(typeof func === 'function') && emberDebug.assert('Ember.on expects function as last argument', typeof func === 'function');
+    true && !(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__ = events;
     return func;
   }
@@ -23660,7 +23729,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   function DEFAULT_GETTER_FUNCTION(name) {
     return function GETTER_FUNCTION() {
       var meta$$1 = exports.peekMeta(this);
-      if (meta$$1 !== null && meta$$1 !== undefined) {
+      if (meta$$1 !== undefined) {
         return meta$$1.peekValues(name);
       }
     };
@@ -23670,7 +23739,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     function IGETTER_FUNCTION() {
       var meta$$1 = exports.peekMeta(this);
       var val = void 0;
-      if (meta$$1 !== null && meta$$1 !== undefined) {
+      if (meta$$1 !== undefined) {
         val = meta$$1.readInheritedValue('values', name);
       }
 
@@ -23732,7 +23801,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       become the explicit value of this property.
   */
   function defineProperty(obj, keyName, desc, data, meta$$1) {
-    if (meta$$1 === null || meta$$1 === undefined) {
+    if (meta$$1 === undefined) {
       meta$$1 = meta(obj);
     }
 
@@ -23920,7 +23989,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var meta$$1 = _meta || exports.peekMeta(obj);
 
     // do nothing of this object has already been destroyed
-    if (!meta$$1 || meta$$1.isSourceDestroyed()) {
+    if (meta$$1 === undefined || meta$$1.isSourceDestroyed()) {
       return;
     }
 
@@ -24131,9 +24200,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;
     }
 
@@ -25594,7 +25663,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 {
       true && !(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));
@@ -25612,8 +25682,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();
@@ -25731,10 +25802,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
@@ -25766,12 +25840,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);
     }
@@ -25793,14 +25867,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);
@@ -25850,15 +25920,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   ComputedPropertyPrototype._set = function computedPropertySet(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;
     }
@@ -26472,6 +26541,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   var onerror = void 0;
+  var onErrorTarget = {
+    get onerror() {
+      return dispatchOverride || onerror;
+    }
+  };
+
   // Ember.onerror getter
   function getOnerror() {
     return onerror;
@@ -26563,7 +26638,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       }
 
       var meta$$1 = exports.peekMeta(obj);
-      if (meta$$1) {
+      if (meta$$1 !== undefined) {
         var map = meta$$1.readableWeak();
         if (map !== undefined) {
           var val = map[this._id];
@@ -26608,7 +26683,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       }
 
       var meta$$1 = exports.peekMeta(obj);
-      if (meta$$1) {
+      if (meta$$1 !== undefined) {
         var map = meta$$1.readableWeak();
         if (map !== undefined) {
           return map[this._id] !== undefined;
@@ -26800,15 +26875,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     run.currentRunLoop = next;
   }
 
-  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: {
@@ -26916,16 +26982,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() {
@@ -26936,7 +27012,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
@@ -27170,9 +27246,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() {
@@ -27185,7 +27275,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.
     ```
   
@@ -27233,8 +27323,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');
@@ -28780,16 +28872,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);
     }
 
     {
@@ -28860,7 +28950,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);
@@ -28972,9 +29062,7 @@ 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];
-
+  function updateObserversAndListeners(obj, key, paths, updateMethod) {
     if (paths) {
       for (var i = 0; i < paths.length; i++) {
         updateMethod(obj, paths[i], null, key);
@@ -28985,16 +29073,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);
     }
   }
 
@@ -29201,7 +29289,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Mixin.mixins = function mixins(obj) {
       var meta$$1 = exports.peekMeta(obj);
       var ret = [];
-      if (!meta$$1) {
+      if (meta$$1 === undefined) {
         return ret;
       }
 
@@ -29318,7 +29406,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));
@@ -29393,15 +29481,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'
@@ -29640,7 +29734,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   function isProxy(value) {
     if (typeof value === 'object' && value !== null) {
       var meta$$1 = exports.peekMeta(value);
-      return meta$$1 && meta$$1.isProxy();
+      return meta$$1 === undefined ? false : meta$$1.isProxy();
     }
 
     return false;
@@ -30451,14 +30545,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'
     });
     ```
@@ -30947,9 +31041,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,
 
@@ -31777,10 +31953,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);
           }
         }
@@ -31817,8 +31993,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'
       });
       ```
@@ -31864,8 +32040,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')) {
@@ -31902,8 +32078,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();
@@ -31923,7 +32099,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');
@@ -31952,8 +32129,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!');
         },
@@ -31977,8 +32154,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);
@@ -31997,8 +32174,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();
         })
@@ -32013,8 +32190,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();
         })
@@ -32029,8 +32206,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') &&
@@ -32317,8 +32494,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'));
@@ -32458,8 +32635,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);
@@ -32875,7 +33052,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}
@@ -33697,6 +33874,8 @@ enifed('ember-routing/system/router', ['exports', 'ember-utils', 'ember-console'
         if (originRoute !== route) {
           var errorRouteName = findRouteStateName(route, 'error');
           if (errorRouteName) {
+            var _errorId = (0, _emberUtils.guidFor)(error);
+            router._markErrorAsHandled(_errorId);
             router.intermediateTransitionTo(errorRouteName, error);
             return false;
           }
@@ -33705,6 +33884,8 @@ enifed('ember-routing/system/router', ['exports', 'ember-utils', 'ember-console'
         // Check for an 'error' substate route
         var errorSubstateName = findRouteSubstateName(route, 'error');
         if (errorSubstateName) {
+          var errorId = (0, _emberUtils.guidFor)(error);
+          router._markErrorAsHandled(errorId);
           router.intermediateTransitionTo(errorSubstateName, error);
           return false;
         }
@@ -35237,9 +35418,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) {
@@ -35259,9 +35440,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) {
@@ -35271,9 +35452,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;
   }
 
   /**
@@ -35659,7 +35840,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function uniqBy(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);
@@ -35673,7 +35854,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
         });
       }
       return uniq;
-    }).readOnly();
+    }, { dependentKeys: [dependentKey + '.[]'], readOnly: true });
+
+    return cp;
   }
 
   /**
@@ -35810,7 +35993,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     (true && !(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);
 
@@ -35824,7 +36007,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;
   }
 
   /**
@@ -36007,11 +36195,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) {
@@ -36038,7 +36226,6 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
           return direction === 'desc' ? -1 * result : result;
         }
       }
-
       return 0;
     }));
   }
@@ -36072,9 +36259,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()
     });
     ```
   
@@ -36082,10 +36273,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')
     });
     ```
   
@@ -36213,15 +36407,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'
       });
@@ -36233,8 +36430,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() {
@@ -36266,7 +36464,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')
@@ -36310,7 +36509,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')
@@ -36333,7 +36533,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')
@@ -37365,11 +37566,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) {
@@ -37448,7 +37645,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) {
       var length = (0, _emberMetal.get)(array, 'length');
       var addedAmount = addAmt === -1 ? 0 : addAmt;
@@ -37478,7 +37675,7 @@ enifed('ember-runtime/mixins/array', ['exports', 'ember-utils', 'ember-metal', '
   var EMBER_ARRAY = (0, _emberUtils.symbol)('EMBER_ARRAY');
 
   function isEmberArray(obj) {
-    return obj && !!obj[EMBER_ARRAY];
+    return obj && obj[EMBER_ARRAY];
   }
 
   // ..........................................................
@@ -37558,17 +37755,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;
     }
 
@@ -38550,22 +38743,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);
@@ -39417,8 +39610,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');
@@ -39615,7 +39809,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){
@@ -39638,7 +39832,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
@@ -41315,8 +41509,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'],
   
@@ -41449,9 +41645,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();
@@ -45179,17 +45378,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'));
@@ -45486,7 +45688,7 @@ enifed('ember-utils', ['exports'], function (exports) {
   */
   function tryInvoke(obj, methodName, args) {
     if (canInvoke(obj, methodName)) {
-      return args ? applyStr(obj, methodName, args) : applyStr(obj, methodName);
+      return applyStr(obj, methodName, args);
     }
   }
 
@@ -45839,9 +46041,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');
@@ -45859,9 +46061,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
@@ -45876,9 +46078,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();
         }
@@ -45888,9 +46090,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() {
             ...
@@ -46430,8 +46632,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'
       });
@@ -46440,8 +46643,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
       });
@@ -46449,8 +46653,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
       });
@@ -47838,15 +48043,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,
@@ -47854,19 +48059,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,
@@ -47903,15 +48108,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,
@@ -47923,11 +48128,12 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
 
 
   /**
-   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);
@@ -47935,13 +48141,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;
@@ -48001,7 +48208,7 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
   (0, _emberRuntime.runLoadHooks)('Ember');
 
   /**
-  @module ember
+    @module ember
   */
   exports.default = _emberMetal.default;
 
@@ -48016,7 +48223,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("handlebars", ["exports"], function (exports) {
   "use strict";