ember-source 4.4.0-alpha.6 → 4.4.0

package/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.4.0-alpha.6
+ * @version   4.4.0
  */
 /* eslint-disable no-var */
 
@@ -564,7 +564,6 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
       this.normalizedName = normalizedName;
       this.madeToString = undefined;
       this.injections = undefined;
-      setFactoryFor(this, this);
     }
 
     toString() {
@@ -4704,12 +4703,35 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
   var lazyEventsProcessed = new WeakMap();
 
-  var Component = _views.CoreView.extend(_views.ChildViewsSupport, _views.ViewStateSupport, _views.ClassNamesSupport, _runtime2.TargetActionSupport, _views.ActionSupport, _views.ViewMixin, {
-    isComponent: true,
+  class Component extends _views.CoreView.extend(_views.ChildViewsSupport, _views.ViewStateSupport, _views.ClassNamesSupport, _runtime2.TargetActionSupport, _views.ActionSupport, _views.ViewMixin, {
+    // These need to be overridable via extend/create but should still
+    // have a default. Defining them here is the best way to achieve that.
+    didReceiveAttrs() {},
 
-    init() {
-      this._super(...arguments);
+    didRender() {},
+
+    didUpdate() {},
+
+    didUpdateAttrs() {},
+
+    willRender() {},
+
+    willUpdate() {}
+
+  }) {
+    constructor() {
+      super(...arguments);
+      this.isComponent = true;
+    }
 
+    init(properties) {
+      super.init(properties); // Handle methods from ViewMixin.
+      // The native class inheritance will not work for mixins. To work around this,
+      // we copy the existing rerender method provided by the mixin and swap in the
+      // new rerender method from our class.
+
+      this._superRerender = this.rerender;
+      this.rerender = this._rerender;
       this[IS_DISPATCHING_ATTRS] = false;
       this[DIRTY_TAG] = (0, _validator.createTag)();
       this[BOUNDS] = null;
@@ -4745,7 +4767,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
         for (var key in events) {
           var methodName = events[key];
 
-          if (typeof this[methodName] === 'function') {
+          if (methodName && typeof this[methodName] === 'function') {
             eventNames.push(methodName);
           }
         } // If in a tagless component, assert that no event handlers are defined
@@ -4753,7 +4775,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
         (true && !(!eventNames.length) && (0, _debug.assert)(`You can not define \`${eventNames}\` function(s) to handle DOM event in the \`${this}\` tagless component since it doesn't have any DOM element.`, !eventNames.length));
       }
-    },
+    }
 
     get _dispatcher() {
       if (this.__dispatcher === undefined) {
@@ -4761,8 +4783,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
         (true && !(owner) && (0, _debug.assert)('Component is unexpectedly missing an owner', owner));
 
         if (owner.lookup('-environment:main').isInteractive) {
-          this.__dispatcher = owner.lookup('event_dispatcher:main');
-          (true && !(this.__dispatcher instanceof _views.EventDispatcher) && (0, _debug.assert)('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof _views.EventDispatcher));
+          var dispatcher = owner.lookup('event_dispatcher:main');
+          (true && !(dispatcher instanceof _views.EventDispatcher) && (0, _debug.assert)('Expected dispatcher to be an EventDispatcher', dispatcher instanceof _views.EventDispatcher));
+          this.__dispatcher = dispatcher;
         } else {
           // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
           this.__dispatcher = null;
@@ -4770,20 +4793,24 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       }
 
       return this.__dispatcher;
-    },
+    }
 
-    on(eventName) {
+    on(name, target, method) {
       var _a;
 
-      (_a = this._dispatcher) === null || _a === void 0 ? void 0 : _a.setupHandlerForEmberEvent(eventName);
-      return this._super(...arguments);
-    },
+      (_a = this._dispatcher) === null || _a === void 0 ? void 0 : _a.setupHandlerForEmberEvent(name); // The `on` method here comes from the Evented mixin. Since this mixin
+      // is applied to the parent of this class, however, we are still able
+      // to use `super`.
 
-    rerender() {
+      return super.on(name, target, method);
+    } // Changed to `rerender` on init
+
+
+    _rerender() {
       (0, _validator.dirtyTag)(this[DIRTY_TAG]);
 
-      this._super();
-    },
+      this._superRerender();
+    }
 
     [_metal.PROPERTY_DID_CHANGE](key, value) {
       if (this[IS_DISPATCHING_ATTRS]) {
@@ -4796,39 +4823,40 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       if (reference !== undefined && (0, _reference.isUpdatableRef)(reference)) {
         (0, _reference.updateRef)(reference, arguments.length === 2 ? value : (0, _metal.get)(this, key));
       }
-    },
+    }
 
     getAttr(key) {
       // TODO Intimate API should be deprecated
       return this.get(key);
-    },
-
+    }
     /**
       Normally, Ember's component model is "write-only". The component takes a
       bunch of attributes that it got passed in, and uses them to render its
       template.
-       One nice thing about this model is that if you try to set a value to the
+         One nice thing about this model is that if you try to set a value to the
       same thing as last time, Ember (through HTMLBars) will avoid doing any
       work on the DOM.
-       This is not just a performance optimization. If an attribute has not
+         This is not just a performance optimization. If an attribute has not
       changed, it is important not to clobber the element's "hidden state".
       For example, if you set an input's `value` to the same value as before,
       it will clobber selection state and cursor position. In other words,
       setting an attribute is not **always** idempotent.
-       This method provides a way to read an element's attribute and also
+         This method provides a way to read an element's attribute and also
       update the last value Ember knows about at the same time. This makes
       setting an attribute idempotent.
-       In particular, what this means is that if you get an `<input>` element's
+         In particular, what this means is that if you get an `<input>` element's
       `value` attribute and then re-render the template with the same value,
       it will avoid clobbering the cursor and selection position.
       Since most attribute sets are idempotent in the browser, you typically
       can get away with reading attributes using jQuery, but the most reliable
       way to do so is through this method.
       @method readDOMAttr
-       @param {String} name the name of the attribute
+         @param {String} name the name of the attribute
       @return String
       @public
-     */
+      */
+
+
     readDOMAttr(name) {
       // TODO revisit this
       var _element = (0, _views.getViewElement)(this);
@@ -4848,207 +4876,61 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       }
 
       return element[normalized];
-    },
-
-    /**
-     The WAI-ARIA role of the control represented by this view. For example, a
-     button may have a role of type 'button', or a pane may have a role of
-     type 'alertdialog'. This property is used by assistive software to help
-     visually challenged users navigate rich web applications.
-      The full list of valid WAI-ARIA roles is available at:
-     [https://www.w3.org/TR/wai-aria/#roles_categorization](https://www.w3.org/TR/wai-aria/#roles_categorization)
-      @property ariaRole
-     @type String
-     @default null
-     @public
-     */
-
-    /**
-     Enables components to take a list of parameters as arguments.
-     For example, a component that takes two parameters with the names
-     `name` and `age`:
-      ```app/components/my-component.js
-     import Component from '@ember/component';
-      let MyComponent = Component.extend();
-      MyComponent.reopenClass({
-       positionalParams: ['name', 'age']
-     });
-      export default MyComponent;
-     ```
-      It can then be invoked like this:
-      ```hbs
-     {{my-component "John" 38}}
-     ```
-      The parameters can be referred to just like named parameters:
-      ```hbs
-     Name: {{name}}, Age: {{age}}.
-     ```
-      Using a string instead of an array allows for an arbitrary number of
-     parameters:
-      ```app/components/my-component.js
-     import Component from '@ember/component';
-      let MyComponent = Component.extend();
-      MyComponent.reopenClass({
-       positionalParams: 'names'
-     });
-      export default MyComponent;
-     ```
-      It can then be invoked like this:
-      ```hbs
-     {{my-component "John" "Michael" "Scott"}}
-     ```
-     The parameters can then be referred to by enumerating over the list:
-      ```hbs
-     {{#each names as |name|}}{{name}}{{/each}}
-     ```
-      @static
-     @public
-     @property positionalParams
-     @since 1.13.0
-     */
-
-    /**
-     Called when the attributes passed into the component have been updated.
-     Called both during the initial render of a container and during a rerender.
-     Can be used in place of an observer; code placed here will be executed
-     every time any attribute updates.
-     @method didReceiveAttrs
-     @public
-     @since 1.13.0
-     */
-    didReceiveAttrs() {},
-
-    /**
-     Called when the attributes passed into the component have been updated.
-     Called both during the initial render of a container and during a rerender.
-     Can be used in place of an observer; code placed here will be executed
-     every time any attribute updates.
-     @event didReceiveAttrs
-     @public
-     @since 1.13.0
-     */
-
-    /**
-     Called after a component has been rendered, both on initial render and
-     in subsequent rerenders.
-     @method didRender
-     @public
-     @since 1.13.0
-     */
-    didRender() {},
-
-    /**
-     Called after a component has been rendered, both on initial render and
-     in subsequent rerenders.
-     @event didRender
-     @public
-     @since 1.13.0
-     */
-
-    /**
-     Called before a component has been rendered, both on initial render and
-     in subsequent rerenders.
-     @method willRender
-     @public
-     @since 1.13.0
-     */
-    willRender() {},
-
-    /**
-     Called before a component has been rendered, both on initial render and
-     in subsequent rerenders.
-     @event willRender
-     @public
-     @since 1.13.0
-     */
-
-    /**
-     Called when the attributes passed into the component have been changed.
-     Called only during a rerender, not during an initial render.
-     @method didUpdateAttrs
-     @public
-     @since 1.13.0
-     */
-    didUpdateAttrs() {},
-
-    /**
-     Called when the attributes passed into the component have been changed.
-     Called only during a rerender, not during an initial render.
-     @event didUpdateAttrs
-     @public
-     @since 1.13.0
-     */
+    }
 
-    /**
-     Called when the component is about to update and rerender itself.
-     Called only during a rerender, not during an initial render.
-     @method willUpdate
-     @public
-     @since 1.13.0
-     */
-    willUpdate() {},
+    static toString() {
+      return '@ember/component';
+    }
 
-    /**
-     Called when the component is about to update and rerender itself.
-     Called only during a rerender, not during an initial render.
-     @event willUpdate
-     @public
-     @since 1.13.0
-     */
+  }
 
-    /**
-     Called when the component has updated and rerendered itself.
-     Called only during a rerender, not during an initial render.
-     @method didUpdate
-     @public
-     @since 1.13.0
-     */
-    didUpdate() {}
-    /**
-     Called when the component has updated and rerendered itself.
-     Called only during a rerender, not during an initial render.
-     @event didUpdate
-     @public
-     @since 1.13.0
-     */
+  _exports.Component = Component;
+  Component.isComponentFactory = true; // We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
 
+  Component.reopenClass({
     /**
-      The HTML `id` of the component's element in the DOM. You can provide this
-      value yourself but it must be unique (just as in HTML):
-       ```handlebars
-      {{my-component elementId="a-really-cool-id"}}
+     Enables components to take a list of parameters as arguments.
+      For example, a component that takes two parameters with the names
+      `name` and `age`:
+         ```app/components/my-component.js
+      import Component from '@ember/component';
+         let MyComponent = Component.extend();
+         MyComponent.reopenClass({
+        positionalParams: ['name', 'age']
+      });
+         export default MyComponent;
       ```
-       ```handlebars
-      <MyComponent @elementId="a-really-cool-id" />
+         It can then be invoked like this:
+         ```hbs
+      {{my-component "John" 38}}
       ```
-      If not manually set a default value will be provided by the framework.
-      Once rendered an element's `elementId` is considered immutable and you
-      should never change it. If you need to compute a dynamic value for the
-      `elementId`, you should do this when the component or element is being
-      instantiated:
-       ```javascript
-      export default Component.extend({
-        init() {
-          this._super(...arguments);
-           var index = this.get('index');
-          this.set('elementId', `component-id${index}`);
-        }
+         The parameters can be referred to just like named parameters:
+         ```hbs
+      Name: {{name}}, Age: {{age}}.
+      ```
+         Using a string instead of an array allows for an arbitrary number of
+      parameters:
+         ```app/components/my-component.js
+      import Component from '@ember/component';
+         let MyComponent = Component.extend();
+         MyComponent.reopenClass({
+        positionalParams: 'names'
       });
+         export default MyComponent;
+      ```
+         It can then be invoked like this:
+         ```hbs
+      {{my-component "John" "Michael" "Scott"}}
       ```
-       @property elementId
-      @type String
+      The parameters can then be referred to by enumerating over the list:
+         ```hbs
+      {{#each names as |name|}}{{name}}{{/each}}
+      ```
+         @static
       @public
-    */
-
-
-  });
-
-  _exports.Component = Component;
-
-  Component.toString = () => '@ember/component';
-
-  Component.reopenClass({
-    isComponentFactory: true,
+      @property positionalParams
+      @since 1.13.0
+      */
     positionalParams: []
   });
   (0, _manager2.setInternalComponentManager)(CURLY_COMPONENT_MANAGER, Component);
@@ -5062,8 +4944,8 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   var IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
 
   class Helper extends _runtime2.FrameworkObject {
-    init() {
-      super.init();
+    init(properties) {
+      super.init(properties);
       this[RECOMPUTE_TAG] = (0, _validator.createTag)();
     }
     /**
@@ -8600,7 +8482,7 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
           /* ADD */
           && kind === 0
           /* ADD */
-          && listener.sync !== sync)) && (0, _debug.assert)(`You attempted to add an observer for the same method on '${event.split(':')[0]}' twice to ${target} as both sync and async. Observers must be either sync or async, they cannot be both. This is likely a mistake, you should either remove the code that added the observer a second time, or update it to always be sync or async. The method was ${method}.`, !(listener.kind === 0 && kind === 0 && listener.sync !== sync))); // update own listener
+          && listener.sync !== sync)) && (0, _debug.assert)(`You attempted to add an observer for the same method on '${event.split(':')[0]}' twice to ${target} as both sync and async. Observers must be either sync or async, they cannot be both. This is likely a mistake, you should either remove the code that added the observer a second time, or update it to always be sync or async. The method was ${String(method)}.`, !(listener.kind === 0 && kind === 0 && listener.sync !== sync))); // update own listener
 
           listener.kind = kind;
           listener.sync = sync;
@@ -8959,6 +8841,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     }
   });
   _exports.hasListeners = hasListeners;
+  _exports.hasUnknownProperty = hasUnknownProperty;
   _exports.inject = inject;
   _exports.isBlank = isBlank;
   _exports.isClassicDecorator = isClassicDecorator;
@@ -10884,6 +10767,10 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     };
   }
 
+  function hasUnknownProperty(val) {
+    return typeof val === 'object' && val !== null && typeof val.unknownProperty === 'function';
+  }
+
   function get(obj, keyName) {
     (true && !(arguments.length === 2) && (0, _debug.assert)(`Get must be called with two arguments; an object and a property key`, arguments.length === 2));
     (true && !(obj !== undefined && obj !== null) && (0, _debug.assert)(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null));
@@ -10908,7 +10795,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
         value = obj[keyName];
       }
 
-      if (value === undefined && typeof obj === 'object' && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
+      if (value === undefined && typeof obj === 'object' && !(keyName in obj) && hasUnknownProperty(obj)) {
         value = obj.unknownProperty(keyName);
       }
 
@@ -11309,7 +11196,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
       return true;
     }
 
-    if (typeof obj.unknownProperty !== 'function' && typeof obj.size === 'number') {
+    if (!hasUnknownProperty(obj) && typeof obj.size === 'number') {
       return !obj.size;
     }
 
@@ -18870,6 +18757,10 @@ define("@ember/-internals/routing/lib/system/router_state", ["exports", "@ember/
 });
 define("@ember/-internals/routing/lib/system/transition", [], function () {
   "use strict";
+  /**
+   @module @ember/routing
+  */
+
   /**
     A Transition is a thennable (a promise-like object) that represents
     an attempt to transition to another route. It can be aborted, either
@@ -23593,6 +23484,14 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
   /**
     @module @ember/object
   */
+  function hasSetUnknownProperty(val) {
+    return typeof val === 'object' && val !== null && typeof val.setUnknownProperty === 'function';
+  }
+
+  function hasToStringExtension(val) {
+    return typeof val === 'object' && val !== null && typeof val.toStringExtension === 'function';
+  }
+
   var reopen = _metal.Mixin.prototype.reopen;
   var wasApplied = new _util._WeakSet();
   var prototypeMixinMap = new WeakMap();
@@ -23616,12 +23515,9 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       (true && !(!(properties instanceof _metal.Mixin)) && (0, _debug.assert)('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof _metal.Mixin)));
       var concatenatedProperties = obj.concatenatedProperties;
       var mergedProperties = obj.mergedProperties;
-      var hasConcatenatedProps = concatenatedProperties !== undefined && concatenatedProperties.length > 0;
-      var hasMergedProps = mergedProperties !== undefined && mergedProperties.length > 0;
       var keyNames = Object.keys(properties);
 
-      for (var i = 0; i < keyNames.length; i++) {
-        var keyName = keyNames[i];
+      for (var keyName of keyNames) {
         var value = properties[keyName];
         (true && !(!(0, _metal.isClassicDecorator)(value)) && (0, _debug.assert)('EmberObject.create no longer supports defining computed ' + 'properties. Define computed properties using extend() or reopen() ' + 'before calling create().', !(0, _metal.isClassicDecorator)(value)));
         (true && !(!(typeof value === 'function' && value.toString().indexOf('._super') !== -1)) && (0, _debug.assert)('EmberObject.create no longer supports defining methods that call _super.', !(typeof value === 'function' && value.toString().indexOf('._super') !== -1)));
@@ -23630,7 +23526,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
         var isDescriptor = possibleDesc !== undefined;
 
         if (!isDescriptor) {
-          if (hasConcatenatedProps && concatenatedProperties.indexOf(keyName) > -1) {
+          if (concatenatedProperties !== undefined && concatenatedProperties.length > 0 && concatenatedProperties.includes(keyName)) {
             var baseValue = obj[keyName];
 
             if (baseValue) {
@@ -23640,7 +23536,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
             }
           }
 
-          if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
+          if (mergedProperties !== undefined && mergedProperties.length > 0 && mergedProperties.includes(keyName)) {
             var _baseValue = obj[keyName];
             value = Object.assign({}, _baseValue, value);
           }
@@ -23648,7 +23544,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
 
         if (isDescriptor) {
           possibleDesc.set(obj, keyName, value);
-        } else if (typeof obj.setUnknownProperty === 'function' && !(keyName in obj)) {
+        } else if (hasSetUnknownProperty(obj) && !(keyName in obj)) {
           obj.setUnknownProperty(keyName, value);
         } else {
           if (true
@@ -23674,86 +23570,24 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     var observerEvents = m.observerEvents();
 
     if (observerEvents !== undefined) {
-      for (var _i = 0; _i < observerEvents.length; _i++) {
-        (0, _metal.activateObserver)(obj, observerEvents[_i].event, observerEvents[_i].sync);
+      for (var i = 0; i < observerEvents.length; i++) {
+        (0, _metal.activateObserver)(obj, observerEvents[i].event, observerEvents[i].sync);
       }
     }
 
-    (0, _metal.sendEvent)(obj, 'init', undefined, undefined, undefined, m);
+    (0, _metal.sendEvent)(obj, 'init', undefined, undefined, m);
   }
-  /**
-    `CoreObject` is the base class for all Ember constructs. It establishes a
-    class system based on Ember's Mixin system, and provides the basis for the
-    Ember Object Model. `CoreObject` should generally not be used directly,
-    instead you should use `EmberObject`.
-  
-    ## Usage
-  
-    You can define a class by extending from `CoreObject` using the `extend`
-    method:
-  
-    ```js
-    const Person = CoreObject.extend({
-      name: 'Tomster',
-    });
-    ```
-  
-    For detailed usage, see the [Object Model](https://guides.emberjs.com/release/object-model/)
-    section of the guides.
-  
-    ## Usage with Native Classes
-  
-    Native JavaScript `class` syntax can be used to extend from any `CoreObject`
-    based class:
-  
-    ```js
-    class Person extends CoreObject {
-      init() {
-        super.init(...arguments);
-        this.name = 'Tomster';
-      }
-    }
-    ```
-  
-    Some notes about `class` usage:
-  
-    * `new` syntax is not currently supported with classes that extend from
-      `EmberObject` or `CoreObject`. You must continue to use the `create` method
-      when making new instances of classes, even if they are defined using native
-      class syntax. If you want to use `new` syntax, consider creating classes
-      which do _not_ extend from `EmberObject` or `CoreObject`. Ember features,
-      such as computed properties and decorators, will still work with base-less
-      classes.
-    * Instead of using `this._super()`, you must use standard `super` syntax in
-      native classes. See the [MDN docs on classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Super_class_calls_with_super)
-      for more details.
-    * Native classes support using [constructors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Constructor)
-      to set up newly-created instances. Ember uses these to, among other things,
-      support features that need to retrieve other entities by name, like Service
-      injection and `getOwner`. To ensure your custom instance setup logic takes
-      place after this important work is done, avoid using the `constructor` in
-      favor of `init`.
-    * Properties passed to `create` will be available on the instance by the time
-      `init` runs, so any code that requires these values should work at that
-      time.
-    * Using native classes, and switching back to the old Ember Object model is
-      fully supported.
-  
-    @class CoreObject
-    @public
-  */
-
 
   class CoreObject {
     constructor(owner) {
       this[_owner2.OWNER] = owner; // prepare prototype...
 
       this.constructor.proto();
-      var self = this;
+      var self;
 
       if (true
       /* DEBUG */
-      && typeof self.unknownProperty === 'function') {
+      && (0, _metal.hasUnknownProperty)(this)) {
         var messageFor = (obj, property) => {
           return `You attempted to access the \`${String(property)}\` property (of ${obj}).\n` + `Since Ember 3.1, this is usually fine as you no longer need to use \`.get()\`\n` + `to access computed properties. However, in this case, the object in question\n` + `is a special kind of Ember object (a proxy). Therefore, it is still necessary\n` + `to use \`.get('${String(property)}')\` in this case.\n\n` + `If you encountered this error because of third-party code that you don't control,\n` + `there is more information at https://github.com/emberjs/ember.js/issues/16148, and\n` + `you can help us improve this error message by telling us more about what happened in\n` + `this situation.`;
         };
@@ -23777,10 +23611,13 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
           }
 
         });
+      } else {
+        self = this;
       }
 
+      var destroyable = self;
       (0, _destroyable.registerDestructor)(self, ensureDestroyCalled, true);
-      (0, _destroyable.registerDestructor)(self, () => self.willDestroy()); // disable chains
+      (0, _destroyable.registerDestructor)(self, () => destroyable.willDestroy()); // disable chains
 
       var m = (0, _meta2.meta)(self);
       m.setInitializing(); // only return when in debug builds and `self` is the proxy created above
@@ -23803,61 +23640,61 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     /**
       An overridable method called when objects are instantiated. By default,
       does nothing unless it is overridden during class definition.
-       Example:
-       ```javascript
+         Example:
+         ```javascript
       import EmberObject from '@ember/object';
-       const Person = EmberObject.extend({
+         const Person = EmberObject.extend({
         init() {
           alert(`Name is ${this.get('name')}`);
         }
       });
-       let steve = Person.create({
+         let steve = Person.create({
         name: 'Steve'
       });
-       // alerts 'Name is Steve'.
+         // alerts 'Name is Steve'.
       ```
-       NOTE: If you do override `init` for a framework class like `Component`
+         NOTE: If you do override `init` for a framework class like `Component`
       from `@ember/component`, be sure to call `this._super(...arguments)`
       in your `init` declaration!
       If you don't, Ember may not have an opportunity to
       do important setup work, and you'll see strange behavior in your
       application.
-       @method init
+         @method init
       @public
     */
 
 
-    init() {}
+    init(_properties) {}
     /**
       Defines the properties that will be concatenated from the superclass
       (instead of overridden).
-       By default, when you extend an Ember class a property defined in
+         By default, when you extend an Ember class a property defined in
       the subclass overrides a property with the same name that is defined
       in the superclass. However, there are some cases where it is preferable
       to build up a property's value by combining the superclass' property
       value with the subclass' value. An example of this in use within Ember
       is the `classNames` property of `Component` from `@ember/component`.
-       Here is some sample code showing the difference between a concatenated
+         Here is some sample code showing the difference between a concatenated
       property and a normal one:
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const Bar = EmberObject.extend({
+         const Bar = EmberObject.extend({
         // Configure which properties to concatenate
         concatenatedProperties: ['concatenatedProperty'],
-         someNonConcatenatedProperty: ['bar'],
+           someNonConcatenatedProperty: ['bar'],
         concatenatedProperty: ['bar']
       });
-       const FooBar = Bar.extend({
+         const FooBar = Bar.extend({
         someNonConcatenatedProperty: ['foo'],
         concatenatedProperty: ['foo']
       });
-       let fooBar = FooBar.create();
+         let fooBar = FooBar.create();
       fooBar.get('someNonConcatenatedProperty'); // ['foo']
       fooBar.get('concatenatedProperty'); // ['bar', 'foo']
       ```
-       This behavior extends to object creation as well. Continuing the
+         This behavior extends to object creation as well. Continuing the
       above example:
-       ```javascript
+         ```javascript
       let fooBar = FooBar.create({
         someNonConcatenatedProperty: ['baz'],
         concatenatedProperty: ['baz']
@@ -23865,23 +23702,23 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       fooBar.get('someNonConcatenatedProperty'); // ['baz']
       fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
       ```
-       Adding a single property that is not an array will just add it in the array:
-       ```javascript
+         Adding a single property that is not an array will just add it in the array:
+         ```javascript
       let fooBar = FooBar.create({
         concatenatedProperty: 'baz'
       })
       view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
       ```
-       Using the `concatenatedProperties` property, we can tell Ember to mix the
+         Using the `concatenatedProperties` property, we can tell Ember to mix the
       content of the properties.
-       In `Component` the `classNames`, `classNameBindings` and
+         In `Component` the `classNames`, `classNameBindings` and
       `attributeBindings` properties are concatenated.
-       This feature is available for you to use throughout the Ember object model,
+         This feature is available for you to use throughout the Ember object model,
       although typical app developers are likely to use it infrequently. Since
       it changes expectations about behavior of properties, you should properly
       document its usage in each individual concatenated property (to not
       mislead your users to think they can override the property in a subclass).
-       @property concatenatedProperties
+         @property concatenatedProperties
       @type Array
       @default null
       @public
@@ -23890,20 +23727,20 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     /**
       Defines the properties that will be merged from the superclass
       (instead of overridden).
-       By default, when you extend an Ember class a property defined in
+         By default, when you extend an Ember class a property defined in
       the subclass overrides a property with the same name that is defined
       in the superclass. However, there are some cases where it is preferable
       to build up a property's value by merging the superclass property value
       with the subclass property's value. An example of this in use within Ember
       is the `queryParams` property of routes.
-       Here is some sample code showing the difference between a merged
+         Here is some sample code showing the difference between a merged
       property and a normal one:
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const Bar = EmberObject.extend({
+         const Bar = EmberObject.extend({
         // Configure which properties are to be merged
         mergedProperties: ['mergedProperty'],
-         someNonMergedProperty: {
+           someNonMergedProperty: {
           nonMerged: 'superclass value of nonMerged'
         },
         mergedProperty: {
@@ -23911,7 +23748,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
           limit: { replace: true }
         }
       });
-       const FooBar = Bar.extend({
+         const FooBar = Bar.extend({
         someNonMergedProperty: {
           completelyNonMerged: 'subclass value of nonMerged'
         },
@@ -23919,13 +23756,13 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
           limit: { replace: false }
         }
       });
-       let fooBar = FooBar.create();
-       fooBar.get('someNonMergedProperty');
+         let fooBar = FooBar.create();
+         fooBar.get('someNonMergedProperty');
       // => { completelyNonMerged: 'subclass value of nonMerged' }
       //
       // Note the entire object, including the nonMerged property of
       // the superclass object, has been replaced
-       fooBar.get('mergedProperty');
+         fooBar.get('mergedProperty');
       // => {
       //   page: {replace: false},
       //   limit: {replace: false}
@@ -23935,15 +23772,15 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       // `limit` property's value of `false` has been merged from
       // the subclass.
       ```
-       This behavior is not available during object `create` calls. It is only
+         This behavior is not available during object `create` calls. It is only
       available at `extend` time.
-       In `Route` the `queryParams` property is merged.
-       This feature is available for you to use throughout the Ember object model,
+         In `Route` the `queryParams` property is merged.
+         This feature is available for you to use throughout the Ember object model,
       although typical app developers are likely to use it infrequently. Since
       it changes expectations about behavior of properties, you should properly
       document its usage in each individual merged property (to not
       mislead your users to think they can override the property in a subclass).
-       @property mergedProperties
+         @property mergedProperties
       @type Array
       @default null
       @public
@@ -23951,9 +23788,9 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
 
     /**
       Destroyed object property flag.
-       if this property is `true` the observers and bindings were already
+         if this property is `true` the observers and bindings were already
       removed by the effect of calling the `destroy()` method.
-       @property isDestroyed
+         @property isDestroyed
       @default false
       @public
     */
@@ -23963,14 +23800,14 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       return (0, _destroyable.isDestroyed)(this);
     }
 
-    set isDestroyed(value) {
+    set isDestroyed(_value) {
       (true && !(false) && (0, _debug.assert)(`You cannot set \`${this}.isDestroyed\` directly, please use \`.destroy()\`.`, false));
     }
     /**
       Destruction scheduled flag. The `destroy()` method has been called.
-       The object stays intact until the end of the run loop at which point
+         The object stays intact until the end of the run loop at which point
       the `isDestroyed` flag is set.
-       @property isDestroying
+         @property isDestroying
       @default false
       @public
     */
@@ -23980,17 +23817,17 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       return (0, _destroyable.isDestroying)(this);
     }
 
-    set isDestroying(value) {
+    set isDestroying(_value) {
       (true && !(false) && (0, _debug.assert)(`You cannot set \`${this}.isDestroying\` directly, please use \`.destroy()\`.`, false));
     }
     /**
       Destroys an object by setting the `isDestroyed` flag and removing its
       metadata, which effectively destroys observers and bindings.
-       If you try to set a property on a destroyed object, an exception will be
+         If you try to set a property on a destroyed object, an exception will be
       raised.
-       Note that destruction is scheduled for the end of the run loop and does not
+         Note that destruction is scheduled for the end of the run loop and does not
       happen immediately.  It will set an isDestroying flag immediately.
-       @method destroy
+         @method destroy
       @return {EmberObject} receiver
       @public
     */
@@ -24010,7 +23847,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     }
     /**
       Override to implement teardown.
-       @method willDestroy
+         @method willDestroy
       @public
     */
 
@@ -24020,22 +23857,22 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       Returns a string representation which attempts to provide more information
       than Javascript's `toString` typically does, in a generic way for all Ember
       objects.
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const Person = EmberObject.extend();
+         const Person = EmberObject.extend();
       person = Person.create();
       person.toString(); //=> "<Person:ember1024>"
       ```
-       If the object's class is not defined on an Ember namespace, it will
+         If the object's class is not defined on an Ember namespace, it will
       indicate it is a subclass of the registered superclass:
-       ```javascript
+         ```javascript
       const Student = Person.extend();
       let student = Student.create();
       student.toString(); //=> "<(subclass of Person):ember1025>"
       ```
-       If the method `toStringExtension` is defined, its return value will be
+         If the method `toStringExtension` is defined, its return value will be
       included in the output.
-       ```javascript
+         ```javascript
       const Teacher = Person.extend({
         toStringExtension() {
           return this.get('fullName');
@@ -24044,133 +23881,34 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       teacher = Teacher.create();
       teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
       ```
-       @method toString
+         @method toString
       @return {String} string representation
       @public
     */
 
 
     toString() {
-      var hasToStringExtension = typeof this.toStringExtension === 'function';
-      var extension = hasToStringExtension ? `:${this.toStringExtension()}` : '';
+      var extension = hasToStringExtension(this) ? `:${this.toStringExtension()}` : '';
       return `<${(0, _container.getFactoryFor)(this) || '(unknown)'}:${(0, _utils.guidFor)(this)}${extension}>`;
     }
-    /**
-      Creates a new subclass.
-       ```javascript
-      import EmberObject from '@ember/object';
-       const Person = EmberObject.extend({
-        say(thing) {
-          alert(thing);
-         }
-      });
-      ```
-       This defines a new subclass of EmberObject: `Person`. It contains one method: `say()`.
-       You can also create a subclass from any existing class by calling its `extend()` method.
-      For example, you might want to create a subclass of Ember's built-in `Component` class:
-       ```javascript
-      import Component from '@ember/component';
-       const PersonComponent = Component.extend({
-        tagName: 'li',
-        classNameBindings: ['isAdministrator']
-      });
-      ```
-       When defining a subclass, you can override methods but still access the
-      implementation of your parent class by calling the special `_super()` method:
-       ```javascript
-      import EmberObject from '@ember/object';
-       const Person = EmberObject.extend({
-        say(thing) {
-          let name = this.get('name');
-          alert(`${name} says: ${thing}`);
-        }
-      });
-       const Soldier = Person.extend({
-        say(thing) {
-          this._super(`${thing}, sir!`);
-        },
-        march(numberOfHours) {
-          alert(`${this.get('name')} marches for ${numberOfHours} hours.`);
-        }
-      });
-       let yehuda = Soldier.create({
-        name: 'Yehuda Katz'
-      });
-       yehuda.say('Yes');  // alerts "Yehuda Katz says: Yes, sir!"
-      ```
-       The `create()` on line #17 creates an *instance* of the `Soldier` class.
-      The `extend()` on line #8 creates a *subclass* of `Person`. Any instance
-      of the `Person` class will *not* have the `march()` method.
-       You can also pass `Mixin` classes to add additional properties to the subclass.
-       ```javascript
-      import EmberObject from '@ember/object';
-      import Mixin from '@ember/object/mixin';
-       const Person = EmberObject.extend({
-        say(thing) {
-          alert(`${this.get('name')} says: ${thing}`);
-        }
-      });
-       const SingingMixin = Mixin.create({
-        sing(thing) {
-          alert(`${this.get('name')} sings: la la la ${thing}`);
-        }
-      });
-       const BroadwayStar = Person.extend(SingingMixin, {
-        dance() {
-          alert(`${this.get('name')} dances: tap tap tap tap `);
-        }
-      });
-      ```
-       The `BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
-       @method extend
-      @static
-      @for @ember/object
-      @param {Mixin} [mixins]* One or more Mixin classes
-      @param {Object} [arguments]* Object containing values to use within the new class
-      @public
-    */
-
 
     static extend() {
       var Class = class extends this {};
-      reopen.apply(Class.PrototypeMixin, arguments);
+
+      for (var _len2 = arguments.length, mixins = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        mixins[_key2] = arguments[_key2];
+      }
+
+      reopen.apply(Class.PrototypeMixin, mixins);
       return Class;
     }
-    /**
-      Creates an instance of a class. Accepts either no arguments, or an object
-      containing values to initialize the newly instantiated object with.
-       ```javascript
-      import EmberObject from '@ember/object';
-       const Person = EmberObject.extend({
-        helloWorld() {
-          alert(`Hi, my name is ${this.get('name')}`);
-        }
-      });
-       let tom = Person.create({
-        name: 'Tom Dale'
-      });
-       tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
-      ```
-       `create` will call the `init` function if defined during
-      `AnyObject.extend`
-       If no arguments are passed to `create`, it will not set values to the new
-      instance during initialization:
-       ```javascript
-      let noName = Person.create();
-      noName.helloWorld(); // alerts undefined
-      ```
-       NOTE: For performance reasons, you cannot declare methods or computed
-      properties during `create`. You should instead declare methods and computed
-      properties when using `extend`.
-       @method create
-      @for @ember/object
-      @static
-      @param [arguments]*
-      @public
-    */
 
+    static create() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
 
-    static create(props, extra) {
+      var props = args[0];
       var instance;
 
       if (props !== undefined) {
@@ -24180,10 +23918,10 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
         instance = new this();
       }
 
-      if (extra === undefined) {
+      if (args.length <= 1) {
         initialize(instance, props);
       } else {
-        initialize(instance, flattenProps.apply(this, arguments));
+        initialize(instance, flattenProps.apply(this, args));
       }
 
       return instance;
@@ -24191,25 +23929,25 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     /**
       Augments a constructor's prototype with additional
       properties and functions:
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const MyObject = EmberObject.extend({
+         const MyObject = EmberObject.extend({
         name: 'an object'
       });
-       o = MyObject.create();
+         o = MyObject.create();
       o.get('name'); // 'an object'
-       MyObject.reopen({
+         MyObject.reopen({
         say(msg) {
           console.log(msg);
         }
       });
-       o2 = MyObject.create();
+         o2 = MyObject.create();
       o2.say('hello'); // logs "hello"
-       o.say('goodbye'); // logs "goodbye"
+         o.say('goodbye'); // logs "goodbye"
       ```
-       To add functions and properties to the constructor itself,
+         To add functions and properties to the constructor itself,
       see `reopenClass`
-       @method reopen
+         @method reopen
       @for @ember/object
       @static
       @public
@@ -24218,7 +23956,12 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
 
     static reopen() {
       this.willReopen();
-      reopen.apply(this.PrototypeMixin, arguments);
+
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+
+      reopen.apply(this.PrototypeMixin, args);
       return this;
     }
 
@@ -24237,47 +23980,47 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     }
     /**
       Augments a constructor's own properties and functions:
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const MyObject = EmberObject.extend({
+         const MyObject = EmberObject.extend({
         name: 'an object'
       });
-       MyObject.reopenClass({
+         MyObject.reopenClass({
         canBuild: false
       });
-       MyObject.canBuild; // false
+         MyObject.canBuild; // false
       o = MyObject.create();
       ```
-       In other words, this creates static properties and functions for the class.
+         In other words, this creates static properties and functions for the class.
       These are only available on the class and not on any instance of that class.
-       ```javascript
+         ```javascript
       import EmberObject from '@ember/object';
-       const Person = EmberObject.extend({
+         const Person = EmberObject.extend({
         name: '',
         sayHello() {
           alert(`Hello. My name is ${this.get('name')}`);
         }
       });
-       Person.reopenClass({
+         Person.reopenClass({
         species: 'Homo sapiens',
-         createPerson(name) {
+           createPerson(name) {
           return Person.create({ name });
         }
       });
-       let tom = Person.create({
+         let tom = Person.create({
         name: 'Tom Dale'
       });
       let yehuda = Person.createPerson('Yehuda Katz');
-       tom.sayHello(); // "Hello. My name is Tom Dale"
+         tom.sayHello(); // "Hello. My name is Tom Dale"
       yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
       alert(Person.species); // "Homo sapiens"
       ```
-       Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
+         Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
       variables. They are only valid on `Person`.
-       To add functions and properties to instances of
+         To add functions and properties to instances of
       a constructor by extending the constructor's prototype
       see `reopen`
-       @method reopenClass
+         @method reopenClass
       @for @ember/object
       @static
       @public
@@ -24285,7 +24028,11 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
 
 
     static reopenClass() {
-      (0, _metal.applyMixin)(this, arguments);
+      for (var _len5 = arguments.length, mixins = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        mixins[_key5] = arguments[_key5];
+      }
+
+      (0, _metal.applyMixin)(this, mixins);
       return this;
     }
 
@@ -24313,21 +24060,21 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
       metadata about how they function or what values they operate on. For
       example, computed property functions may close over variables that are then
       no longer available for introspection.
-       You can pass a hash of these values to a computed property like this:
-       ```javascript
+         You can pass a hash of these values to a computed property like this:
+         ```javascript
       import { computed } from '@ember/object';
-       person: computed(function() {
+         person: computed(function() {
         let personId = this.get('personId');
         return Person.create({ id: personId });
       }).meta({ type: Person })
       ```
-       Once you've done this, you can retrieve the values saved to the computed
+         Once you've done this, you can retrieve the values saved to the computed
       property from your class like this:
-       ```javascript
+         ```javascript
       MyClass.metaForProperty('person');
       ```
-       This will return the original hash that was passed to `meta()`.
-       @static
+         This will return the original hash that was passed to `meta()`.
+         @static
       @method metaForProperty
       @param key {String} property name
       @private
@@ -24344,7 +24091,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     /**
       Iterate over each computed property for the class, passing its name
       and any associated metadata (see `metaForProperty`) to the callback.
-       @static
+         @static
       @method eachComputedProperty
       @param {Function} callback
       @param {Object} binding
@@ -24417,38 +24164,19 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
   CoreObject.isMethod = false;
 
   function flattenProps() {
-    var {
-      concatenatedProperties,
-      mergedProperties
-    } = this;
-    var hasConcatenatedProps = concatenatedProperties !== undefined && concatenatedProperties.length > 0;
-    var hasMergedProps = mergedProperties !== undefined && mergedProperties.length > 0;
     var initProperties = {};
 
-    for (var i = 0; i < arguments.length; i++) {
-      var properties = i < 0 || arguments.length <= i ? undefined : arguments[i];
+    for (var _len6 = arguments.length, props = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      props[_key6] = arguments[_key6];
+    }
+
+    for (var properties of props) {
       (true && !(!(properties instanceof _metal.Mixin)) && (0, _debug.assert)('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof _metal.Mixin)));
       var keyNames = Object.keys(properties);
 
       for (var j = 0, k = keyNames.length; j < k; j++) {
         var keyName = keyNames[j];
         var value = properties[keyName];
-
-        if (hasConcatenatedProps && concatenatedProperties.indexOf(keyName) > -1) {
-          var baseValue = initProperties[keyName];
-
-          if (baseValue) {
-            value = (0, _utils.makeArray)(baseValue).concat(value);
-          } else {
-            value = (0, _utils.makeArray)(value);
-          }
-        }
-
-        if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
-          var _baseValue2 = initProperties[keyName];
-          value = Object.assign({}, _baseValue2, value);
-        }
-
         initProperties[keyName] = value;
       }
     }
@@ -24461,7 +24189,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
   ) {
     /**
       Provides lookup-time type validation for injected properties.
-       @private
+         @private
       @method _onLookup
     */
     CoreObject._onLookup = function injectedPropertyAssertion(debugContainerKey) {
@@ -24479,7 +24207,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
     /**
       Returns a hash of property names and container names that injected
       properties will lookup on the container lazily.
-       @method _lazyInjections
+         @method _lazyInjections
       @return {Object} Hash of all lazy injected property keys to container names
       @private
     */
@@ -24599,18 +24327,7 @@ define("@ember/-internals/runtime/lib/system/object", ["exports", "@ember/-inter
   /**
   @module @ember/object
   */
-
-  /**
-    `EmberObject` is the main base class for all Ember objects. It is a subclass
-    of `CoreObject` with the `Observable` mixin applied. For details,
-    see the documentation for each of these.
-  
-    @class EmberObject
-    @extends CoreObject
-    @uses Observable
-    @public
-  */
-  class EmberObject extends _core_object.default {
+  class EmberObject extends _core_object.default.extend(_observable.default) {
     get _debugContainerKey() {
       var factory = (0, _container.getFactoryFor)(this);
       return factory !== undefined && factory.fullName;
@@ -24618,21 +24335,10 @@ define("@ember/-internals/runtime/lib/system/object", ["exports", "@ember/-inter
 
   }
 
-  _exports.default = EmberObject;
-
-  _observable.default.apply(EmberObject.prototype);
-
-  var FrameworkObject;
+  var _default = EmberObject;
+  _exports.default = _default;
+  var FrameworkObject = class FrameworkObject extends EmberObject {};
   _exports.FrameworkObject = FrameworkObject;
-  _exports.FrameworkObject = FrameworkObject = class FrameworkObject extends _core_object.default {
-    get _debugContainerKey() {
-      var factory = (0, _container.getFactoryFor)(this);
-      return factory !== undefined && factory.fullName;
-    }
-
-  };
-
-  _observable.default.apply(FrameworkObject.prototype);
 
   if (true
   /* DEBUG */
@@ -24640,8 +24346,8 @@ define("@ember/-internals/runtime/lib/system/object", ["exports", "@ember/-inter
     var INIT_WAS_CALLED = (0, _utils.symbol)('INIT_WAS_CALLED');
     var ASSERT_INIT_WAS_CALLED = (0, _utils.symbol)('ASSERT_INIT_WAS_CALLED');
     _exports.FrameworkObject = FrameworkObject = class DebugFrameworkObject extends EmberObject {
-      init() {
-        super.init(...arguments);
+      init(properties) {
+        super.init(properties);
         this[INIT_WAS_CALLED] = true;
       }
 
@@ -27168,36 +26874,49 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
   });
   _exports.default = void 0;
 
-  var CoreView = _runtime.FrameworkObject.extend(_runtime.Evented, _runtime.ActionHandler, {
-    isView: true,
-    _states: _states.default,
+  var __decorate = void 0 && (void 0).__decorate || function (decorators, target, key, desc) {
+    var c = arguments.length,
+        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+        d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  };
+
+  class CoreView extends _runtime.FrameworkObject.extend(_runtime.Evented, _runtime.ActionHandler, {
+    // Continue to declare `_states` here so that we have a single reference on the prototype
+    // instead of one on each instance.
+    _states: _states.default
+  }) {
+    constructor() {
+      super(...arguments);
+      this.isView = true;
+    }
 
-    init() {
-      this._super(...arguments);
+    init(properties) {
+      var _a;
 
+      super.init(properties); // Handle methods from Evented
+      // The native class inheritance will not work for mixins. To work around this,
+      // we copy the existing trigger and has methods provided by the mixin and swap in the
+      // new ones from our class.
+
+      this._superTrigger = this.trigger;
+      this.trigger = this._trigger;
+      this._superHas = this.has;
+      this.has = this._has;
+      (_a = this.parentView) !== null && _a !== void 0 ? _a : this.parentView = null;
       this._state = 'preRender';
       this._currentState = this._states.preRender;
-    },
-
-    renderer: (0, _metal.inject)('renderer', '-dom'),
-
-    /**
-      If the view is currently inserted into the DOM of a parent view, this
-      property will point to the parent of the view.
-         @property parentView
-      @type Ember.View
-      @default null
-      @private
-    */
-    parentView: null,
+    }
 
     instrumentDetails(hash) {
       hash['object'] = this.toString();
       hash['containerKey'] = this._debugContainerKey;
       hash['view'] = this;
       return hash;
-    },
-
+    }
     /**
       Override the default event firing from `Evented` to
       also call methods with the given name.
@@ -27205,29 +26924,34 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
       @param name {String}
       @private
     */
-    trigger(name) {
+    // Changed to `trigger` on init
+
+
+    _trigger(name) {
       for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
         args[_key - 1] = arguments[_key];
       }
 
-      this._super(...arguments);
+      this._superTrigger(name, ...args);
 
       var method = this[name];
 
       if (typeof method === 'function') {
         return method.apply(this, args);
       }
-    },
+    } // Changed to `has` on init
 
-    has(name) {
-      return typeof this[name] === 'function' || this._super(name);
+
+    _has(name) {
+      return typeof this[name] === 'function' || this._superHas(name);
     }
 
-  });
+  }
+
+  CoreView.isViewFactory = true;
+
+  __decorate([(0, _metal.inject)('renderer', '-dom')], CoreView.prototype, "renderer", void 0);
 
-  CoreView.reopenClass({
-    isViewFactory: true
-  });
   var _default = CoreView;
   _exports.default = _default;
 });
@@ -29059,8 +28783,8 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
     @public
   */
   var DEFAULT_FEATURES = {
-    EMBER_LIBRARIES_ISREGISTERED: null,
-    EMBER_IMPROVED_INSTRUMENTATION: null,
+    EMBER_LIBRARIES_ISREGISTERED: false,
+    EMBER_IMPROVED_INSTRUMENTATION: false,
     EMBER_UNIQUE_ID_HELPER: true
   };
   /**
@@ -34076,19 +33800,6 @@ define("@ember/polyfills/lib/assign", ["exports", "@ember/debug"], function (_ex
     return Object.assign(target, ...rest);
   }
 });
-define("@ember/renderer/index", ["exports", "@ember/-internals/glimmer"], function (_exports, _glimmer) {
-  "use strict";
-
-  Object.defineProperty(_exports, "__esModule", {
-    value: true
-  });
-  Object.defineProperty(_exports, "renderSettled", {
-    enumerable: true,
-    get: function () {
-      return _glimmer.renderSettled;
-    }
-  });
-});
 define("@ember/routing/auto-location", ["exports", "@ember/-internals/routing"], function (_exports, _routing) {
   "use strict";
 
@@ -55051,7 +54762,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.4.0-alpha.6";
+  var _default = "4.4.0";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {