ember-source 4.4.0-alpha.7 → 4.5.0-alpha.2

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.7
+ * @version   4.5.0-alpha.2
  */
 /* eslint-disable no-var */
 
@@ -264,8 +264,7 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
       @private
      @method lookup
      @param {String} fullName
-     @param {Object} [options]
-     @param {String} [options.source] The fullname of the request source (used for local lookup)
+     @param {TypeOptions} [options]
      @return {any}
      */
 
@@ -345,9 +344,7 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
       }
 
       var normalizedName = this.registry.normalize(fullName);
-      (true && !(this.registry.isValidFullName(normalizedName)) && (0, _debug.assert)('fullName must be a proper full name', this.registry.isValidFullName(normalizedName))); // TODO: This needs to return a Factory to be compatible with Owner.
-      // We should correctly the types so that this cast is not necessary.
-
+      (true && !(this.registry.isValidFullName(normalizedName)) && (0, _debug.assert)('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)));
       return factoryFor(this, normalizedName, fullName);
     }
 
@@ -632,7 +629,6 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
       this.fallback = options.fallback || null;
       this.resolver = options.resolver || null;
       this.registrations = (0, _utils.dictionary)(options.registrations || null);
-      this._localLookupCache = Object.create(null);
       this._normalizeCache = (0, _utils.dictionary)(null);
       this._resolveCache = (0, _utils.dictionary)(null);
       this._failSet = new Set();
@@ -729,7 +725,6 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
     unregister(fullName) {
       (true && !(this.isValidFullName(fullName)) && (0, _debug.assert)('fullName must be a proper full name', this.isValidFullName(fullName)));
       var normalizedName = this.normalize(fullName);
-      this._localLookupCache = Object.create(null);
       delete this.registrations[normalizedName];
       delete this._resolveCache[normalizedName];
       delete this._options[normalizedName];
@@ -760,8 +755,6 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
         @private
      @method resolve
      @param {String} fullName
-     @param {Object} [options]
-     @param {String} [options.source] the fullname of the request source (used for local lookups)
      @return {Function} fullName's factory
      */
 
@@ -770,7 +763,7 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
       var factory = resolve(this, this.normalize(fullName));
 
       if (factory === undefined && this.fallback !== null) {
-        factory = this.fallback.resolve(...arguments);
+        factory = this.fallback.resolve(fullName);
       }
 
       return factory;
@@ -4947,6 +4940,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     init(properties) {
       super.init(properties);
       this[RECOMPUTE_TAG] = (0, _validator.createTag)();
+      (true && !(this.compute) && (0, _debug.assert)('expected compute to be defined', this.compute));
     }
     /**
       On a class-based helper, it may be useful to force a recomputation of that
@@ -5001,6 +4995,21 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
     createHelper(definition, args) {
       var instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
+      (true && !(function (instance) {
+        if (instance !== null && typeof instance === 'object') {
+          var cast = instance;
+          return typeof cast.compute === 'function' && typeof cast.destroy === 'function';
+        }
+
+        return false;
+      }(instance)) && (0, _debug.assert)('expected HelperInstance', function (instance) {
+        if (instance !== null && typeof instance === 'object') {
+          var cast = instance;
+          return typeof cast.compute === 'function' && typeof cast.destroy === 'function';
+        }
+
+        return false;
+      }(instance)));
       return {
         instance,
         args
@@ -5265,9 +5274,12 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
           (true && !(currentOwner instanceof _instance.default) && (0, _debug.assert)('Expected currentOwner to be an EngineInstance', currentOwner instanceof _instance.default));
           var mountPoint = currentOwner.mountPoint;
           state.engine = currentOwner;
-          state.engineBucket = {
-            mountPoint
-          };
+
+          if (mountPoint) {
+            state.engineBucket = {
+              mountPoint
+            };
+          }
         }
       }
 
@@ -7074,7 +7086,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   function lookupComponentPair(owner, name, options) {
     var component = componentFor(name, owner);
 
-    if (component !== null && component.class !== undefined) {
+    if ((0, _owner2.isFactory)(component) && component.class) {
       var _layout = (0, _manager2.getComponentTemplate)(component.class);
 
       if (_layout !== undefined) {
@@ -12713,8 +12725,12 @@ define("@ember/-internals/owner/index", ["exports", "@glimmer/owner"], function
     value: true
   });
   _exports.getOwner = getOwner;
+  _exports.isFactory = isFactory;
   _exports.setOwner = setOwner;
 
+  function isFactory(obj) {
+    return obj != null && typeof obj.create === 'function';
+  }
   /**
     Framework objects in an Ember application (components, services, routes, etc.)
     are created via a factory and dependency injection system. Each of these
@@ -12759,6 +12775,8 @@ define("@ember/-internals/owner/index", ["exports", "@glimmer/owner"], function
     @since 2.3.0
     @public
   */
+
+
   function getOwner(object) {
     return (0, _owner.getOwner)(object);
   }
@@ -17091,6 +17109,8 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
   */
 
   class EmberRouter extends _runtime.Object.extend(_runtime.Evented) {
+    // Note that owner is actually required in this scenario, but since it is strictly
+    // optional in other contexts trying to make it required here confuses TS.
     constructor(owner) {
       super(owner);
       this._didSetupRouter = false;
@@ -17110,6 +17130,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       this._slowTransitionTimer = null;
       this.currentState = null;
       this.targetState = null;
+      (true && !(owner) && (0, _debug.assert)('BUG: Missing owner', owner));
 
       this._resetQueuedQueryParameterChanges();
 
@@ -24245,7 +24266,7 @@ define("@ember/-internals/runtime/lib/system/core_object", ["exports", "@ember/-
   var _default = CoreObject;
   _exports.default = _default;
 });
-define("@ember/-internals/runtime/lib/system/namespace", ["exports", "@ember/-internals/metal", "@ember/-internals/utils", "@ember/-internals/runtime/lib/system/object"], function (_exports, _metal, _utils, _object) {
+define("@ember/-internals/runtime/lib/system/namespace", ["exports", "@ember/-internals/metal", "@ember/-internals/utils", "@ember/debug", "@ember/-internals/runtime/lib/system/object"], function (_exports, _metal, _utils, _debug, _object) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -24276,19 +24297,21 @@ define("@ember/-internals/runtime/lib/system/namespace", ["exports", "@ember/-in
     @public
   */
   class Namespace extends _object.default {
-    init() {
+    init(properties) {
+      super.init(properties);
       (0, _metal.addNamespace)(this);
     }
 
     toString() {
-      var name = (0, _metal.get)(this, 'name') || (0, _metal.get)(this, 'modulePrefix');
+      var existing_name = (0, _metal.get)(this, 'name') || (0, _metal.get)(this, 'modulePrefix');
 
-      if (name) {
-        return name;
+      if (existing_name) {
+        (true && !(typeof existing_name === 'string') && (0, _debug.assert)("name wasn't a string", typeof existing_name === 'string'));
+        return existing_name;
       }
 
       (0, _metal.findNamespaces)();
-      name = (0, _utils.getName)(this);
+      var name = (0, _utils.getName)(this);
 
       if (name === undefined) {
         name = (0, _utils.guidFor)(this);
@@ -24304,17 +24327,19 @@ define("@ember/-internals/runtime/lib/system/namespace", ["exports", "@ember/-in
 
     destroy() {
       (0, _metal.removeNamespace)(this);
-      super.destroy();
+      return super.destroy();
     }
 
   }
 
-  _exports.default = Namespace;
-  Namespace.prototype.isNamespace = true;
   Namespace.NAMESPACES = _metal.NAMESPACES;
   Namespace.NAMESPACES_BY_ID = _metal.NAMESPACES_BY_ID;
   Namespace.processAll = _metal.processAllNamespaces;
-  Namespace.byName = _metal.findNamespace;
+  Namespace.byName = _metal.findNamespace; // Declare on the prototype to have a single shared value.
+
+  Namespace.prototype.isNamespace = true;
+  var _default = Namespace;
+  _exports.default = _default;
 });
 define("@ember/-internals/runtime/lib/system/object", ["exports", "@ember/-internals/container", "@ember/-internals/utils", "@ember/-internals/metal", "@ember/-internals/runtime/lib/system/core_object", "@ember/-internals/runtime/lib/mixins/observable", "@ember/debug"], function (_exports, _container, _utils, _metal, _core_object, _observable, _debug) {
   "use strict";
@@ -26884,11 +26909,7 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
     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
-  }) {
+  class CoreView extends _runtime.FrameworkObject.extend(_runtime.Evented, _runtime.ActionHandler) {
     constructor() {
       super(...arguments);
       this.isView = true;
@@ -26950,8 +26971,10 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
 
   CoreView.isViewFactory = true;
 
-  __decorate([(0, _metal.inject)('renderer', '-dom')], CoreView.prototype, "renderer", void 0);
+  __decorate([(0, _metal.inject)('renderer', '-dom')], CoreView.prototype, "renderer", void 0); // Declare on the prototype to have a single shared value.
+
 
+  CoreView.prototype._states = _states.default;
   var _default = CoreView;
   _exports.default = _default;
 });
@@ -27173,7 +27196,7 @@ define("@ember/application/index", ["exports", "@ember/-internals/owner", "@embe
     }
   });
 });
-define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@ember/-internals/browser-environment", "@ember/engine/instance", "@ember/-internals/glimmer"], function (_exports, _metal, environment, _instance, _glimmer) {
+define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@ember/-internals/browser-environment", "@ember/engine/instance", "@ember/-internals/glimmer", "@ember/debug", "@ember/-internals/routing", "@ember/-internals/views"], function (_exports, _metal, environment, _instance, _glimmer, _debug, _routing, _views) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -27209,35 +27232,21 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
     @class ApplicationInstance
     @extends EngineInstance
   */
-  var ApplicationInstance = _instance.default.extend({
-    /**
-      The `Application` for which this is an instance.
-       @property {Application} application
-      @private
-    */
-    application: null,
-
-    /**
-      The DOM events for which the event dispatcher should listen.
-       By default, the application's `Ember.EventDispatcher` listens
-      for a set of standard DOM events, such as `mousedown` and
-      `keyup`, and delegates them to your application's `Ember.View`
-      instances.
-       @private
-      @property {Object} customEvents
-    */
-    customEvents: null,
+  class ApplicationInstance extends _instance.default {
+    constructor() {
+      super(...arguments);
+      /**
+        The root DOM element of the Application as an element or a
+        CSS selector.
+               @private
+        @property {String|DOMElement} rootElement
+      */
 
-    /**
-      The root DOM element of the Application as an element or a
-      CSS selector.
-       @private
-      @property {String|DOMElement} rootElement
-    */
-    rootElement: null,
+      this.rootElement = null;
+    }
 
-    init() {
-      this._super(...arguments);
+    init(properties) {
+      super.init(properties);
 
       this.application._watchInstance(this); // Register this instance in the per-instance registry.
       //
@@ -27251,25 +27260,26 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
       this.register('-application-instance:main', this, {
         instantiate: false
       });
-    },
-
+    }
     /**
       Overrides the base `EngineInstance._bootSync` method with concerns relevant
       to booting application (instead of engine) instances.
-       This method should only contain synchronous boot concerns. Asynchronous
+         This method should only contain synchronous boot concerns. Asynchronous
       boot concerns should eventually be moved to the `boot` method, which
       returns a promise.
-       Until all boot code has been made asynchronous, we need to continue to
+         Until all boot code has been made asynchronous, we need to continue to
       expose this method for use *internally* in places where we need to boot an
       instance synchronously.
-       @private
+         @private
     */
+
+
     _bootSync(options) {
       if (this._booted) {
         return this;
       }
 
-      options = new BootOptions(options);
+      options = new _BootOptions(options);
       this.setupRegistry(options);
 
       if (options.rootElement) {
@@ -27290,93 +27300,104 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
 
       this._booted = true;
       return this;
-    },
+    }
 
     setupRegistry(options) {
       this.constructor.setupRegistry(this.__registry__, options);
-    },
+    }
 
-    router: (0, _metal.computed)(function () {
-      return this.lookup('router:main');
-    }).readOnly(),
+    get router() {
+      if (!this._router) {
+        var router = this.lookup('router:main');
+        (true && !(router instanceof _routing.Router) && (0, _debug.assert)('expected an instance of Router', router instanceof _routing.Router));
+        this._router = router;
+      }
 
+      return this._router;
+    }
     /**
       This hook is called by the root-most Route (a.k.a. the ApplicationRoute)
       when it has finished creating the root View. By default, we simply take the
       view and append it to the `rootElement` specified on the Application.
-       In cases like FastBoot and testing, we can override this hook and implement
+         In cases like FastBoot and testing, we can override this hook and implement
       custom behavior, such as serializing to a string and sending over an HTTP
       socket rather than appending to DOM.
-       @param view {Ember.View} the root-most view
+         @param view {Ember.View} the root-most view
       @deprecated
       @private
     */
+
+
     didCreateRootView(view) {
       view.appendTo(this.rootElement);
-    },
-
+    }
     /**
       Tells the router to start routing. The router will ask the location for the
       current URL of the page to determine the initial URL to start routing to.
       To start the app at a specific URL, call `handleURL` instead.
-       @private
+         @private
     */
+
+
     startRouting() {
       this.router.startRouting();
-    },
-
+    }
     /**
       Sets up the router, initializing the child router and configuring the
       location before routing begins.
-       Because setup should only occur once, multiple calls to `setupRouter`
+         Because setup should only occur once, multiple calls to `setupRouter`
       beyond the first call have no effect.
-       This is commonly used in order to confirm things that rely on the router
+         This is commonly used in order to confirm things that rely on the router
       are functioning properly from tests that are primarily rendering related.
-       For example, from within [ember-qunit](https://github.com/emberjs/ember-qunit)'s
+         For example, from within [ember-qunit](https://github.com/emberjs/ember-qunit)'s
       `setupRenderingTest` calling `this.owner.setupRouter()` would allow that
       rendering test to confirm that any `<LinkTo></LinkTo>`'s that are rendered
       have the correct URL.
-       @public
+         @public
     */
+
+
     setupRouter() {
       this.router.setupRouter();
-    },
-
+    }
     /**
       Directs the router to route to a particular URL. This is useful in tests,
       for example, to tell the app to start at a particular URL.
-       @param url {String} the URL the router should route to
+         @param url {String} the URL the router should route to
       @private
     */
+
+
     handleURL(url) {
       this.setupRouter();
       return this.router.handleURL(url);
-    },
-
+    }
     /**
       @private
     */
+
+
     setupEventDispatcher() {
       var dispatcher = this.lookup('event_dispatcher:main');
+      (true && !(dispatcher instanceof _views.EventDispatcher) && (0, _debug.assert)('expected EventDispatcher', dispatcher instanceof _views.EventDispatcher));
       var applicationCustomEvents = (0, _metal.get)(this.application, 'customEvents');
       var instanceCustomEvents = (0, _metal.get)(this, 'customEvents');
       var customEvents = Object.assign({}, applicationCustomEvents, instanceCustomEvents);
       dispatcher.setup(customEvents, this.rootElement);
       return dispatcher;
-    },
-
+    }
     /**
       Returns the current URL of the app instance. This is useful when your
       app does not update the browsers URL bar (i.e. it uses the `'none'`
       location adapter).
-       @public
+         @public
       @return {String} the current URL
     */
+
+
     getURL() {
       return this.router.url;
-    },
-
-    // `instance.visit(url)` should eventually replace `instance.handleURL()`;
+    } // `instance.visit(url)` should eventually replace `instance.handleURL()`;
     // the test helpers can probably be switched to use this implementation too
 
     /**
@@ -27384,10 +27405,12 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
       example, or to tell the app to start at a particular URL. This method
       returns a promise that resolves with the app instance when the transition
       is complete, or rejects if the transion was aborted due to an error.
-       @public
+         @public
       @param url {String} the destination URL
       @return {Promise<ApplicationInstance>}
     */
+
+
     visit(url) {
       this.setupRouter();
 
@@ -27417,48 +27440,43 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
         }
       };
 
-      var location = (0, _metal.get)(router, 'location'); // Keeps the location adapter's internal URL in-sync
+      var location = (0, _metal.get)(router, 'location');
+      (true && !(typeof location !== 'string') && (0, _debug.assert)('location has been initialized', typeof location !== 'string')); // Keeps the location adapter's internal URL in-sync
 
       location.setURL(url); // getURL returns the set url with the rootURL stripped off
 
       return router.handleURL(location.getURL()).then(handleTransitionResolve, handleTransitionReject);
-    },
+    }
 
     willDestroy() {
-      this._super(...arguments);
+      super.willDestroy();
 
       this.application._unwatchInstance(this);
     }
-
-  });
-
-  ApplicationInstance.reopenClass({
     /**
      @private
      @method setupRegistry
      @param {Registry} registry
      @param {BootOptions} options
     */
-    setupRegistry(registry, options) {
+
+
+    static setupRegistry(registry, options) {
       if (options === void 0) {
         options = {};
       }
 
-      if (!options.toEnvironment) {
-        options = new BootOptions(options);
-      }
-
-      registry.register('-environment:main', options.toEnvironment(), {
+      var coptions = options instanceof _BootOptions ? options : new _BootOptions(options);
+      registry.register('-environment:main', coptions.toEnvironment(), {
         instantiate: false
       });
-      registry.register('service:-document', options.document, {
+      registry.register('service:-document', coptions.document, {
         instantiate: false
       });
-
-      this._super(registry, options);
+      super.setupRegistry(registry, coptions);
     }
 
-  });
+  }
   /**
     A list of boot-time configuration options for customizing the behavior of
     an `ApplicationInstance`.
@@ -27482,48 +27500,26 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
     @public
   */
 
-  class BootOptions {
+
+  class _BootOptions {
     constructor(options) {
       if (options === void 0) {
         options = {};
       }
 
       /**
-        Interactive mode: whether we need to set up event delegation and invoke
-        lifecycle callbacks on Components.
-         @property isInteractive
-        @type boolean
-        @default auto-detected
-        @private
-      */
-      this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
-
-      /**
-        @property _renderMode
+        If present, overrides the router's `location` property with this
+        value. This is useful for environments where trying to modify the
+        URL would be inappropriate.
+               @property location
         @type string
-        @default undefined
-        @private
+        @default null
+        @public
       */
+      this.location = null;
+      this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
 
       this._renderMode = options._renderMode;
-      /**
-        Run in a full browser environment.
-         When this flag is set to `false`, it will disable most browser-specific
-        and interactive features. Specifically:
-         * It does not use `jQuery` to append the root view; the `rootElement`
-          (either specified as a subsequent option or on the application itself)
-          must already be an `Element` in the given `document` (as opposed to a
-          string selector).
-         * It does not set up an `EventDispatcher`.
-         * It does not run any `Component` lifecycle hooks (such as `didInsertElement`).
-         * It sets the `location` option to `"none"`. (If you would like to use
-          the location adapter specified in the app's router instead, you can also
-          specify `{ location: null }` to specifically opt-out.)
-         @property isBrowser
-        @type boolean
-        @default auto-detected
-        @public
-      */
 
       if (options.isBrowser !== undefined) {
         this.isBrowser = Boolean(options.isBrowser);
@@ -27535,17 +27531,6 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
         this.isInteractive = false;
         this.location = 'none';
       }
-      /**
-        Disable rendering completely.
-         When this flag is set to `false`, it will disable the entire rendering
-        pipeline. Essentially, this puts the app into "routing-only" mode. No
-        templates will be rendered, and no Components will be created.
-         @property shouldRender
-        @type boolean
-        @default true
-        @public
-      */
-
 
       if (options.shouldRender !== undefined) {
         this.shouldRender = Boolean(options.shouldRender);
@@ -27556,46 +27541,12 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
       if (!this.shouldRender) {
         this.isInteractive = false;
       }
-      /**
-        If present, render into the given `Document` object instead of the
-        global `window.document` object.
-         In practice, this is only useful in non-browser environment or in
-        non-interactive mode, because Ember's `jQuery` dependency is
-        implicitly bound to the current document, causing event delegation
-        to not work properly when the app is rendered into a foreign
-        document object (such as an iframe's `contentDocument`).
-         In non-browser mode, this could be a "`Document`-like" object as
-        Ember only interact with a small subset of the DOM API in non-
-        interactive mode. While the exact requirements have not yet been
-        formalized, the `SimpleDOM` library's implementation is known to
-        work.
-         @property document
-        @type Document
-        @default the global `document` object
-        @public
-      */
-
 
       if (options.document) {
         this.document = options.document;
       } else {
         this.document = typeof document !== 'undefined' ? document : null;
       }
-      /**
-        If present, overrides the application's `rootElement` property on
-        the instance. This is useful for testing environment, where you
-        might want to append the root view to a fixture area.
-         In non-browser mode, because Ember does not have access to jQuery,
-        this options must be specified as a DOM `Element` object instead of
-        a selector string.
-         See the documentation on `Application`'s `rootElement` for
-        details.
-         @property rootElement
-        @type String|Element
-        @default null
-        @public
-       */
-
 
       if (options.rootElement) {
         this.rootElement = options.rootElement;
@@ -27603,16 +27554,6 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
       // defaults from the "combo" options like `isBrowser` (although in
       // practice, the resulting combination is probably invalid)
 
-      /**
-        If present, overrides the router's `location` property with this
-        value. This is useful for environments where trying to modify the
-        URL would be inappropriate.
-         @property location
-        @type string
-        @default null
-        @public
-      */
-
 
       if (options.location !== undefined) {
         this.location = options.location;
@@ -27625,13 +27566,13 @@ define("@ember/application/instance", ["exports", "@ember/-internals/metal", "@e
 
     toEnvironment() {
       // Do we really want to assign all of this!?
-      var env = Object.assign({}, environment); // For compatibility with existing code
-
-      env.hasDOM = this.isBrowser;
-      env.isInteractive = this.isInteractive;
-      env._renderMode = this._renderMode;
-      env.options = this;
-      return env;
+      return Object.assign(Object.assign({}, environment), {
+        // For compatibility with existing code
+        hasDOM: this.isBrowser,
+        isInteractive: this.isInteractive,
+        _renderMode: this._renderMode,
+        options: this
+      });
     }
 
   }
@@ -27801,149 +27742,56 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
   
     @class Application
     @extends Engine
-    @uses RegistryProxyMixin
     @public
   */
-  var Application = _engine.default.extend({
-    /**
-      The root DOM element of the Application. This can be specified as an
-      element or a [selector string](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors#reference_table_of_selectors).
-       This is the element that will be passed to the Application's,
-      `eventDispatcher`, which sets up the listeners for event delegation. Every
-      view in your application should be a child of the element you specify here.
-       @property rootElement
-      @type DOMElement
-      @default 'body'
-      @public
-    */
-    rootElement: 'body',
-
+  class Application extends _engine.default {
+    constructor() {
+      super(...arguments);
+      this._bootPromise = null;
+      this._bootResolver = null;
+    }
     /**
-       @property _document
-      @type Document | null
-      @default 'window.document'
+      This creates a registry with the default Ember naming conventions.
+         It also configures the registry:
+         * registered views are created every time they are looked up (they are
+        not singletons)
+      * registered templates are not factories; the registered value is
+        returned directly.
+      * the router receives the application as its `namespace` property
+      * all controllers receive the router as their `target` and `controllers`
+        properties
+      * all controllers receive the application as their `namespace` property
+      * the application view receives the application controller as its
+        `controller` property
+      * the application view receives the application template as its
+        `defaultTemplate` property
+         @method buildRegistry
+      @static
+      @param {Application} namespace the application for which to
+        build the registry
+      @return {Ember.Registry} the built registry
       @private
     */
-    _document: _browserEnvironment.hasDOM ? window.document : null,
-
-    /**
-      The `Ember.EventDispatcher` responsible for delegating events to this
-      application's views.
-       The event dispatcher is created by the application at initialization time
-      and sets up event listeners on the DOM element described by the
-      application's `rootElement` property.
-       See the documentation for `Ember.EventDispatcher` for more information.
-       @property eventDispatcher
-      @type Ember.EventDispatcher
-      @default null
-      @public
-    */
-    eventDispatcher: null,
-
-    /**
-      The DOM events for which the event dispatcher should listen.
-       By default, the application's `Ember.EventDispatcher` listens
-      for a set of standard DOM events, such as `mousedown` and
-      `keyup`, and delegates them to your application's `Ember.View`
-      instances.
-       If you would like additional bubbling events to be delegated to your
-      views, set your `Application`'s `customEvents` property
-      to a hash containing the DOM event name as the key and the
-      corresponding view method name as the value. Setting an event to
-      a value of `null` will prevent a default event listener from being
-      added for that event.
-       To add new events to be listened to:
-       ```app/app.js
-      import Application from '@ember/application';
-       let App = Application.extend({
-        customEvents: {
-          // add support for the paste event
-          paste: 'paste'
-        }
-      });
-      ```
-       To prevent default events from being listened to:
-       ```app/app.js
-      import Application from '@ember/application';
-       let App = Application.extend({
-        customEvents: {
-          // remove support for mouseenter / mouseleave events
-          mouseenter: null,
-          mouseleave: null
-        }
-      });
-      ```
-      @property customEvents
-      @type Object
-      @default null
-      @public
-    */
-    customEvents: null,
 
-    /**
-      Whether the application should automatically start routing and render
-      templates to the `rootElement` on DOM ready. While default by true,
-      other environments such as FastBoot or a testing harness can set this
-      property to `false` and control the precise timing and behavior of the boot
-      process.
-       @property autoboot
-      @type Boolean
-      @default true
-      @private
-    */
-    autoboot: true,
 
-    /**
-      Whether the application should be configured for the legacy "globals mode".
-      Under this mode, the Application object serves as a global namespace for all
-      classes.
-       ```javascript
-      import Application from '@ember/application';
-      import Component from '@ember/component';
-       let App = Application.create({
-        ...
-      });
-       App.Router.reopen({
-        location: 'none'
-      });
-       App.Router.map({
-        ...
-      });
-       App.MyComponent = Component.extend({
-        ...
-      });
-      ```
-       This flag also exposes other internal APIs that assumes the existence of
-      a special "default instance", like `App.__container__.lookup(...)`.
-       This option is currently not configurable, its value is derived from
-      the `autoboot` flag – disabling `autoboot` also implies opting-out of
-      globals mode support, although they are ultimately orthogonal concerns.
-       Some of the global modes features are already deprecated in 1.x. The
-      existence of this flag is to untangle the globals mode code paths from
-      the autoboot code paths, so that these legacy features can be reviewed
-      for deprecation/removal separately.
-       Forcing the (autoboot=true, _globalsMode=false) here and running the tests
-      would reveal all the places where we are still relying on these legacy
-      behavior internally (mostly just tests).
-       @property _globalsMode
-      @type Boolean
-      @default true
-      @private
-    */
-    _globalsMode: true,
+    static buildRegistry(namespace) {
+      var registry = super.buildRegistry(namespace);
+      commonSetupRegistry(registry);
+      (0, _glimmer.setupApplicationRegistry)(registry);
+      return registry;
+    }
 
-    /**
-      An array of application instances created by `buildInstance()`. Used
-      internally to ensure that all instances get destroyed.
-       @property _applicationInstances
-      @type Array
-      @default null
-      @private
-    */
-    _applicationInstances: null,
+    init(properties) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
 
-    init() {
-      this._super(...arguments);
+      super.init(properties);
+      (_a = this.rootElement) !== null && _a !== void 0 ? _a : this.rootElement = 'body';
+      (_b = this._document) !== null && _b !== void 0 ? _b : this._document = null;
+      (_c = this.eventDispatcher) !== null && _c !== void 0 ? _c : this.eventDispatcher = null;
+      (_d = this.customEvents) !== null && _d !== void 0 ? _d : this.customEvents = null;
+      (_e = this.autoboot) !== null && _e !== void 0 ? _e : this.autoboot = true;
+      (_f = this._document) !== null && _f !== void 0 ? _f : this._document = _browserEnvironment.hasDOM ? window.document : null;
+      (_g = this._globalsMode) !== null && _g !== void 0 ? _g : this._globalsMode = true;
 
       if (true
       /* DEBUG */
@@ -27951,8 +27799,7 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
         if (_environment.ENV.LOG_VERSION) {
           // we only need to see this once per Application#init
           _environment.ENV.LOG_VERSION = false;
-
-          _metal.libraries.logVersions();
+          (_h = _metal.libraries.logVersions) === null || _h === void 0 ? void 0 : _h.call(_metal.libraries);
         }
       } // Start off the number of deferrals at 1. This will be decremented by
       // the Application's own `boot` method.
@@ -27970,14 +27817,15 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       if (this.autoboot) {
         this.waitForDOMReady();
       }
-    },
-
+    }
     /**
       Create an ApplicationInstance for this application.
-       @public
+         @public
       @method buildInstance
       @return {ApplicationInstance} the application instance
     */
+
+
     buildInstance(options) {
       if (options === void 0) {
         options = {};
@@ -27985,40 +27833,44 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot build new instances of this application since it has already been destroyed', !this.isDestroyed));
       (true && !(!this.isDestroying) && (0, _debug.assert)('You cannot build new instances of this application since it is being destroyed', !this.isDestroying));
-      options.base = this;
-      options.application = this;
-      return _instance.default.create(options);
-    },
-
+      return _instance.default.create(Object.assign(Object.assign({}, options), {
+        base: this,
+        application: this
+      }));
+    }
     /**
       Start tracking an ApplicationInstance for this application.
       Used when the ApplicationInstance is created.
-       @private
+         @private
       @method _watchInstance
     */
+
+
     _watchInstance(instance) {
       this._applicationInstances.add(instance);
-    },
-
+    }
     /**
       Stop tracking an ApplicationInstance for this application.
       Used when the ApplicationInstance is about to be destroyed.
-       @private
+         @private
       @method _unwatchInstance
     */
+
+
     _unwatchInstance(instance) {
       return this._applicationInstances.delete(instance);
-    },
-
+    }
     /**
       Enable the legacy globals mode by allowing this application to act
       as a global namespace. See the docs on the `_globalsMode` property
       for details.
-       Most of these features are already deprecated in 1.x, so we can
+         Most of these features are already deprecated in 1.x, so we can
       stop using them internally and try to remove them.
-       @private
+         @private
       @method _prepareForGlobalsMode
     */
+
+
     _prepareForGlobalsMode() {
       // Create subclass of Router for this Application instance.
       // This is to ensure that someone reopening `App.Router` does not
@@ -28026,20 +27878,21 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       this.Router = (this.Router || _routing.Router).extend();
 
       this._buildDeprecatedInstance();
-    },
-
+    }
     /*
       Build the deprecated instance for legacy globals mode support.
       Called when creating and resetting the application.
-       This is orthogonal to autoboot: the deprecated instance needs to
+         This is orthogonal to autoboot: the deprecated instance needs to
       be created at Application construction (not boot) time to expose
       App.__container__. If autoboot sees that this instance exists,
       it will continue booting it to avoid doing unncessary work (as
       opposed to building a new instance at boot time), but they are
       otherwise unrelated.
-       @private
+         @private
       @method _buildDeprecatedInstance
     */
+
+
     _buildDeprecatedInstance() {
       // Build a default instance
       var instance = this.buildInstance(); // Legacy support for App.__container__ and other global methods
@@ -28047,42 +27900,43 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
       this.__deprecatedInstance__ = instance;
       this.__container__ = instance.__container__;
-    },
-
+    }
     /**
       Automatically kick-off the boot process for the application once the
       DOM has become ready.
-       The initialization itself is scheduled on the actions queue which
+         The initialization itself is scheduled on the actions queue which
       ensures that code-loading finishes before booting.
-       If you are asynchronously loading code, you should call `deferReadiness()`
+         If you are asynchronously loading code, you should call `deferReadiness()`
       to defer booting, and then call `advanceReadiness()` once all of your code
       has finished loading.
-       @private
+         @private
       @method waitForDOMReady
     */
+
+
     waitForDOMReady() {
-      if (this._document === null || this._document.readyState !== 'loading') {
-        (0, _runloop.schedule)('actions', this, 'domReady');
+      var document = this._document;
+
+      if (document === null || document.readyState !== 'loading') {
+        (0, _runloop.schedule)('actions', this, this.domReady);
       } else {
         var callback = () => {
-          this._document.removeEventListener('DOMContentLoaded', callback);
-
-          (0, _runloop.run)(this, 'domReady');
+          document.removeEventListener('DOMContentLoaded', callback);
+          (0, _runloop.run)(this, this.domReady);
         };
 
-        this._document.addEventListener('DOMContentLoaded', callback);
+        document.addEventListener('DOMContentLoaded', callback);
       }
-    },
-
+    }
     /**
       This is the autoboot flow:
-       1. Boot the app by calling `this.boot()`
+         1. Boot the app by calling `this.boot()`
       2. Create an instance (or use the `__deprecatedInstance__` in globals mode)
       3. Boot the instance by calling `instance.boot()`
       4. Invoke the `App.ready()` callback
       5. Kick-off routing on the instance
-       Ideally, this is all we would need to do:
-       ```javascript
+         Ideally, this is all we would need to do:
+         ```javascript
       _autoBoot() {
         this.boot().then(() => {
           let instance = (this._globalsMode) ? this.__deprecatedInstance__ : this.buildInstance();
@@ -28093,16 +27947,18 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
         });
       }
       ```
-       Unfortunately, we cannot actually write this because we need to participate
+         Unfortunately, we cannot actually write this because we need to participate
       in the "synchronous" boot process. While the code above would work fine on
       the initial boot (i.e. DOM ready), when `App.reset()` is called, we need to
       boot a new instance synchronously (see the documentation on `_bootSync()`
       for details).
-       Because of this restriction, the actual logic of this method is located
+         Because of this restriction, the actual logic of this method is located
       inside `didBecomeReady()`.
-       @private
+         @private
       @method domReady
     */
+
+
     domReady() {
       if (this.isDestroying || this.isDestroyed) {
         return;
@@ -28110,45 +27966,47 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
       this._bootSync(); // Continues to `didBecomeReady`
 
-    },
-
+    }
     /**
       Use this to defer readiness until some condition is true.
-       Example:
-       ```javascript
+         Example:
+         ```javascript
       import Application from '@ember/application';
-       let App = Application.create();
-       App.deferReadiness();
-       fetch('/auth-token')
+         let App = Application.create();
+         App.deferReadiness();
+         fetch('/auth-token')
       .then(response => response.json())
       .then(data => {
         App.token = data.token;
         App.advanceReadiness();
       });
       ```
-       This allows you to perform asynchronous setup logic and defer
+         This allows you to perform asynchronous setup logic and defer
       booting your application until the setup has finished.
-       However, if the setup requires a loading UI, it might be better
+         However, if the setup requires a loading UI, it might be better
       to use the router for this purpose.
-       @method deferReadiness
+         @method deferReadiness
       @public
     */
+
+
     deferReadiness() {
       (true && !(this instanceof Application) && (0, _debug.assert)('You must call deferReadiness on an instance of Application', this instanceof Application));
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot defer readiness since application has already destroyed', !this.isDestroyed));
       (true && !(!this.isDestroying) && (0, _debug.assert)('You cannot defer readiness since the application is being destroyed', !this.isDestroying));
       (true && !(this._readinessDeferrals > 0) && (0, _debug.assert)('You cannot defer readiness since the `ready()` hook has already been called', this._readinessDeferrals > 0));
       this._readinessDeferrals++;
-    },
-
+    }
     /**
       Call `advanceReadiness` after any asynchronous setup logic has completed.
       Each call to `deferReadiness` must be matched by a call to `advanceReadiness`
       or the application will never become ready and routing will not begin.
-       @method advanceReadiness
+         @method advanceReadiness
       @see {Application#deferReadiness}
       @public
     */
+
+
     advanceReadiness() {
       (true && !(this instanceof Application) && (0, _debug.assert)('You must call advanceReadiness on an instance of Application', this instanceof Application));
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot advance readiness since application has already destroyed', !this.isDestroyed));
@@ -28159,21 +28017,22 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       if (this._readinessDeferrals === 0) {
         (0, _runloop.once)(this, this.didBecomeReady);
       }
-    },
-
+    }
     /**
       Initialize the application and return a promise that resolves with the `Application`
       object when the boot process is complete.
-       Run any application initializers and run the application load hook. These hooks may
+         Run any application initializers and run the application load hook. These hooks may
       choose to defer readiness. For example, an authentication hook might want to defer
       readiness until the auth token has been retrieved.
-       By default, this method is called automatically on "DOM ready"; however, if autoboot
+         By default, this method is called automatically on "DOM ready"; however, if autoboot
       is disabled, this is automatically called when the first application instance is
       created via `visit`.
-       @public
+         @public
       @method boot
       @return {Promise<Application,Error>}
     */
+
+
     boot() {
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot boot this application since it has already been destroyed', !this.isDestroyed));
       (true && !(!this.isDestroying) && (0, _debug.assert)('You cannot boot this application since it is being destroyed', !this.isDestroying));
@@ -28188,20 +28047,22 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
         // in the promise rejection
       }
 
+      (true && !(this._bootPromise) && (0, _debug.assert)('has boot promise', this._bootPromise));
       return this._bootPromise;
-    },
-
+    }
     /**
       Unfortunately, a lot of existing code assumes the booting process is
       "synchronous". Specifically, a lot of tests assumes the last call to
       `app.advanceReadiness()` or `app.reset()` will result in the app being
       fully-booted when the current runloop completes.
-       We would like new code (like the `visit` API) to stop making this assumption,
+         We would like new code (like the `visit` API) to stop making this assumption,
       so we created the asynchronous version above that returns a promise. But until
       we have migrated all the code, we would have to expose this method for use
       *internally* in places where we need to boot an app "synchronously".
-       @private
+         @private
     */
+
+
     _bootSync() {
       if (this._booted || this.isDestroying || this.isDestroyed) {
         return;
@@ -28225,45 +28086,44 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
         throw error;
       }
-    },
-
+    }
     /**
       Reset the application. This is typically used only in tests. It cleans up
       the application in the following order:
-       1. Deactivate existing routes
+         1. Deactivate existing routes
       2. Destroy all objects in the container
       3. Create a new application container
       4. Re-route to the existing url
-       Typical Example:
-       ```javascript
+         Typical Example:
+         ```javascript
       import Application from '@ember/application';
       let App;
-       run(function() {
+         run(function() {
         App = Application.create();
       });
-       module('acceptance test', {
+         module('acceptance test', {
         setup: function() {
           App.reset();
         }
       });
-       test('first test', function() {
+         test('first test', function() {
         // App is freshly reset
       });
-       test('second test', function() {
+         test('second test', function() {
         // App is again freshly reset
       });
       ```
-       Advanced Example:
-       Occasionally you may want to prevent the app from initializing during
+         Advanced Example:
+         Occasionally you may want to prevent the app from initializing during
       setup. This could enable extra configuration, or enable asserting prior
       to the app becoming ready.
-       ```javascript
+         ```javascript
       import Application from '@ember/application';
       let App;
-       run(function() {
+         run(function() {
         App = Application.create();
       });
-       module('acceptance test', {
+         module('acceptance test', {
         setup: function() {
           run(function() {
             App.reset();
@@ -28271,17 +28131,19 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
           });
         }
       });
-       test('first test', function() {
+         test('first test', function() {
         ok(true, 'something before app is initialized');
-         run(function() {
+           run(function() {
           App.advanceReadiness();
         });
-         ok(true, 'something after app is initialized');
+           ok(true, 'something after app is initialized');
       });
       ```
-       @method reset
+         @method reset
       @public
     */
+
+
     reset() {
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot reset this application since it has already been destroyed', !this.isDestroyed));
       (true && !(!this.isDestroying) && (0, _debug.assert)('You cannot reset this application since it is being destroyed', !this.isDestroying));
@@ -28296,6 +28158,7 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       this._booted = false;
 
       function handleReset() {
+        (true && !(instance) && (0, _debug.assert)('expected instance', instance));
         (0, _runloop.run)(instance, 'destroy');
 
         this._buildDeprecatedInstance();
@@ -28304,17 +28167,20 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       }
 
       (0, _runloop.join)(this, handleReset);
-    },
-
+    }
     /**
       @private
       @method didBecomeReady
     */
+
+
     didBecomeReady() {
       if (this.isDestroying || this.isDestroyed) {
         return;
       }
 
+      (true && !(this._bootResolver) && (0, _debug.assert)('expected _bootResolver', this._bootResolver));
+
       try {
         // TODO: Is this still needed for _globalsMode = false?
         // See documentation on `_autoboot()` for details
@@ -28325,6 +28191,7 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
             // If we already have the __deprecatedInstance__ lying around, boot it to
             // avoid unnecessary work
             instance = this.__deprecatedInstance__;
+            (true && !(instance) && (0, _debug.assert)('expected instance', instance));
           } else {
             // Otherwise, build an instance and boot it. This is currently unreachable,
             // because we forced _globalsMode to === autoboot; but having this branch
@@ -28352,24 +28219,25 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
         throw error;
       }
-    },
-
+    }
     /**
       Called when the Application has become ready, immediately before routing
       begins. The call will be delayed until the DOM has become ready.
-       @event ready
+         @event ready
       @public
     */
+
+
     ready() {
       return this;
-    },
+    } // This method must be moved to the application instance object
+
 
-    // This method must be moved to the application instance object
     willDestroy() {
-      this._super(...arguments);
+      super.willDestroy();
 
-      if (_lazy_load._loaded.application === this) {
-        _lazy_load._loaded.application = undefined;
+      if (_lazy_load._loaded['application'] === this) {
+        _lazy_load._loaded['application'] = undefined;
       }
 
       if (this._applicationInstances.size) {
@@ -28377,86 +28245,85 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
         this._applicationInstances.clear();
       }
-    },
-
+    }
     /**
       Boot a new instance of `ApplicationInstance` for the current
       application and navigate it to the given `url`. Returns a `Promise` that
       resolves with the instance when the initial routing and rendering is
       complete, or rejects with any error that occurred during the boot process.
-       When `autoboot` is disabled, calling `visit` would first cause the
+         When `autoboot` is disabled, calling `visit` would first cause the
       application to boot, which runs the application initializers.
-       This method also takes a hash of boot-time configuration options for
+         This method also takes a hash of boot-time configuration options for
       customizing the instance's behavior. See the documentation on
       `ApplicationInstance.BootOptions` for details.
-       `ApplicationInstance.BootOptions` is an interface class that exists
+         `ApplicationInstance.BootOptions` is an interface class that exists
       purely to document the available options; you do not need to construct it
       manually. Simply pass a regular JavaScript object containing of the
       desired options:
-       ```javascript
+         ```javascript
       MyApp.visit("/", { location: "none", rootElement: "#container" });
       ```
-       ### Supported Scenarios
-       While the `BootOptions` class exposes a large number of knobs, not all
+         ### Supported Scenarios
+         While the `BootOptions` class exposes a large number of knobs, not all
       combinations of them are valid; certain incompatible combinations might
       result in unexpected behavior.
-       For example, booting the instance in the full browser environment
+         For example, booting the instance in the full browser environment
       while specifying a foreign `document` object (e.g. `{ isBrowser: true,
       document: iframe.contentDocument }`) does not work correctly today,
       largely due to Ember's jQuery dependency.
-       Currently, there are three officially supported scenarios/configurations.
+         Currently, there are three officially supported scenarios/configurations.
       Usages outside of these scenarios are not guaranteed to work, but please
       feel free to file bug reports documenting your experience and any issues
       you encountered to help expand support.
-       #### Browser Applications (Manual Boot)
-       The setup is largely similar to how Ember works out-of-the-box. Normally,
+         #### Browser Applications (Manual Boot)
+         The setup is largely similar to how Ember works out-of-the-box. Normally,
       Ember will boot a default instance for your Application on "DOM ready".
       However, you can customize this behavior by disabling `autoboot`.
-       For example, this allows you to render a miniture demo of your application
+         For example, this allows you to render a miniture demo of your application
       into a specific area on your marketing website:
-       ```javascript
+         ```javascript
       import MyApp from 'my-app';
-       $(function() {
+         $(function() {
         let App = MyApp.create({ autoboot: false });
-         let options = {
+           let options = {
           // Override the router's location adapter to prevent it from updating
           // the URL in the address bar
           location: 'none',
-           // Override the default `rootElement` on the app to render into a
+             // Override the default `rootElement` on the app to render into a
           // specific `div` on the page
           rootElement: '#demo'
         };
-         // Start the app at the special demo URL
+           // Start the app at the special demo URL
         App.visit('/demo', options);
       });
       ```
-       Or perhaps you might want to boot two instances of your app on the same
+         Or perhaps you might want to boot two instances of your app on the same
       page for a split-screen multiplayer experience:
-       ```javascript
+         ```javascript
       import MyApp from 'my-app';
-       $(function() {
+         $(function() {
         let App = MyApp.create({ autoboot: false });
-         let sessionId = MyApp.generateSessionID();
-         let player1 = App.visit(`/matches/join?name=Player+1&session=${sessionId}`, { rootElement: '#left', location: 'none' });
+           let sessionId = MyApp.generateSessionID();
+           let player1 = App.visit(`/matches/join?name=Player+1&session=${sessionId}`, { rootElement: '#left', location: 'none' });
         let player2 = App.visit(`/matches/join?name=Player+2&session=${sessionId}`, { rootElement: '#right', location: 'none' });
-         Promise.all([player1, player2]).then(() => {
+           Promise.all([player1, player2]).then(() => {
           // Both apps have completed the initial render
           $('#loading').fadeOut();
         });
       });
       ```
-       Do note that each app instance maintains their own registry/container, so
+         Do note that each app instance maintains their own registry/container, so
       they will run in complete isolation by default.
-       #### Server-Side Rendering (also known as FastBoot)
-       This setup allows you to run your Ember app in a server environment using
+         #### Server-Side Rendering (also known as FastBoot)
+         This setup allows you to run your Ember app in a server environment using
       Node.js and render its content into static HTML for SEO purposes.
-       ```javascript
+         ```javascript
       const HTMLSerializer = new SimpleDOM.HTMLSerializer(SimpleDOM.voidMap);
-       function renderURL(url) {
+         function renderURL(url) {
         let dom = new SimpleDOM.Document();
         let rootElement = dom.body;
         let options = { isBrowser: false, document: dom, rootElement: rootElement };
-         return MyApp.visit(options).then(instance => {
+           return MyApp.visit(options).then(instance => {
           try {
             return HTMLSerializer.serialize(rootElement.firstChild);
           } finally {
@@ -28465,50 +28332,50 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
         });
       }
       ```
-       In this scenario, because Ember does not have access to a global `document`
+         In this scenario, because Ember does not have access to a global `document`
       object in the Node.js environment, you must provide one explicitly. In practice,
       in the non-browser environment, the stand-in `document` object only needs to
       implement a limited subset of the full DOM API. The `SimpleDOM` library is known
       to work.
-       Since there is no DOM access in the non-browser environment, you must also
+         Since there is no DOM access in the non-browser environment, you must also
       specify a DOM `Element` object in the same `document` for the `rootElement` option
       (as opposed to a selector string like `"body"`).
-       See the documentation on the `isBrowser`, `document` and `rootElement` properties
+         See the documentation on the `isBrowser`, `document` and `rootElement` properties
       on `ApplicationInstance.BootOptions` for details.
-       #### Server-Side Resource Discovery
-       This setup allows you to run the routing layer of your Ember app in a server
+         #### Server-Side Resource Discovery
+         This setup allows you to run the routing layer of your Ember app in a server
       environment using Node.js and completely disable rendering. This allows you
       to simulate and discover the resources (i.e. AJAX requests) needed to fulfill
       a given request and eagerly "push" these resources to the client.
-       ```app/initializers/network-service.js
+         ```app/initializers/network-service.js
       import BrowserNetworkService from 'app/services/network/browser';
       import NodeNetworkService from 'app/services/network/node';
-       // Inject a (hypothetical) service for abstracting all AJAX calls and use
+         // Inject a (hypothetical) service for abstracting all AJAX calls and use
       // the appropriate implementation on the client/server. This also allows the
       // server to log all the AJAX calls made during a particular request and use
       // that for resource-discovery purpose.
-       export function initialize(application) {
+         export function initialize(application) {
         if (window) { // browser
           application.register('service:network', BrowserNetworkService);
         } else { // node
           application.register('service:network', NodeNetworkService);
         }
       };
-       export default {
+         export default {
         name: 'network-service',
         initialize: initialize
       };
       ```
-       ```app/routes/post.js
+         ```app/routes/post.js
       import Route from '@ember/routing/route';
       import { service } from '@ember/service';
-       // An example of how the (hypothetical) service is used in routes.
-       export default class IndexRoute extends Route {
+         // An example of how the (hypothetical) service is used in routes.
+         export default class IndexRoute extends Route {
         @service network;
-         model(params) {
+           model(params) {
           return this.network.fetch(`/api/posts/${params.post_id}.json`);
         }
-         afterModel(post) {
+           afterModel(post) {
           if (post.isExternalContent) {
             return this.network.fetch(`/api/external/?url=${post.externalURL}`);
           } else {
@@ -28517,21 +28384,23 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
         }
       }
       ```
-       ```javascript
+         ```javascript
       // Finally, put all the pieces together
-       function discoverResourcesFor(url) {
+         function discoverResourcesFor(url) {
         return MyApp.visit(url, { isBrowser: false, shouldRender: false }).then(instance => {
           let networkService = instance.lookup('service:network');
           return networkService.requests; // => { "/api/posts/123.json": "..." }
         });
       }
       ```
-       @public
+         @public
       @method visit
       @param url {String} The initial URL to navigate to
       @param options {ApplicationInstance.BootOptions}
       @return {Promise<ApplicationInstance, Error>}
     */
+
+
     visit(url, options) {
       (true && !(!this.isDestroyed) && (0, _debug.assert)('You cannot visit this application since it has already been destroyed', !this.isDestroyed));
       (true && !(!this.isDestroying) && (0, _debug.assert)('You cannot visit this application since it is being destroyed', !this.isDestroying));
@@ -28544,40 +28413,7 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
       });
     }
 
-  });
-
-  Application.reopenClass({
-    /**
-      This creates a registry with the default Ember naming conventions.
-       It also configures the registry:
-       * registered views are created every time they are looked up (they are
-        not singletons)
-      * registered templates are not factories; the registered value is
-        returned directly.
-      * the router receives the application as its `namespace` property
-      * all controllers receive the router as their `target` and `controllers`
-        properties
-      * all controllers receive the application as their `namespace` property
-      * the application view receives the application controller as its
-        `controller` property
-      * the application view receives the application template as its
-        `defaultTemplate` property
-       @method buildRegistry
-      @static
-      @param {Application} namespace the application for which to
-        build the registry
-      @return {Ember.Registry} the built registry
-      @private
-    */
-    buildRegistry() {
-      var registry = this._super(...arguments);
-
-      commonSetupRegistry(registry);
-      (0, _glimmer.setupApplicationRegistry)(registry);
-      return registry;
-    }
-
-  });
+  }
 
   function commonSetupRegistry(registry) {
     registry.register('router:main', _routing.Router);
@@ -28649,9 +28485,11 @@ define("@ember/application/lib/lazy_load", ["exports", "@ember/-internals/enviro
   _exports._loaded = _loaded;
 
   function onLoad(name, callback) {
+    var _a;
+
     var object = loaded[name];
-    loadHooks[name] = loadHooks[name] || [];
-    loadHooks[name].push(callback);
+    var hooks = (_a = loadHooks[name]) !== null && _a !== void 0 ? _a : loadHooks[name] = [];
+    hooks.push(callback);
 
     if (object) {
       callback(object);
@@ -28671,20 +28509,19 @@ define("@ember/application/lib/lazy_load", ["exports", "@ember/-internals/enviro
 
 
   function runLoadHooks(name, object) {
+    var _a;
+
     loaded[name] = object;
 
     if (_browserEnvironment.window && typeof CustomEvent === 'function') {
       var event = new CustomEvent(name, {
-        detail: object,
-        name
+        detail: object
       });
 
       _browserEnvironment.window.dispatchEvent(event);
     }
 
-    if (loadHooks[name]) {
-      loadHooks[name].forEach(callback => callback(object));
-    }
+    (_a = loadHooks[name]) === null || _a === void 0 ? void 0 : _a.forEach(callback => callback(object));
   }
 });
 define("@ember/application/namespace", ["exports", "@ember/-internals/runtime"], function (_exports, _runtime) {
@@ -30070,7 +29907,7 @@ define("@ember/destroyable/index", ["exports", "@glimmer/destroyable"], function
     return (0, _destroyable.unregisterDestructor)(destroyable, destructor);
   }
 });
-define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@ember/-internals/utils", "@ember/controller", "@ember/-internals/runtime", "@ember/-internals/container", "dag-map", "@ember/debug", "@ember/-internals/metal", "@ember/engine/instance", "@ember/-internals/routing", "@ember/-internals/extension-support", "@ember/-internals/views", "@ember/-internals/glimmer"], function (_exports, _engineParent, _utils, _controller, _runtime, _container, _dagMap, _debug, _metal, _instance, _routing, _extensionSupport, _views, _glimmer) {
+define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@ember/-internals/utils", "@ember/controller", "@ember/-internals/runtime", "@ember/-internals/container", "dag-map", "@ember/debug", "@ember/-internals/metal", "@ember/engine/instance", "@ember/-internals/routing", "@ember/-internals/extension-support", "@ember/-internals/views", "@ember/-internals/glimmer", "@ember/-internals/runtime/lib/mixins/registry_proxy"], function (_exports, _engineParent, _utils, _controller, _runtime, _container, _dagMap, _debug, _metal, _instance, _routing, _extensionSupport, _views, _glimmer, _registry_proxy) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -30099,119 +29936,145 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
 
     return properties;
   }
-  /**
-  @module @ember/engine
-  */
-
-  /**
-    The `Engine` class contains core functionality for both applications and
-    engines.
-  
-    Each engine manages a registry that's used for dependency injection and
-    exposed through `RegistryProxy`.
-  
-    Engines also manage initializers and instance initializers.
-  
-    Engines can spawn `EngineInstance` instances via `buildInstance()`.
-  
-    @class Engine
-    @extends Ember.Namespace
-    @uses RegistryProxy
-    @public
-  */
 
+  class Engine extends _runtime.Namespace.extend(_registry_proxy.default) {
+    constructor() {
+      super(...arguments);
+      /**
+        A private flag indicating whether an engine's initializers have run yet.
+               @private
+        @property _initializersRan
+      */
 
-  var Engine = _runtime.Namespace.extend(_runtime.RegistryProxyMixin, {
-    init() {
-      this._super(...arguments);
-
-      this.buildRegistry();
-    },
-
+      this._initializersRan = false;
+    }
     /**
-      A private flag indicating whether an engine's initializers have run yet.
-       @private
-      @property _initializersRan
+      This creates a registry with the default Ember naming conventions.
+         It also configures the registry:
+         * registered views are created every time they are looked up (they are
+        not singletons)
+      * registered templates are not factories; the registered value is
+        returned directly.
+      * the router receives the application as its `namespace` property
+      * all controllers receive the router as their `target` and `controllers`
+        properties
+      * all controllers receive the application as their `namespace` property
+      * the application view receives the application controller as its
+        `controller` property
+      * the application view receives the application template as its
+        `defaultTemplate` property
+         @method buildRegistry
+      @static
+      @param {Application} namespace the application for which to
+        build the registry
+      @return {Ember.Registry} the built registry
+      @private
     */
-    _initializersRan: false,
 
+
+    static buildRegistry(namespace) {
+      var registry = new _container.Registry({
+        resolver: resolverFor(namespace)
+      });
+      registry.set = _metal.set;
+      registry.register('application:main', namespace, {
+        instantiate: false
+      });
+      commonSetupRegistry(registry);
+      (0, _glimmer.setupEngineRegistry)(registry);
+      return registry;
+    }
+
+    init(properties) {
+      super.init(properties);
+      this.buildRegistry();
+    }
     /**
       Ensure that initializers are run once, and only once, per engine.
-       @private
+         @private
       @method ensureInitializers
     */
+
+
     ensureInitializers() {
       if (!this._initializersRan) {
         this.runInitializers();
         this._initializersRan = true;
       }
-    },
-
+    }
     /**
       Create an EngineInstance for this engine.
-       @public
+         @public
       @method buildInstance
       @return {EngineInstance} the engine instance
     */
+
+
     buildInstance(options) {
       if (options === void 0) {
         options = {};
       }
 
       this.ensureInitializers();
-      options.base = this;
-      return _instance.default.create(options);
-    },
-
+      return _instance.default.create(Object.assign(Object.assign({}, options), {
+        base: this
+      }));
+    }
     /**
       Build and configure the registry for the current engine.
-       @private
+         @private
       @method buildRegistry
       @return {Ember.Registry} the configured registry
     */
+
+
     buildRegistry() {
       var registry = this.__registry__ = this.constructor.buildRegistry(this);
       return registry;
-    },
-
+    }
     /**
       @private
       @method initializer
     */
-    initializer(options) {
-      this.constructor.initializer(options);
-    },
 
+
+    initializer(initializer) {
+      this.constructor.initializer(initializer);
+    }
     /**
       @private
       @method instanceInitializer
     */
-    instanceInitializer(options) {
-      this.constructor.instanceInitializer(options);
-    },
 
+
+    instanceInitializer(initializer) {
+      this.constructor.instanceInitializer(initializer);
+    }
     /**
       @private
       @method runInitializers
     */
+
+
     runInitializers() {
       this._runInitializer('initializers', (name, initializer) => {
-        (true && !(Boolean(initializer)) && (0, _debug.assert)(`No application initializer named '${name}'`, Boolean(initializer)));
+        (true && !(initializer) && (0, _debug.assert)(`No application initializer named '${name}'`, initializer));
         initializer.initialize(this);
       });
-    },
-
+    }
     /**
       @private
       @since 1.12.0
       @method runInstanceInitializers
     */
+
+
     runInstanceInitializers(instance) {
       this._runInitializer('instanceInitializers', (name, initializer) => {
-        (true && !(Boolean(initializer)) && (0, _debug.assert)(`No instance initializer named '${name}'`, Boolean(initializer)));
+        (true && !(initializer) && (0, _debug.assert)(`No instance initializer named '${name}'`, initializer));
         initializer.initialize(instance);
       });
-    },
+    }
 
     _runInitializer(bucketName, cb) {
       var initializersByName = (0, _metal.get)(this.constructor, bucketName);
@@ -30219,233 +30082,238 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
       var graph = new _dagMap.default();
       var initializer;
 
-      for (var i = 0; i < initializers.length; i++) {
-        initializer = initializersByName[initializers[i]];
+      for (var name of initializers) {
+        initializer = initializersByName[name];
+        (true && !(initializer) && (0, _debug.assert)(`missing ${bucketName}: ${name}`, initializer));
         graph.add(initializer.name, initializer, initializer.before, initializer.after);
       }
 
       graph.topsort(cb);
     }
 
-  });
-
-  Engine.reopenClass({
-    initializers: Object.create(null),
-    instanceInitializers: Object.create(null),
-
-    /**
-      The goal of initializers should be to register dependencies and injections.
-      This phase runs once. Because these initializers may load code, they are
-      allowed to defer application readiness and advance it. If you need to access
-      the container or store you should use an InstanceInitializer that will be run
-      after all initializers and therefore after all code is loaded and the app is
-      ready.
-       Initializer receives an object which has the following attributes:
-      `name`, `before`, `after`, `initialize`. The only required attribute is
-      `initialize`, all others are optional.
-       * `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.
-       ```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`:
-       ```app/initializer/first.js
-      import { debug } from '@ember/debug';
-       export function initialize() {
-        debug('First initializer!');
-      }
-       export default {
-        name: 'first',
-        initialize
-      };
-      ```
-       ```bash
-      // DEBUG: First initializer!
-      ```
-       We add another initializer named `second`, specifying that it should run
-      after the initializer named `first`:
-       ```app/initializer/second.js
-      import { debug } from '@ember/debug';
-       export function initialize() {
-        debug('Second initializer!');
-      }
-       export default {
-        name: 'second',
-        after: 'first',
-        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`:
-       ```app/initializer/pre.js
-      import { debug } from '@ember/debug';
-       export function initialize() {
-        debug('Pre initializer!');
-      }
-       export default {
-        name: 'pre',
-        before: 'first',
-        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:
-       ```app/initializer/post.js
-      import { debug } from '@ember/debug';
-       export function initialize() {
-        debug('Post initializer!');
-      }
-       export default {
-        name: 'post',
-        after: ['first', 'second'],
-        initialize
-      };
-      ```
-       ```bash
-      // DEBUG: Pre initializer!
-      // DEBUG: First initializer!
-      // DEBUG: Second initializer!
-      // DEBUG: Post initializer!
-      ```
-       * `initialize` is a callback function that receives one argument,
-        `application`, on which you can operate.
-       Example of using `application` to register an adapter:
-       ```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}
-      @public
-    */
-    initializer: buildInitializerMethod('initializers', 'initializer'),
+  }
 
-    /**
-      Instance initializers run after all initializers have run. Because
-      instance initializers run after the app is fully set up. We have access
-      to the store, container, and other items. However, these initializers run
-      after code has loaded and are not allowed to defer readiness.
-       Instance initializer receives an object which has the following attributes:
-      `name`, `before`, `after`, `initialize`. The only required attribute is
-      `initialize`, all others are optional.
-       * `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.
-       ```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
-      or an array of strings, referencing the `name` of other initializers.
-       * See Application.initializer for discussion on the usage of before
-      and after.
-       Example instanceInitializer to preload data into the store.
-       ```app/initializer/preload-data.js
-       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
-          // index.html file. This allows the app to have access to a set of data
-          // without making any additional remote calls. Good for basic data that is
-          // 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 = document.querySelector('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
-          store = application.lookup('service:store');
-           // Push the encoded JSON into the store
-          store.pushPayload(userConfig);
-      }
-       export default {
-        name: 'named-instance-initializer',
-        initialize
-      };
-      ```
-       @method instanceInitializer
-      @param instanceInitializer
-      @public
-    */
-    instanceInitializer: buildInitializerMethod('instanceInitializers', 'instance initializer'),
+  Engine.initializers = Object.create(null);
+  Engine.instanceInitializers = Object.create(null);
+  /**
+    The goal of initializers should be to register dependencies and injections.
+    This phase runs once. Because these initializers may load code, they are
+    allowed to defer application readiness and advance it. If you need to access
+    the container or store you should use an InstanceInitializer that will be run
+    after all initializers and therefore after all code is loaded and the app is
+    ready.
+  
+    Initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+  
+    * `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.
+  
+    ```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`:
+  
+    ```app/initializer/first.js
+    import { debug } from '@ember/debug';
+  
+    export function initialize() {
+      debug('First initializer!');
+    }
+  
+    export default {
+      name: 'first',
+      initialize
+    };
+    ```
+  
+    ```bash
+    // DEBUG: First initializer!
+    ```
+  
+    We add another initializer named `second`, specifying that it should run
+    after the initializer named `first`:
+  
+    ```app/initializer/second.js
+    import { debug } from '@ember/debug';
+  
+    export function initialize() {
+      debug('Second initializer!');
+    }
+  
+    export default {
+      name: 'second',
+      after: 'first',
+      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`:
+  
+    ```app/initializer/pre.js
+    import { debug } from '@ember/debug';
+  
+    export function initialize() {
+      debug('Pre initializer!');
+    }
+  
+    export default {
+      name: 'pre',
+      before: 'first',
+      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:
+  
+    ```app/initializer/post.js
+    import { debug } from '@ember/debug';
+  
+    export function initialize() {
+      debug('Post initializer!');
+    }
+  
+    export default {
+      name: 'post',
+      after: ['first', 'second'],
+      initialize
+    };
+    ```
+  
+    ```bash
+    // DEBUG: Pre initializer!
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    // DEBUG: Post initializer!
+    ```
+  
+    * `initialize` is a callback function that receives one argument,
+      `application`, on which you can operate.
+  
+    Example of using `application` to register an adapter:
+  
+    ```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}
+    @public
+  */
 
-    /**
-      This creates a registry with the default Ember naming conventions.
-       It also configures the registry:
-       * registered views are created every time they are looked up (they are
-        not singletons)
-      * registered templates are not factories; the registered value is
-        returned directly.
-      * the router receives the application as its `namespace` property
-      * all controllers receive the router as their `target` and `controllers`
-        properties
-      * all controllers receive the application as their `namespace` property
-      * the application view receives the application controller as its
-        `controller` property
-      * the application view receives the application template as its
-        `defaultTemplate` property
-       @method buildRegistry
-      @static
-      @param {Application} namespace the application for which to
-        build the registry
-      @return {Ember.Registry} the built registry
-      @private
-    */
-    buildRegistry(namespace) {
-      var registry = new _container.Registry({
-        resolver: resolverFor(namespace)
-      });
-      registry.set = _metal.set;
-      registry.register('application:main', namespace, {
-        instantiate: false
-      });
-      commonSetupRegistry(registry);
-      (0, _glimmer.setupEngineRegistry)(registry);
-      return registry;
-    },
+  Engine.initializer = buildInitializerMethod('initializers', 'initializer');
+  /**
+    Instance initializers run after all initializers have run. Because
+    instance initializers run after the app is fully set up. We have access
+    to the store, container, and other items. However, these initializers run
+    after code has loaded and are not allowed to defer readiness.
+  
+    Instance initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+  
+    * `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.
+  
+    ```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
+    or an array of strings, referencing the `name` of other initializers.
+  
+    * See Application.initializer for discussion on the usage of before
+    and after.
+  
+    Example instanceInitializer to preload data into the store.
+  
+    ```app/initializer/preload-data.js
+  
+    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
+        // index.html file. This allows the app to have access to a set of data
+        // without making any additional remote calls. Good for basic data that is
+        // 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 = document.querySelector('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
+        store = application.lookup('service:store');
+  
+        // Push the encoded JSON into the store
+        store.pushPayload(userConfig);
+    }
+  
+    export default {
+      name: 'named-instance-initializer',
+      initialize
+    };
+    ```
+  
+    @method instanceInitializer
+    @param instanceInitializer
+    @public
+  */
 
-    /**
-      Set this to provide an alternate class to `DefaultResolver`
-       @property resolver
-      @public
-    */
-    Resolver: null
-  });
+  Engine.instanceInitializer = buildInitializerMethod('instanceInitializers', 'instance initializer');
   /**
     This function defines the default lookup rules for container lookups:
   
@@ -30459,12 +30327,12 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
   
     @private
     @method resolverFor
-    @param {Ember.Namespace} namespace the namespace to look for classes
+    @param {Ember.Enginer} namespace the namespace to look for classes
     @return {*} the resolved value for a given lookup
   */
 
   function resolverFor(namespace) {
-    var ResolverClass = (0, _metal.get)(namespace, 'Resolver');
+    var ResolverClass = namespace.Resolver;
     var props = {
       namespace
     };
@@ -30477,16 +30345,21 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
       // to make sure we have a new `initializers` object, which extends from the parent class' using
       // prototypal inheritance. Without this, attempting to add initializers to the subclass would
       // pollute the parent class as well as other subclasses.
-      if (this.superclass[bucketName] !== undefined && this.superclass[bucketName] === this[bucketName]) {
-        var attrs = {};
-        attrs[bucketName] = Object.create(this[bucketName]);
+      // SAFETY: The superclass may be an Engine, we don't call unless we confirmed it was ok.
+      var superclass = this.superclass;
+
+      if (superclass[bucketName] !== undefined && superclass[bucketName] === this[bucketName]) {
+        var attrs = {
+          [bucketName]: Object.create(this[bucketName])
+        };
         this.reopenClass(attrs);
       }
 
       (true && !(!this[bucketName][initializer.name]) && (0, _debug.assert)(`The ${humanName} '${initializer.name}' has already been registered`, !this[bucketName][initializer.name]));
       (true && !((0, _utils.canInvoke)(initializer, 'initialize')) && (0, _debug.assert)(`An ${humanName} cannot be registered without an initialize function`, (0, _utils.canInvoke)(initializer, 'initialize')));
       (true && !(initializer.name !== undefined) && (0, _debug.assert)(`An ${humanName} cannot be registered without a name property`, initializer.name !== undefined));
-      this[bucketName][initializer.name] = initializer;
+      var initializers = this[bucketName];
+      initializers[initializer.name] = initializer;
     };
   }
 
@@ -30513,7 +30386,7 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
   var _default = Engine;
   _exports.default = _default;
 });
-define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@ember/debug", "@ember/error", "@ember/-internals/container", "@ember/-internals/utils", "@ember/engine/lib/engine-parent"], function (_exports, _runtime, _debug, _error, _container, _utils, _engineParent) {
+define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@ember/debug", "@ember/error", "@ember/-internals/container", "@ember/-internals/utils", "@ember/engine/lib/engine-parent", "@ember/-internals/runtime/lib/mixins/registry_proxy", "@ember/-internals/runtime/lib/mixins/container_proxy", "@ember/-internals/owner", "@ember/engine"], function (_exports, _runtime, _debug, _error, _container, _utils, _engineParent, _registry_proxy, _container_proxy, _owner, _engine) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -30524,80 +30397,78 @@ define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@embe
   /**
   @module @ember/engine
   */
+  var CEngine = _engine.default;
 
-  /**
-    The `EngineInstance` encapsulates all of the stateful aspects of a
-    running `Engine`.
-  
-    @public
-    @class EngineInstance
-    @extends EmberObject
-    @uses RegistryProxyMixin
-    @uses ContainerProxyMixin
-  */
-  var EngineInstance = _runtime.Object.extend(_runtime.RegistryProxyMixin, _runtime.ContainerProxyMixin, {
+  class EngineInstance extends _runtime.Object.extend(_registry_proxy.default, _container_proxy.default) {
+    constructor() {
+      super(...arguments);
+      this._booted = false;
+      this._bootPromise = null;
+    }
     /**
-      The base `Engine` for which this is an instance.
-       @property {Engine} engine
-      @private
-    */
-    base: null,
+     @private
+     @method setupRegistry
+     @param {Registry} registry
+     @param {BootOptions} options
+     */
 
-    init() {
-      this._super(...arguments); // Ensure the guid gets setup for this instance
 
+    static setupRegistry(_registry, _options) {}
 
-      (0, _utils.guidFor)(this);
-      var base = this.base;
+    init(properties) {
+      var _a;
 
-      if (!base) {
-        base = this.application;
-        this.base = base;
-      } // Create a per-instance registry that will use the application's registry
-      // as a fallback for resolving registrations.
+      super.init(properties); // Ensure the guid gets setup for this instance
 
+      (0, _utils.guidFor)(this);
+      (_a = this.base) !== null && _a !== void 0 ? _a : this.base = this.application; // Create a per-instance registry that will use the application's registry
+      // as a fallback for resolving registrations.
 
       var registry = this.__registry__ = new _container.Registry({
-        fallback: base.__registry__
+        fallback: this.base.__registry__
       }); // Create a per-instance container from the instance's registry
 
       this.__container__ = registry.container({
         owner: this
       });
       this._booted = false;
-    },
-
+    }
     /**
       Initialize the `EngineInstance` and return a promise that resolves
       with the instance itself when the boot process is complete.
-       The primary task here is to run any registered instance initializers.
-       See the documentation on `BootOptions` for the options it takes.
-       @public
+         The primary task here is to run any registered instance initializers.
+         See the documentation on `BootOptions` for the options it takes.
+         @public
       @method boot
       @param options {Object}
       @return {Promise<EngineInstance,Error>}
     */
+
+
     boot(options) {
       if (this._bootPromise) {
         return this._bootPromise;
       }
 
-      this._bootPromise = new _runtime.RSVP.Promise(resolve => resolve(this._bootSync(options)));
+      this._bootPromise = new _runtime.RSVP.Promise(resolve => {
+        resolve(this._bootSync(options));
+      });
       return this._bootPromise;
-    },
-
+    }
     /**
       Unfortunately, a lot of existing code assumes booting an instance is
       synchronous – specifically, a lot of tests assume the last call to
       `app.advanceReadiness()` or `app.reset()` will result in a new instance
       being fully-booted when the current runloop completes.
-       We would like new code (like the `visit` API) to stop making this
+         We would like new code (like the `visit` API) to stop making this
       assumption, so we created the asynchronous version above that returns a
       promise. But until we have migrated all the code, we would have to expose
       this method for use *internally* in places where we need to boot an instance
       synchronously.
-       @private
+         @private
     */
+
+
     _bootSync(options) {
       if (this._booted) {
         return this;
@@ -30609,7 +30480,7 @@ define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@embe
       this.base.runInstanceInitializers(this);
       this._booted = true;
       return this;
-    },
+    }
 
     setupRegistry(options) {
       if (options === void 0) {
@@ -30617,32 +30488,35 @@ define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@embe
       }
 
       this.constructor.setupRegistry(this.__registry__, options);
-    },
-
+    }
     /**
      Unregister a factory.
-      Overrides `RegistryProxy#unregister` in order to clear any cached instances
+        Overrides `RegistryProxy#unregister` in order to clear any cached instances
      of the unregistered factory.
-      @public
+        @public
      @method unregister
      @param {String} fullName
      */
+
+
     unregister(fullName) {
-      this.__container__.reset(fullName);
+      this.__container__.reset(fullName); // We overwrote this method from RegistryProxyMixin.
 
-      this._super(...arguments);
-    },
 
+      this.__registry__.unregister(fullName);
+    }
     /**
       Build a new `EngineInstance` that's a child of this instance.
-       Engines must be registered by name with their parent engine
+         Engines must be registered by name with their parent engine
       (or application).
-       @private
+         @private
       @method buildChildEngineInstance
       @param name {String} the registered name of the engine.
       @param options {Object} options provided to the engine instance.
       @return {EngineInstance,Error}
     */
+
+
     buildChildEngineInstance(name, options) {
       if (options === void 0) {
         options = {};
@@ -30654,52 +30528,48 @@ define("@ember/engine/instance", ["exports", "@ember/-internals/runtime", "@embe
         throw new _error.default(`You attempted to mount the engine '${name}', but it is not registered with its parent.`);
       }
 
+      (true && !(Engine instanceof CEngine) && (0, _debug.assert)('expected an Engine', Engine instanceof CEngine));
       var engineInstance = Engine.buildInstance(options);
       (0, _engineParent.setEngineParent)(engineInstance, this);
       return engineInstance;
-    },
-
+    }
     /**
       Clone dependencies shared between an engine instance and its parent.
-       @private
+         @private
       @method cloneParentDependencies
     */
+
+
     cloneParentDependencies() {
       var parent = (0, _engineParent.getEngineParent)(this);
+      (true && !(parent) && (0, _debug.assert)('expected parent', parent));
       var registrations = ['route:basic', 'service:-routing'];
-      registrations.forEach(key => this.register(key, parent.resolveRegistration(key)));
+      registrations.forEach(key => {
+        var registration = parent.resolveRegistration(key);
+        (true && !((0, _owner.isFactory)(registration)) && (0, _debug.assert)('expected registration to be a factory', (0, _owner.isFactory)(registration)));
+        this.register(key, registration);
+      });
       var env = parent.lookup('-environment:main');
       this.register('-environment:main', env, {
         instantiate: false
       });
       var singletons = ['router:main', (0, _container.privatize)`-bucket-cache:main`, '-view-registry:main', `renderer:-dom`, 'service:-document'];
 
-      if (env.isInteractive) {
+      if (env['isInteractive']) {
         singletons.push('event_dispatcher:main');
       }
 
-      singletons.forEach(key => this.register(key, parent.lookup(key), {
-        instantiate: false
-      }));
+      singletons.forEach(key => {
+        // SAFETY: We already expect this to be a singleton
+        var singleton = parent.lookup(key);
+        this.register(key, singleton, {
+          instantiate: false
+        });
+      });
     }
 
-  });
-
-  EngineInstance.reopenClass({
-    /**
-     @private
-     @method setupRegistry
-     @param {Registry} registry
-     @param {BootOptions} options
-     */
-    setupRegistry(registry, options) {
-      // when no options/environment is present, do nothing
-      if (!options) {
-        return;
-      }
-    }
+  }
 
-  });
   var _default = EngineInstance;
   _exports.default = _default;
 });
@@ -54762,7 +54632,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.4.0-alpha.7";
+  var _default = "4.5.0-alpha.2";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {