ember-source 4.4.0-alpha.2 → 4.4.0-alpha.5

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.2
+ * @version   4.4.0-alpha.5
  */
 /* eslint-disable no-var */
 
@@ -704,22 +704,6 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
     container(options) {
       return new Container(this, options);
     }
-    /**
-     Registers a factory for later injection.
-        Example:
-        ```javascript
-     let registry = new Registry();
-        registry.register('model:user', Person, {singleton: false });
-     registry.register('fruit:favorite', Orange);
-     registry.register('communication:main', Email, {singleton: false});
-     ```
-        @private
-     @method register
-     @param {String} fullName
-     @param {Function} factory
-     @param {Object} options
-     */
-
 
     register(fullName, factory, options) {
       if (options === void 0) {
@@ -1497,23 +1481,11 @@ define("@ember/-internals/extension-support/lib/container_debug_adapter", ["expo
     @since 1.5.0
     @public
   */
-  var _default = _runtime.Object.extend({
-    init() {
-      this._super(...arguments);
-
+  class ContainerDebugAdapter extends _runtime.Object {
+    constructor(owner) {
+      super(owner);
       this.resolver = (0, _owner.getOwner)(this).lookup('resolver-for-debugging:main');
-    },
-
-    /**
-      The resolver instance of the application
-      being debugged. This property will be injected
-      on creation.
-         @property resolver
-      @default null
-      @public
-    */
-    resolver: null,
-
+    }
     /**
       Returns true if it is possible to catalog a list of available
       classes in the resolver for a given type.
@@ -1522,14 +1494,15 @@ define("@ember/-internals/extension-support/lib/container_debug_adapter", ["expo
       @return {boolean} whether a list is available for this type.
       @public
     */
+
+
     canCatalogEntriesByType(type) {
       if (type === 'model' || type === 'template') {
         return false;
       }
 
       return true;
-    },
-
+    }
     /**
       Returns the available classes a given type.
          @method catalogEntriesByType
@@ -1537,6 +1510,8 @@ define("@ember/-internals/extension-support/lib/container_debug_adapter", ["expo
       @return {Array} An array of strings.
       @public
     */
+
+
     catalogEntriesByType(type) {
       var namespaces = (0, _runtime.A)(_runtime.Namespace.NAMESPACES);
       var types = (0, _runtime.A)();
@@ -1559,9 +1534,9 @@ define("@ember/-internals/extension-support/lib/container_debug_adapter", ["expo
       return types;
     }
 
-  });
+  }
 
-  _exports.default = _default;
+  _exports.default = ContainerDebugAdapter;
 });
 define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@ember/-internals/owner", "@ember/runloop", "@ember/-internals/metal", "@ember/string", "@ember/-internals/runtime", "@glimmer/validator"], function (_exports, _owner, _runloop, _metal, _string, _runtime, _validator) {
   "use strict";
@@ -1583,12 +1558,12 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
 
   class RecordsWatcher {
     constructor(records, recordsAdded, recordsUpdated, recordsRemoved, wrapRecord, release) {
+      this.wrapRecord = wrapRecord;
+      this.release = release;
       this.recordCaches = new Map();
       this.added = [];
       this.updated = [];
       this.removed = [];
-      this.release = release;
-      this.wrapRecord = wrapRecord;
       this.recordArrayCache = (0, _validator.createCache)(() => {
         var seen = new Set(); // Track `[]` for legacy support
 
@@ -1600,7 +1575,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
         // should not be polled again in the future
 
         (0, _validator.untrack)(() => {
-          this.recordCaches.forEach((cache, record) => {
+          this.recordCaches.forEach((_cache, record) => {
             if (!seen.has(record)) {
               this.removed.push(wrapRecord(record));
               this.recordCaches.delete(record);
@@ -1652,6 +1627,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
 
   class TypeWatcher {
     constructor(records, onChange, release) {
+      this.release = release;
       var hasBeenAccessed = false;
       this.cache = (0, _validator.createCache)(() => {
         // Empty iteration, we're doing this just
@@ -1720,49 +1696,47 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
   */
 
 
-  var _default = _runtime.Object.extend({
-    init() {
-      this._super(...arguments);
-
-      this.containerDebugAdapter = (0, _owner.getOwner)(this).lookup('container-debug-adapter:main');
+  class DataAdapter extends _runtime.Object {
+    constructor(owner) {
+      super(owner);
       this.releaseMethods = (0, _runtime.A)();
       this.recordsWatchers = new Map();
       this.typeWatchers = new Map();
       this.flushWatchers = null;
-    },
-
-    /**
-      The container-debug-adapter which is used
-      to list all models.
-         @property containerDebugAdapter
-      @default undefined
-      @since 1.5.0
-      @public
-    **/
+      /**
+        The container-debug-adapter which is used
+        to list all models.
+               @property containerDebugAdapter
+        @default undefined
+        @since 1.5.0
+        @public
+      **/
 
-    /**
-      The number of attributes to send
-      as columns. (Enough to make the record
-      identifiable).
-         @private
-      @property attributeLimit
-      @default 3
-      @since 1.3.0
-    */
-    attributeLimit: 3,
+      /**
+        The number of attributes to send
+        as columns. (Enough to make the record
+        identifiable).
+               @private
+        @property attributeLimit
+        @default 3
+        @since 1.3.0
+      */
 
-    /**
-       Ember Data > v1.0.0-beta.18
-       requires string model names to be passed
-       around instead of the actual factories.
-          This is a stamp for the Ember Inspector
-       to differentiate between the versions
-       to be able to support older versions too.
-          @public
-       @property acceptsModelName
-     */
-    acceptsModelName: true,
+      this.attributeLimit = 3;
+      /**
+         Ember Data > v1.0.0-beta.18
+         requires string model names to be passed
+         around instead of the actual factories.
+                This is a stamp for the Ember Inspector
+         to differentiate between the versions
+         to be able to support older versions too.
+                @public
+         @property acceptsModelName
+       */
 
+      this.acceptsModelName = true;
+      this.containerDebugAdapter = (0, _owner.getOwner)(this).lookup('container-debug-adapter:main');
+    }
     /**
        Map from records arrays to RecordsWatcher instances
           @private
@@ -1802,10 +1776,11 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @return {Array} List of objects defining filters.
        The object should have a `name` and `desc` property.
     */
+
+
     getFilters() {
       return (0, _runtime.A)();
-    },
-
+    }
     /**
       Fetch the model types and observe them for changes.
          @public
@@ -1816,6 +1791,8 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       Takes an array of objects containing wrapped types.
          @return {Function} Method to call to remove all observers
     */
+
+
     watchModelTypes(typesAdded, typesUpdated) {
       var modelTypes = this.getModelTypes();
       var releaseMethods = (0, _runtime.A)();
@@ -1835,7 +1812,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
 
       this.releaseMethods.pushObject(release);
       return release;
-    },
+    }
 
     _nameToClass(type) {
       if (typeof type === 'string') {
@@ -1845,8 +1822,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       }
 
       return type;
-    },
-
+    }
     /**
       Fetch the records of a given type and observe them for changes.
          @public
@@ -1863,6 +1839,8 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       Takes an array of objects containing wrapped records.
          @return {Function} Method to call to remove all observers.
     */
+
+
     watchRecords(modelName, recordsAdded, recordsUpdated, recordsRemoved) {
       var klass = this._nameToClass(modelName);
 
@@ -1883,7 +1861,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       }
 
       return recordsWatcher.release;
-    },
+    }
 
     updateFlushWatchers() {
       if (this.flushWatchers === null) {
@@ -1900,13 +1878,14 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
 
         this.flushWatchers = null;
       }
-    },
-
+    }
     /**
       Clear all observers before destruction
       @private
       @method willDestroy
     */
+
+
     willDestroy() {
       this._super(...arguments);
 
@@ -1917,8 +1896,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       if (this.flushWatchers) {
         _runloop._backburner.off('end', this.flushWatchers);
       }
-    },
-
+    }
     /**
       Detect whether a class is a model.
          Test that against the model class
@@ -1927,10 +1905,11 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @method detect
       @return boolean Whether the class is a model class or not.
     */
-    detect() {
-      return false;
-    },
 
+
+    detect(_klass) {
+      return false;
+    }
     /**
       Get the columns for a given model type.
          @public
@@ -1939,10 +1918,11 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
        name: {String} The name of the column.
        desc: {String} Humanized description (what would show in a table column name).
     */
-    columnsForType() {
-      return (0, _runtime.A)();
-    },
 
+
+    columnsForType(_klass) {
+      return (0, _runtime.A)();
+    }
     /**
       Adds observers to a model type class.
          @private
@@ -1951,6 +1931,8 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @param {Function} typesUpdated Called when a type is modified.
       @return {Function} The function to call to remove observers.
     */
+
+
     observeModelType(modelName, typesUpdated) {
       var klass = this._nameToClass(modelName);
 
@@ -1976,63 +1958,50 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       }
 
       return typeWatcher.release;
-    },
-
+    }
     /**
       Wraps a given model type and observes changes to it.
          @private
       @method wrapModelType
       @param {Class} klass A model class.
       @param {String} modelName Name of the class.
-      @return {Object} Contains the wrapped type and the function to remove observers
-      Format:
-        type: {Object} The wrapped type.
-          The wrapped type has the following format:
-            name: {String} The name of the type.
-            count: {Integer} The number of records available.
-            columns: {Columns} An array of columns to describe the record.
-            object: {Class} The actual Model type class.
-        release: {Function} The function to remove observers.
+      @return {Object} The wrapped type has the following format:
+        name: {String} The name of the type.
+        count: {Integer} The number of records available.
+        columns: {Columns} An array of columns to describe the record.
+        object: {Class} The actual Model type class.
     */
+
+
     wrapModelType(klass, name) {
       var records = this.getRecords(klass, name);
-      var typeToSend;
-      typeToSend = {
+      return {
         name,
         count: (0, _metal.get)(records, 'length'),
         columns: this.columnsForType(klass),
         object: klass
       };
-      return typeToSend;
-    },
-
+    }
     /**
       Fetches all models defined in the application.
          @private
       @method getModelTypes
       @return {Array} Array of model types.
     */
-    getModelTypes() {
-      var containerDebugAdapter = this.get('containerDebugAdapter');
-      var types;
 
-      if (containerDebugAdapter.canCatalogEntriesByType('model')) {
-        types = containerDebugAdapter.catalogEntriesByType('model');
-      } else {
-        types = this._getObjectsOnNamespaces();
-      } // New adapters return strings instead of classes.
 
+    getModelTypes() {
+      var containerDebugAdapter = this.containerDebugAdapter;
+      var stringTypes = containerDebugAdapter.canCatalogEntriesByType('model') ? containerDebugAdapter.catalogEntriesByType('model') : this._getObjectsOnNamespaces(); // New adapters return strings instead of classes.
 
-      types = (0, _runtime.A)(types).map(name => {
+      var klassTypes = (0, _runtime.A)(stringTypes).map(name => {
         return {
           klass: this._nameToClass(name),
           name
         };
       });
-      types = (0, _runtime.A)(types).filter(type => this.detect(type.klass));
-      return (0, _runtime.A)(types);
-    },
-
+      return (0, _runtime.A)(klassTypes).filter(type => this.detect(type.klass));
+    }
     /**
       Loops over all namespaces and all objects
       attached to them.
@@ -2040,6 +2009,8 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @method _getObjectsOnNamespaces
       @return {Array} Array of model type strings.
     */
+
+
     _getObjectsOnNamespaces() {
       var namespaces = (0, _runtime.A)(_runtime.Namespace.NAMESPACES);
       var types = (0, _runtime.A)();
@@ -2060,8 +2031,7 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
         }
       });
       return types;
-    },
-
+    }
     /**
       Fetches all loaded records for a given type.
          @public
@@ -2070,10 +2040,11 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
        This array will be observed for changes,
        so it should update when new records are added/removed.
     */
-    getRecords() {
-      return (0, _runtime.A)();
-    },
 
+
+    getRecords(_klass, _name) {
+      return (0, _runtime.A)();
+    }
     /**
       Wraps a record and observers changes to it.
          @private
@@ -2083,17 +2054,17 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       columnValues: {Array}
       searchKeywords: {Array}
     */
+
+
     wrapRecord(record) {
-      var recordToSend = {
-        object: record
+      return {
+        object: record,
+        columnValues: this.getRecordColumnValues(record),
+        searchKeywords: this.getRecordKeywords(record),
+        filterValues: this.getRecordFilterValues(record),
+        color: this.getRecordColor(record)
       };
-      recordToSend.columnValues = this.getRecordColumnValues(record);
-      recordToSend.searchKeywords = this.getRecordKeywords(record);
-      recordToSend.filterValues = this.getRecordFilterValues(record);
-      recordToSend.color = this.getRecordColor(record);
-      return recordToSend;
-    },
-
+    }
     /**
       Gets the values for each column.
          @public
@@ -2101,20 +2072,22 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @return {Object} Keys should match column names defined
       by the model type.
     */
-    getRecordColumnValues() {
-      return {};
-    },
 
+
+    getRecordColumnValues(_record) {
+      return {};
+    }
     /**
       Returns keywords to match when searching records.
          @public
       @method getRecordKeywords
       @return {Array} Relevant keywords for search.
     */
-    getRecordKeywords() {
-      return (0, _runtime.A)();
-    },
 
+
+    getRecordKeywords(_record) {
+      return (0, _runtime.A)();
+    }
     /**
       Returns the values of filters defined by `getFilters`.
          @public
@@ -2122,10 +2095,11 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @param {Object} record The record instance.
       @return {Object} The filter values.
     */
-    getRecordFilterValues() {
-      return {};
-    },
 
+
+    getRecordFilterValues(_record) {
+      return {};
+    }
     /**
       Each record can have a color that represents its state.
          @public
@@ -2134,13 +2108,15 @@ define("@ember/-internals/extension-support/lib/data_adapter", ["exports", "@emb
       @return {String} The records color.
         Possible options: black, red, blue, green.
     */
-    getRecordColor() {
+
+
+    getRecordColor(_record) {
       return null;
     }
 
-  });
+  }
 
-  _exports.default = _default;
+  _exports.default = DataAdapter;
 });
 define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler", "@ember/-internals/owner", "@ember/-internals/utils", "@ember/debug", "@glimmer/manager", "@glimmer/reference", "@glimmer/validator", "@ember/-internals/metal", "@ember/object", "@ember/-internals/browser-environment", "@ember/-internals/views", "@ember/engine", "@ember/engine/instance", "@ember/instrumentation", "@ember/service", "@ember/string", "@glimmer/destroyable", "@ember/runloop", "@glimmer/util", "@glimmer/runtime", "@ember/-internals/runtime", "@ember/-internals/environment", "@ember/-internals/container", "@glimmer/node", "@ember/-internals/glimmer", "@glimmer/global-context", "@ember/-internals/routing", "@glimmer/program", "rsvp"], function (_exports, _opcodeCompiler, _owner2, _utils, _debug, _manager2, _reference, _validator, _metal, _object, _browserEnvironment, _views, _engine, _instance, _instrumentation, _service, _string, _destroyable, _runloop, _util, _runtime, _runtime2, _environment2, _container, _node, _glimmer, _globalContext, _routing2, _program, _rsvp) {
   "use strict";
@@ -2476,7 +2452,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   class AbstractInput extends InternalComponent {
     constructor() {
       super(...arguments);
-      this._value = valueFrom(this.args.named.value);
+      this._value = valueFrom(this.args.named['value']);
     }
 
     validateArguments() {
@@ -2734,7 +2710,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   class Input extends AbstractInput {
     constructor() {
       super(...arguments);
-      this._checked = valueFrom(this.args.named.checked);
+      this._checked = valueFrom(this.args.named['checked']);
     }
 
     static toString() {
@@ -2774,7 +2750,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
     get checked() {
       if (this.isCheckbox) {
-        (true && (0, _debug.warn)('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', (0, _validator.untrack)(() => this.args.named.checked !== undefined || this.args.named.value === undefined || typeof (0, _reference.valueForRef)(this.args.named.value) === 'string'), {
+        (true && (0, _debug.warn)('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', (0, _validator.untrack)(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof (0, _reference.valueForRef)(this.args.named['value']) === 'string'), {
           id: 'ember.built-in-components.input-checkbox-value'
         }));
         return this._checked.get();
@@ -2784,7 +2760,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     }
 
     set checked(checked) {
-      (true && (0, _debug.warn)('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', (0, _validator.untrack)(() => this.args.named.checked !== undefined || this.args.named.value === undefined || typeof (0, _reference.valueForRef)(this.args.named.value) === 'string'), {
+      (true && (0, _debug.warn)('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', (0, _validator.untrack)(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof (0, _reference.valueForRef)(this.args.named['value']) === 'string'), {
         id: 'ember.built-in-components.input-checkbox-value'
       }));
 
@@ -4093,8 +4069,8 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     var [context, action$$1, ...restArgs] = positional;
     (true && !(context && action$$1) && (0, _debug.assert)('hash position arguments', context && action$$1));
     var debugKey = action$$1.debugLabel;
-    var target = 'target' in named && named.target ? named.target : context;
-    var processArgs = makeArgsProcessor('value' in named && named.value || false, restArgs);
+    var target = 'target' in named ? named['target'] : context;
+    var processArgs = makeArgsProcessor('value' in named && named['value'] || false, restArgs);
     var fn$$1;
 
     if ((0, _reference.isInvokableRef)(action$$1)) {
@@ -4160,13 +4136,12 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     var self;
     var fn$$1;
     (true && !(action$$1 !== undefined && action$$1 !== null) && (0, _debug.assert)(`Action passed is null or undefined in (action) from ${target}.`, action$$1 !== undefined && action$$1 !== null));
-    var typeofAction = typeof action$$1;
 
-    if (typeofAction === 'string') {
+    if (typeof action$$1 === 'string') {
       self = target;
       fn$$1 = target.actions && target.actions[action$$1];
       (true && !(Boolean(fn$$1)) && (0, _debug.assert)(`An action named '${action$$1}' was not found in ${target}`, Boolean(fn$$1)));
-    } else if (typeofAction === 'function') {
+    } else if (typeof action$$1 === 'function') {
       self = context;
       fn$$1 = action$$1;
     } else {
@@ -4736,624 +4711,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   }
 
   var lazyEventsProcessed = new WeakMap();
-  /**
-  @module @ember/component
-  */
-
-  /**
-    A component is a reusable UI element that consists of a `.hbs` template and an
-    optional JavaScript class that defines its behavior. For example, someone
-    might make a `button` in the template and handle the click behavior in the
-    JavaScript file that shares the same name as the template.
-  
-    Components are broken down into two categories:
-  
-    - Components _without_ JavaScript, that are based only on a template. These
-      are called Template-only or TO components.
-    - Components _with_ JavaScript, which consist of a template and a backing
-      class.
-  
-    Ember ships with two types of JavaScript classes for components:
-  
-    1. Glimmer components, imported from `@glimmer/component`, which are the
-       default component's for Ember Octane (3.15) and more recent editions.
-    2. Classic components, imported from `@ember/component`, which were the
-       default for older editions of Ember (pre 3.15).
-  
-    Below is the documentation for Classic components. If you are looking for the
-    API documentation for Template-only or Glimmer components, it is
-    [available here](/ember/release/modules/@glimmer%2Fcomponent).
-  
-    ## Defining a Classic Component
-  
-    If you want to customize the component in order to handle events, transform
-    arguments or maintain internal state, you implement a subclass of `Component`.
-  
-    One example is to add computed properties to your component:
-  
-    ```app/components/person-profile.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      displayName: computed('person.title', 'person.firstName', 'person.lastName', function() {
-        let { title, firstName, lastName } = this.person;
-  
-        if (title) {
-          return `${title} ${lastName}`;
-        } else {
-          return `${firstName} ${lastName}`;
-        }
-      })
-    });
-    ```
-  
-    And then use it in the component's template:
-  
-    ```app/templates/components/person-profile.hbs
-    <h1>{{this.displayName}}</h1>
-    {{yield}}
-    ```
-  
-    ## Customizing a Classic Component's HTML Element in JavaScript
-  
-    ### HTML Tag
-  
-    The default HTML tag name used for a component's HTML representation is `div`.
-    This can be customized by setting the `tagName` property.
-  
-    Consider the following component class:
-  
-    ```app/components/emphasized-paragraph.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'em'
-    });
-    ```
-  
-    When invoked, this component would produce output that looks something like
-    this:
-  
-    ```html
-    <em id="ember1" class="ember-view"></em>
-    ```
-  
-    ### HTML `class` Attribute
-  
-    The HTML `class` attribute of a component's tag can be set by providing a
-    `classNames` property that is set to an array of strings:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      classNames: ['my-class', 'my-other-class']
-    });
-    ```
-  
-    Invoking this component will produce output that looks like this:
-  
-    ```html
-    <div id="ember1" class="ember-view my-class my-other-class"></div>
-    ```
-  
-    `class` attribute values can also be set by providing a `classNameBindings`
-    property set to an array of properties names for the component. The return
-    value of these properties will be added as part of the value for the
-    components's `class` attribute. These properties can be computed properties:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-    import { computed } from '@ember/object';
-  
-    export default Component.extend({
-      classNames: ['my-class', 'my-other-class'],
-      classNameBindings: ['propertyA', 'propertyB'],
-  
-      propertyA: 'from-a',
-      propertyB: computed(function() {
-        if (someLogic) { return 'from-b'; }
-      })
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view my-class my-other-class from-a from-b"></div>
-    ```
-  
-    Note that `classNames` and `classNameBindings` is in addition to the `class`
-    attribute passed with the angle bracket invocation syntax. Therefore, if this
-    component was invoked like so:
-  
-    ```handlebars
-    <MyWidget class="from-invocation" />
-    ```
-  
-    The resulting HTML will look similar to this:
-  
-    ```html
-    <div id="ember1" class="from-invocation ember-view my-class my-other-class from-a from-b"></div>
-    ```
-  
-    If the value of a class name binding returns a boolean the property name
-    itself will be used as the class name if the property is true. The class name
-    will not be added if the value is `false` or `undefined`.
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      classNameBindings: ['hovered'],
-  
-      hovered: true
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view hovered"></div>
-    ```
-  
-    ### Custom Class Names for Boolean Values
-  
-    When using boolean class name bindings you can supply a string value other
-    than the property name for use as the `class` HTML attribute by appending the
-    preferred value after a ":" character when defining the binding:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      classNameBindings: ['awesome:so-very-cool'],
-  
-      awesome: true
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view so-very-cool"></div>
-    ```
-  
-    Boolean value class name bindings whose property names are in a
-    camelCase-style format will be converted to a dasherized format:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      classNameBindings: ['isUrgent'],
-  
-      isUrgent: true
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view is-urgent"></div>
-    ```
-  
-    Class name bindings can also refer to object values that are found by
-    traversing a path relative to the component itself:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-    import EmberObject from '@ember/object';
-  
-    export default Component.extend({
-      classNameBindings: ['messages.empty'],
-  
-      messages: EmberObject.create({
-        empty: true
-      })
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view empty"></div>
-    ```
-  
-    If you want to add a class name for a property which evaluates to true and
-    and a different class name if it evaluates to false, you can pass a binding
-    like this:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      classNameBindings: ['isEnabled:enabled:disabled'],
-      isEnabled: true
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view enabled"></div>
-    ```
-  
-    When isEnabled is `false`, the resulting HTML representation looks like this:
-  
-    ```html
-    <div id="ember1" class="ember-view disabled"></div>
-    ```
-  
-    This syntax offers the convenience to add a class if a property is `false`:
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
-    export default Component.extend({
-      classNameBindings: ['isEnabled::disabled'],
-      isEnabled: true
-    });
-    ```
-  
-    Invoking this component when the `isEnabled` property is true will produce
-    HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view"></div>
-    ```
-  
-    Invoking it when the `isEnabled` property on the component is `false` will
-    produce HTML that looks like:
-  
-    ```html
-    <div id="ember1" class="ember-view disabled"></div>
-    ```
-  
-    Updates to the value of a class name binding will result in automatic update
-    of the  HTML `class` attribute in the component's rendered HTML
-    representation. If the value becomes `false` or `undefined` the class name
-    will be removed.
-  
-    Both `classNames` and `classNameBindings` are concatenated properties. See
-    [EmberObject](/ember/release/classes/EmberObject) documentation for more
-    information about concatenated properties.
-  
-    ### Other HTML Attributes
-  
-    The HTML attribute section of a component's tag can be set by providing an
-    `attributeBindings` property set to an array of property names on the component.
-    The return value of these properties will be used as the value of the component's
-    HTML associated attribute:
-  
-    ```app/components/my-anchor.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'a',
-      attributeBindings: ['href'],
-  
-      href: 'http://google.com'
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <a id="ember1" class="ember-view" href="http://google.com"></a>
-    ```
-  
-    One property can be mapped on to another by placing a ":" between
-    the source property and the destination property:
-  
-    ```app/components/my-anchor.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'a',
-      attributeBindings: ['url:href'],
-  
-      url: 'http://google.com'
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <a id="ember1" class="ember-view" href="http://google.com"></a>
-    ```
-  
-    HTML attributes passed with angle bracket invocations will take precedence
-    over those specified in `attributeBindings`. Therefore, if this component was
-    invoked like so:
-  
-    ```handlebars
-    <MyAnchor href="http://bing.com" @url="http://google.com" />
-    ```
-  
-    The resulting HTML will looks like this:
-  
-    ```html
-    <a id="ember1" class="ember-view" href="http://bing.com"></a>
-    ```
-  
-    Note that the `href` attribute is ultimately set to `http://bing.com`,
-    despite it having attribute binidng to the `url` property, which was
-    set to `http://google.com`.
-  
-    Namespaced attributes (e.g. `xlink:href`) are supported, but have to be
-    mapped, since `:` is not a valid character for properties in Javascript:
-  
-    ```app/components/my-use.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'use',
-      attributeBindings: ['xlinkHref:xlink:href'],
-  
-      xlinkHref: '#triangle'
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <use xlink:href="#triangle"></use>
-    ```
-  
-    If the value of a property monitored by `attributeBindings` is a boolean, the
-    attribute will be present or absent depending on the value:
-  
-    ```app/components/my-text-input.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'input',
-      attributeBindings: ['disabled'],
-  
-      disabled: false
-    });
-    ```
-  
-    Invoking this component will produce HTML that looks like:
-  
-    ```html
-    <input id="ember1" class="ember-view" />
-    ```
-  
-    `attributeBindings` can refer to computed properties:
-  
-    ```app/components/my-text-input.js
-    import Component from '@ember/component';
-    import { computed } from '@ember/object';
-  
-    export default Component.extend({
-      tagName: 'input',
-      attributeBindings: ['disabled'],
-  
-      disabled: computed(function() {
-        if (someLogic) {
-          return true;
-        } else {
-          return false;
-        }
-      })
-    });
-    ```
-  
-    To prevent setting an attribute altogether, use `null` or `undefined` as the
-    value of the property used in `attributeBindings`:
-  
-    ```app/components/my-text-input.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      tagName: 'form',
-      attributeBindings: ['novalidate'],
-      novalidate: null
-    });
-    ```
-  
-    Updates to the property of an attribute binding will result in automatic
-    update of the  HTML attribute in the component's HTML output.
-  
-    `attributeBindings` is a concatenated property. See
-    [EmberObject](/ember/release/classes/EmberObject) documentation for more
-    information about concatenated properties.
-  
-    ## Layouts
-  
-    The `layout` property can be used to dynamically specify a template associated
-    with a component class, instead of relying on Ember to link together a
-    component class and a template based on file names.
-  
-    In general, applications should not use this feature, but it's commonly used
-    in addons for historical reasons.
-  
-    The `layout` property should be set to the default export of a template
-    module, which is the name of a template file without the `.hbs` extension.
-  
-    ```app/templates/components/person-profile.hbs
-    <h1>Person's Title</h1>
-    <div class='details'>{{yield}}</div>
-    ```
-  
-    ```app/components/person-profile.js
-      import Component from '@ember/component';
-      import layout from '../templates/components/person-profile';
-  
-      export default Component.extend({
-        layout
-      });
-    ```
-  
-    If you invoke the component:
-  
-    ```handlebars
-    <PersonProfile>
-      <h2>Chief Basket Weaver</h2>
-      <h3>Fisherman Industries</h3>
-    </PersonProfile>
-    ```
-  
-    or
-  
-    ```handlebars
-    {{#person-profile}}
-      <h2>Chief Basket Weaver</h2>
-      <h3>Fisherman Industries</h3>
-    {{/person-profile}}
-    ```
-  
-    It will result in the following HTML output:
-  
-    ```html
-    <h1>Person's Title</h1>
-      <div class="details">
-      <h2>Chief Basket Weaver</h2>
-      <h3>Fisherman Industries</h3>
-    </div>
-    ```
-  
-    ## Handling Browser Events
-  
-    Components can respond to user-initiated events in one of three ways: passing
-    actions with angle bracket invocation, adding event handler methods to the
-    component's class, or adding actions to the component's template.
-  
-    ### Passing Actions With Angle Bracket Invocation
-  
-    For one-off events specific to particular instance of a component, it is possible
-    to pass actions to the component's element using angle bracket invocation syntax.
-  
-    ```handlebars
-    <MyWidget {{action 'firstWidgetClicked'}} />
-  
-    <MyWidget {{action 'secondWidgetClicked'}} />
-    ```
-  
-    In this case, when the first component is clicked on, Ember will invoke the
-    `firstWidgetClicked` action. When the second component is clicked on, Ember
-    will invoke the `secondWidgetClicked` action instead.
-  
-    Besides `{{action}}`, it is also possible to pass any arbitrary element modifiers
-    using the angle bracket invocation syntax.
-  
-    ### Event Handler Methods
-  
-    Components can also respond to user-initiated events by implementing a method
-    that matches the event name. This approach is appropriate when the same event
-    should be handled by all instances of the same component.
-  
-    An event object will be passed as the argument to the event handler method.
-  
-    ```app/components/my-widget.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      click(event) {
-        // `event.target` is either the component's element or one of its children
-        let tag = event.target.tagName.toLowerCase();
-        console.log('clicked on a `<${tag}>` HTML element!');
-      }
-    });
-    ```
-  
-    In this example, whenever the user clicked anywhere inside the component, it
-    will log a message to the console.
-  
-    It is possible to handle event types other than `click` by implementing the
-    following event handler methods. In addition, custom events can be registered
-    by using `Application.customEvents`.
-  
-    Touch events:
-  
-    * `touchStart`
-    * `touchMove`
-    * `touchEnd`
-    * `touchCancel`
-  
-    Keyboard events:
-  
-    * `keyDown`
-    * `keyUp`
-    * `keyPress`
-  
-    Mouse events:
-  
-    * `mouseDown`
-    * `mouseUp`
-    * `contextMenu`
-    * `click`
-    * `doubleClick`
-    * `focusIn`
-    * `focusOut`
-  
-    Form events:
-  
-    * `submit`
-    * `change`
-    * `focusIn`
-    * `focusOut`
-    * `input`
-  
-    Drag and drop events:
-  
-    * `dragStart`
-    * `drag`
-    * `dragEnter`
-    * `dragLeave`
-    * `dragOver`
-    * `dragEnd`
-    * `drop`
-  
-    ### `{{action}}` Helper
-  
-    Instead of handling all events of a particular type anywhere inside the
-    component's element, you may instead want to limit it to a particular
-    element in the component's template. In this case, it would be more
-    convenient to implement an action instead.
-  
-    For example, you could implement the action `hello` for the `person-profile`
-    component:
-  
-    ```app/components/person-profile.js
-    import Component from '@ember/component';
-  
-    export default Component.extend({
-      actions: {
-        hello(name) {
-          console.log("Hello", name);
-        }
-      }
-    });
-    ```
-  
-    And then use it in the component's template:
-  
-    ```app/templates/components/person-profile.hbs
-    <h1>{{@person.name}}</h1>
-  
-    <button {{action 'hello' @person.name}}>
-      Say Hello to {{@person.name}}
-    </button>
-    ```
-  
-    When the user clicks the button, Ember will invoke the `hello` action,
-    passing in the current value of `@person.name` as an argument.
-  
-    See [Ember.Templates.helpers.action](/ember/release/classes/Ember.Templates.helpers/methods/action?anchor=action).
-  
-    @class Component
-    @extends Ember.CoreView
-    @uses Ember.TargetActionSupport
-    @uses Ember.ClassNamesSupport
-    @uses Ember.ActionSupport
-    @uses Ember.ViewMixin
-    @uses Ember.ViewStateSupport
-    @public
-  */
 
   var Component = _views.CoreView.extend(_views.ChildViewsSupport, _views.ViewStateSupport, _views.ClassNamesSupport, _runtime2.TargetActionSupport, _views.ActionSupport, _views.ViewMixin, {
     isComponent: true,
@@ -5663,23 +5020,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
      @since 1.13.0
      */
 
-    /**
-      Layout can be used to wrap content in a component.
-      @property layout
-      @type Function
-      @public
-    */
-
-    /**
-      The name of the layout to lookup if no layout is provided.
-      By default `Component` will lookup a template with this name in
-      `Ember.TEMPLATES` (a shared global object).
-      @property layoutName
-      @type String
-      @default null
-      @private
-    */
-
     /**
       The HTML `id` of the component's element in the DOM. You can provide this
       value yourself but it must be unique (just as in HTML):
@@ -6740,7 +6080,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     },
 
     warnIfStyleNotTrusted(value) {
-      (true && (0, _debug.warn)((0, _views.constructStyleDeprecationMessage)(value), (() => {
+      (true && (0, _debug.warn)((0, _views.constructStyleDeprecationMessage)(String(value)), (() => {
         if (value === null || value === undefined || isHTMLSafe$1(value)) {
           return true;
         }
@@ -6836,9 +6176,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     } = _ref12;
     var nameOrValueRef = positional[0];
     (true && !(positional.length === 1 && nameOrValueRef) && (0, _debug.assert)(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef));
-    var typeRef = named.type;
-    var locRef = named.loc;
-    var originalRef = named.original;
+    var typeRef = named['type'];
+    var locRef = named['loc'];
+    var originalRef = named['original'];
     (true && !(typeRef) && (0, _debug.assert)(`[BUG] expecting \`type\` named argument`, typeRef));
     (true && !(locRef) && (0, _debug.assert)(`[BUG] expecting \`loc\` named argument`, locRef));
     (true && !(originalRef) && (0, _debug.assert)(`[BUG] expecting \`original\` named argument`, originalRef)); // Bug: why do these fail?
@@ -7218,6 +6558,26 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     (true && !(positional.length === 1 && Object.keys(named).length === 0) && (0, _debug.assert)('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0));
     return (0, _reference.createUnboundRef)((0, _reference.valueForRef)(positional[0]), '(result of an `unbound` helper)');
   });
+  /**
+  @module ember
+  */
+
+  var uniqueId = internalHelper(() => {
+    return (0, _reference.createConstRef)(uniqueId$1(), 'unique-id');
+  }); // From https://gist.github.com/selfish/fef2c0ba6cdfe07af76e64cecd74888b
+  //
+  // This code should be reasonably fast, and provide a unique value every time
+  // it's called, which is what we need here. It produces a string formatted as a
+  // standard UUID, which avoids accidentally turning Ember-specific
+  // implementation details into an intimate API.
+
+  function uniqueId$1() {
+    // @ts-expect-error this one-liner abuses weird JavaScript semantics that
+    // TypeScript (legitimately) doesn't like, but they're nonetheless valid and
+    // specced.
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, a => (a ^ Math.random() * 16 >> a / 4).toString(16));
+  }
+
   var MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
   var POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
 
@@ -7735,7 +7095,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     var outletRef = (0, _reference.createComputeRef)(() => {
       var state = (0, _reference.valueForRef)(scope.get('outletState'));
       var outlets = state !== undefined ? state.outlets : undefined;
-      return outlets !== undefined ? outlets.main : undefined;
+      return outlets !== undefined ? outlets['main'] : undefined;
     });
     var lastState = null;
     var definition = null;
@@ -7760,7 +7120,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
           // provide the correct updated value. So we stop updating and return
           // the _last_ model value for that outlet.
 
-          named.model = (0, _reference.createComputeRef)(() => {
+          named['model'] = (0, _reference.createComputeRef)(() => {
             if (lastState === state) {
               model = (0, _reference.valueForRef)(modelRef);
             }
@@ -7771,7 +7131,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
           if (true
           /* DEBUG */
           ) {
-            named.model = (0, _reference.createDebugAliasRef)('@model', named.model);
+            named['model'] = (0, _reference.createDebugAliasRef)('@model', named['model']);
           }
 
           var args = (0, _runtime.createCapturedArgs)(named, _runtime.EMPTY_POSITIONAL);
@@ -7901,6 +7261,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     get: _runtime.get,
     hash: _runtime.hash
   });
+  {
+    BUILTIN_HELPERS['unique-id'] = uniqueId;
+  }
   var BUILTIN_KEYWORD_MODIFIERS = {
     action: actionModifier
   };
@@ -8057,6 +7420,107 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
   }
 
+  var TOP_LEVEL_NAME = '-top-level';
+  var TOP_LEVEL_OUTLET = 'main';
+
+  class OutletView {
+    constructor(_environment, owner, template, namespace) {
+      this._environment = _environment;
+      this.owner = owner;
+      this.template = template;
+      this.namespace = namespace;
+      var outletStateTag = (0, _validator.createTag)();
+      var outletState = {
+        outlets: {
+          main: undefined
+        },
+        render: {
+          owner: owner,
+          into: undefined,
+          outlet: TOP_LEVEL_OUTLET,
+          name: TOP_LEVEL_NAME,
+          controller: undefined,
+          model: undefined,
+          template
+        }
+      };
+      var ref = this.ref = (0, _reference.createComputeRef)(() => {
+        (0, _validator.consumeTag)(outletStateTag);
+        return outletState;
+      }, state => {
+        (0, _validator.dirtyTag)(outletStateTag);
+        outletState.outlets['main'] = state;
+      });
+      this.state = {
+        ref,
+        name: TOP_LEVEL_NAME,
+        outlet: TOP_LEVEL_OUTLET,
+        template,
+        controller: undefined,
+        model: undefined
+      };
+    }
+
+    static extend(injections) {
+      return class extends OutletView {
+        static create(options) {
+          if (options) {
+            return super.create(Object.assign({}, injections, options));
+          } else {
+            return super.create(injections);
+          }
+        }
+
+      };
+    }
+
+    static reopenClass(injections) {
+      Object.assign(this, injections);
+    }
+
+    static create(options) {
+      var {
+        environment: _environment,
+        application: namespace,
+        template: templateFactory$$1
+      } = options;
+      var owner = (0, _owner2.getOwner)(options);
+      (true && !(owner) && (0, _debug.assert)('OutletView is unexpectedly missing an owner', owner));
+      var template = templateFactory$$1(owner);
+      return new OutletView(_environment, owner, template, namespace);
+    }
+
+    appendTo(selector) {
+      var target;
+
+      if (this._environment.hasDOM) {
+        target = typeof selector === 'string' ? document.querySelector(selector) : selector;
+      } else {
+        target = selector;
+      }
+
+      var renderer = this.owner.lookup('renderer:-dom'); // SAFETY: It's not clear that this cast is safe.
+      // The types for appendOutletView may be incorrect or this is a potential bug.
+
+      (0, _runloop.schedule)('render', renderer, 'appendOutletView', this, target);
+    }
+
+    rerender() {
+      /**/
+    }
+
+    setOutletState(state) {
+      (0, _reference.updateRef)(this.ref, state);
+    }
+
+    destroy() {
+      /**/
+    }
+
+  }
+
+  _exports.OutletView = OutletView;
+
   class DynamicScope {
     constructor(view, outletState) {
       this.view = view;
@@ -8114,7 +7578,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       this.root = root;
       this.runtime = runtime;
       (true && !(template !== undefined) && (0, _debug.assert)(`You cannot render \`${(0, _reference.valueForRef)(self)}\` without a template.`, template !== undefined));
-      this.id = (0, _views.getViewId)(root);
+      this.id = root instanceof OutletView ? (0, _utils.guidFor)(root) : (0, _views.getViewId)(root);
       this.result = undefined;
       this.destroyed = false;
       this.render = errorLoopTransaction(() => {
@@ -8556,104 +8020,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     "moduleName": "packages/@ember/-internals/glimmer/lib/templates/outlet.hbs",
     "isStrictMode": false
   });
-  var TOP_LEVEL_NAME = '-top-level';
-  var TOP_LEVEL_OUTLET = 'main';
-
-  class OutletView {
-    constructor(_environment, owner, template, namespace) {
-      this._environment = _environment;
-      this.owner = owner;
-      this.template = template;
-      this.namespace = namespace;
-      var outletStateTag = (0, _validator.createTag)();
-      var outletState = {
-        outlets: {
-          main: undefined
-        },
-        render: {
-          owner: owner,
-          into: undefined,
-          outlet: TOP_LEVEL_OUTLET,
-          name: TOP_LEVEL_NAME,
-          controller: undefined,
-          model: undefined,
-          template
-        }
-      };
-      var ref = this.ref = (0, _reference.createComputeRef)(() => {
-        (0, _validator.consumeTag)(outletStateTag);
-        return outletState;
-      }, state => {
-        (0, _validator.dirtyTag)(outletStateTag);
-        outletState.outlets.main = state;
-      });
-      this.state = {
-        ref,
-        name: TOP_LEVEL_NAME,
-        outlet: TOP_LEVEL_OUTLET,
-        template,
-        controller: undefined,
-        model: undefined
-      };
-    }
-
-    static extend(injections) {
-      return class extends OutletView {
-        static create(options) {
-          if (options) {
-            return super.create(Object.assign({}, injections, options));
-          } else {
-            return super.create(injections);
-          }
-        }
-
-      };
-    }
-
-    static reopenClass(injections) {
-      Object.assign(this, injections);
-    }
-
-    static create(options) {
-      var {
-        environment: _environment,
-        application: namespace,
-        template: templateFactory$$1
-      } = options;
-      var owner = (0, _owner2.getOwner)(options);
-      (true && !(owner) && (0, _debug.assert)('OutletView is unexpectedly missing an owner', owner));
-      var template = templateFactory$$1(owner);
-      return new OutletView(_environment, owner, template, namespace);
-    }
-
-    appendTo(selector) {
-      var target;
-
-      if (this._environment.hasDOM) {
-        target = typeof selector === 'string' ? document.querySelector(selector) : selector;
-      } else {
-        target = selector;
-      }
-
-      var renderer = this.owner.lookup('renderer:-dom');
-      (0, _runloop.schedule)('render', renderer, 'appendOutletView', this, target);
-    }
-
-    rerender() {
-      /**/
-    }
-
-    setOutletState(state) {
-      (0, _reference.updateRef)(this.ref, state);
-    }
-
-    destroy() {
-      /**/
-    }
-
-  }
-
-  _exports.OutletView = OutletView;
 
   function setupApplicationRegistry(registry) {
     // because we are using injections we can't use instantiate false
@@ -8699,6 +8065,18 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       registry.register((0, _container.privatize)`component:-default`, Component);
     }
   }
+  /**
+     Associate a class with a component manager (an object that is responsible for
+     coordinating the lifecycle events that occurs when invoking, rendering and
+     re-rendering a component).
+  
+     @method setComponentManager
+     @param {Function} factory a function to create the owner for an object
+     @param {Object} obj the object to associate with the componetn manager
+     @return {Object} the same object passed in
+     @public
+    */
+
 
   function setComponentManager$1(manager, obj) {
     return (0, _manager2.setComponentManager)(manager, obj);
@@ -9767,7 +9145,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     return true;
   }
   /**
-    @private
+    @public
     @method hasListeners
     @static
     @for @ember/object/events
@@ -11494,10 +10872,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
   function isPath(path) {
     return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
   }
-  /**
-  @module @ember/object
-  */
-
 
   var PROXY_CONTENT = (0, _utils.symbol)('PROXY_CONTENT');
   _exports.PROXY_CONTENT = PROXY_CONTENT;
@@ -11881,7 +11255,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     confusing.
   
     ```javascript
-    isNone();              // true
     isNone(null);          // true
     isNone(undefined);     // true
     isNone('');            // false
@@ -11916,7 +11289,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     to check emptiness.
   
     ```javascript
-    isEmpty();                 // true
     isEmpty(null);             // true
     isEmpty(undefined);        // true
     isEmpty('');               // true
@@ -11941,19 +11313,15 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
 
 
   function isEmpty(obj) {
-    var none = obj === null || obj === undefined;
-
-    if (none) {
-      return none;
+    if (obj === null || obj === undefined) {
+      return true;
     }
 
     if (typeof obj.unknownProperty !== 'function' && typeof obj.size === 'number') {
       return !obj.size;
     }
 
-    var objectType = typeof obj;
-
-    if (objectType === 'object') {
+    if (typeof obj === 'object') {
       var size = get(obj, 'size');
 
       if (typeof size === 'number') {
@@ -11967,7 +11335,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
       }
     }
 
-    if (typeof obj.length === 'number' && objectType !== 'function') {
+    if (typeof obj.length === 'number' && typeof obj !== 'function') {
       return !obj.length;
     }
 
@@ -11983,7 +11351,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     ```javascript
     import { isBlank } from '@ember/utils';
   
-    isBlank();                // true
     isBlank(null);            // true
     isBlank(undefined);       // true
     isBlank('');              // true
@@ -12017,7 +11384,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     A value is present if it not `isBlank`.
   
     ```javascript
-    isPresent();                // false
     isPresent(null);            // false
     isPresent(undefined);       // false
     isPresent('');              // false
@@ -12544,7 +11910,7 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
         } else if (_mixins !== undefined) {
           mergeMixins(_mixins, meta$$1, descs, values, base, keys, keysWithSuper);
 
-          if (currentMixin._without !== undefined) {
+          if (currentMixin instanceof Mixin && currentMixin._without !== undefined) {
             currentMixin._without.forEach(keyName => {
               // deleting the key means we won't process the value
               var index = keys.indexOf(keyName);
@@ -14379,7 +13745,7 @@ define("@ember/-internals/routing/lib/location/hash_location", ["exports", "@emb
     onUpdateURL(callback) {
       this._removeEventListener();
 
-      this._hashchangeHandler = (0, _runloop.bind)(this, function () {
+      this._hashchangeHandler = (0, _runloop.bind)(this, function (_event) {
         var path = this.getURL();
 
         if (this.lastSetURL === path) {
@@ -15005,6 +14371,55 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
   class RouterService extends _service.default.extend(_runtime.Evented) {
     constructor() {
       super(...arguments);
+      /**
+        You can register a listener for events emitted by this service with `.on()`:
+               ```app/routes/contact-form.js
+        import Route from '@ember/routing';
+        import { service } from '@ember/service';
+               export default class extends Route {
+          @service router;
+                 activate() {
+            this.router.on('routeWillChange', (transition) => {
+              if (!transition.to.find(route => route.name === this.routeName)) {
+                alert("Please save or cancel your changes.");
+                transition.abort();
+              }
+            })
+          }
+        }
+        ```
+               @method on
+        @param {String} eventName
+        @param {Function} callback
+        @public
+      */
+
+      /**
+        You can unregister a listener for events emitted by this service with `.off()`:
+               ```app/routes/contact-form.js
+        import Route from '@ember/routing';
+        import { service } from '@ember/service';
+               export default class extends Route {
+          @service router;
+                 callback = (transition) =>  {
+            if (!transition.to.find(route => route.name === this.routeName)) {
+              alert("Please save or cancel your changes.");
+              transition.abort();
+            }
+          };
+                 activate() {
+            this.router.on('routeWillChange', this.callback);
+          }
+                 deactivate() {
+            this.router.off('routeWillChange', this.callback);
+        }
+        ```
+               @method off
+        @param {String} eventName
+        @param {Function} callback
+        @public
+      */
+
       /**
         The `routeWillChange` event is fired at the beginning of any
         attempted transition with a `Transition` object as the sole
@@ -15017,9 +14432,8 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
         import { service } from '@ember/service';
                export default class extends Route {
           @service router;
-                 constructor() {
-            super(...arguments);
-                   this.router.on('routeWillChange', (transition) => {
+                 activate() {
+            this.router.on('routeWillChange', (transition) => {
               if (!transition.to.find(route => route.name === this.routeName)) {
                 alert("Please save or cancel your changes.");
                 transition.abort();
@@ -15044,9 +14458,8 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
         import { service } from '@ember/service';
                export default class extends Route {
           @service router;
-                 constructor() {
-            super(...arguments);
-                   this.router.on('routeDidChange', (transition) => {
+                 activate() {
+            this.router.on('routeDidChange', (transition) => {
               ga.send('pageView', {
                 current: transition.to.name,
                 from: transition.from.name
@@ -15178,7 +14591,6 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
 
       var transition = this._router._doTransition(routeName, models, queryParams, true);
 
-      transition['_keepDefaultQueryParamValues'] = true;
       return transition;
     }
     /**
@@ -15357,19 +14769,26 @@ define("@ember/-internals/routing/lib/services/router", ["exports", "@ember/-int
       var hasQueryParams = Object.keys(queryParams).length > 0;
 
       if (hasQueryParams) {
-        queryParams = Object.assign({}, queryParams);
-
-        this._router._prepareQueryParams( // UNSAFE: casting `routeName as string` here encodes the existing
+        // UNSAFE: casting `routeName as string` here encodes the existing
         // assumption but may be wrong: `extractRouteArgs` correctly returns it
         // as `string | undefined`. There may be bugs if `_prepareQueryParams`
         // does not correctly account for `undefined` values for `routeName`.
         //  Spoilers: under the hood this currently uses router.js APIs which
         // *do not* account for this being `undefined`.
-        routeName, models, queryParams, true
+        var targetRouteName = routeName;
+        queryParams = Object.assign({}, queryParams);
+
+        this._router._prepareQueryParams(targetRouteName, models, queryParams, true
+        /* fromRouterService */
+        );
+
+        var currentQueryParams = Object.assign({}, routerMicrolib.state.queryParams);
+
+        this._router._prepareQueryParams(targetRouteName, models, currentQueryParams, true
         /* fromRouterService */
         );
 
-        return (0, _utils2.shallowEqual)(queryParams, routerMicrolib.state.queryParams);
+        return (0, _utils2.shallowEqual)(queryParams, currentQueryParams);
       }
 
       return true;
@@ -17687,7 +17106,7 @@ define("@ember/-internals/routing/lib/system/route", ["exports", "@ember/-intern
           qp.serializedValue = svalue;
           var thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
 
-          if (!thisQueryParamHasDefaultValue || transition._keepDefaultQueryParamValues) {
+          if (!thisQueryParamHasDefaultValue) {
             finalParams.push({
               value: svalue,
               visible: true,
@@ -17816,6 +17235,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       this._handledErrors = new Set();
       this._engineInstances = Object.create(null);
       this._engineInfoByRoute = Object.create(null);
+      this._slowTransitionTimer = null;
       this.currentState = null;
       this.targetState = null;
 
@@ -18451,11 +17871,13 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       var instances = this._engineInstances;
 
       for (var name in instances) {
-        var instance = instances[name];
-        (true && !(instance) && (0, _debug.assert)('has instance', instance));
+        var instanceMap = instances[name];
+        (true && !(instanceMap) && (0, _debug.assert)('has instanceMap', instanceMap));
 
-        for (var id in instance) {
-          (0, _runloop.run)(instance[id], 'destroy');
+        for (var id in instanceMap) {
+          var instance = instanceMap[id];
+          (true && !(instance) && (0, _debug.assert)('has instance', instance));
+          (0, _runloop.run)(instance, 'destroy');
         }
       }
     }
@@ -18668,7 +18090,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       }
     }
 
-    _doTransition(_targetRouteName, models, _queryParams, _keepDefaultQueryParamValues) {
+    _doTransition(_targetRouteName, models, _queryParams, _fromRouterService) {
       var targetRouteName = _targetRouteName || (0, _utils.getActiveTargetName)(this._routerMicrolib);
 
       (true && !(Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)) && (0, _debug.assert)(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)));
@@ -18679,7 +18101,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
 
       Object.assign(queryParams, _queryParams);
 
-      this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_keepDefaultQueryParamValues));
+      this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_fromRouterService));
 
       var transition = this._routerMicrolib.transitionTo(targetRouteName, ...models, {
         queryParams
@@ -18931,7 +18353,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
     _scheduleLoadingEvent(transition, originRoute) {
       this._cancelSlowTransitionTimer();
 
-      this._slowTransitionTimer = (0, _runloop.scheduleOnce)('routerTransitions', this, '_handleSlowTransition', transition, originRoute);
+      this._slowTransitionTimer = (0, _runloop.scheduleOnce)('routerTransitions', this, this._handleSlowTransition, transition, originRoute);
     }
 
     _handleSlowTransition(transition, originRoute) {
@@ -19392,7 +18814,7 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
       // Create an entry to represent our default template name,
       // just so other routes can target it and inherit its place
       // in the outlet hierarchy.
-      defaultParentState.outlets.main = {
+      defaultParentState.outlets['main'] = {
         render: {
           name: routeName,
           outlet: 'main'
@@ -20149,7 +19571,7 @@ define("@ember/-internals/runtime/index", ["exports", "@ember/-internals/runtime
     }
   });
 });
-define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/runtime/lib/type-of", "@ember/-internals/runtime/lib/mixins/comparable"], function (_exports, _typeOf, _comparable) {
+define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/runtime/lib/type-of", "@ember/-internals/runtime/lib/mixins/comparable", "@ember/debug"], function (_exports, _typeOf, _comparable, _debug) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -20187,8 +19609,9 @@ define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/r
   //                                              SSt  `------'`
 
   function spaceship(a, b) {
-    var diff = a - b;
-    return (diff > 0) - (diff < 0);
+    var diff = a - b; // SAFETY: Number casts true into 1 and false into 0. Therefore, this must end up as one of the Compare values.
+
+    return Number(diff > 0) - Number(diff < 0);
   }
   /**
    @module @ember/utils
@@ -20250,11 +19673,12 @@ define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/r
     var type1 = (0, _typeOf.typeOf)(v);
     var type2 = (0, _typeOf.typeOf)(w);
 
-    if (type1 === 'instance' && _comparable.default.detect(v) && v.constructor.compare) {
+    if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
       return v.constructor.compare(v, w);
     }
 
-    if (type2 === 'instance' && _comparable.default.detect(w) && w.constructor.compare) {
+    if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+      // SAFETY: Multiplying by a negative just changes the sign
       return w.constructor.compare(w, v) * -1;
     }
 
@@ -20267,14 +19691,20 @@ define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/r
 
     switch (type1) {
       case 'boolean':
+        (true && !(typeof v === 'boolean' && typeof w === 'boolean') && (0, _debug.assert)('both are boolean', typeof v === 'boolean' && typeof w === 'boolean'));
+        return spaceship(Number(v), Number(w));
+
       case 'number':
+        (true && !(typeof v === 'number' && typeof w === 'number') && (0, _debug.assert)('both are numbers', typeof v === 'number' && typeof w === 'number'));
         return spaceship(v, w);
 
       case 'string':
+        (true && !(typeof v === 'string' && typeof w === 'string') && (0, _debug.assert)('both are strings', typeof v === 'string' && typeof w === 'string'));
         return spaceship(v.localeCompare(w), 0);
 
       case 'array':
         {
+          (true && !(Array.isArray(v) && Array.isArray(w)) && (0, _debug.assert)('both are arrays', Array.isArray(v) && Array.isArray(w)));
           var vLen = v.length;
           var wLen = w.length;
           var len = Math.min(vLen, wLen);
@@ -20293,19 +19723,24 @@ define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/r
         }
 
       case 'instance':
-        if (_comparable.default.detect(v)) {
+        if (isComparable(v) && v.compare) {
           return v.compare(v, w);
         }
 
         return 0;
 
       case 'date':
+        (true && !(v instanceof Date && w instanceof Date) && (0, _debug.assert)('both are dates', v instanceof Date && w instanceof Date));
         return spaceship(v.getTime(), w.getTime());
 
       default:
         return 0;
     }
   }
+
+  function isComparable(value) {
+    return _comparable.default.detect(value);
+  }
 });
 define("@ember/-internals/runtime/lib/ext/rsvp", ["exports", "rsvp", "@ember/runloop", "@ember/-internals/error-handling", "@ember/debug"], function (_exports, RSVP, _runloop, _errorHandling, _debug) {
   "use strict";
@@ -20339,13 +19774,17 @@ define("@ember/-internals/runtime/lib/ext/rsvp", ["exports", "rsvp", "@ember/run
 
   function errorFor(reason) {
     if (!reason) return;
+    var withErrorThrown = reason;
 
-    if (reason.errorThrown) {
-      return unwrapErrorThrown(reason);
+    if (withErrorThrown.errorThrown) {
+      return unwrapErrorThrown(withErrorThrown);
     }
 
-    if (reason.name === 'UnrecognizedURLError') {
-      (true && !(false) && (0, _debug.assert)(`The URL '${reason.message}' did not match any routes in your application`, false));
+    var withName = reason;
+
+    if (withName.name === 'UnrecognizedURLError') {
+      (true && !(false) && (0, _debug.assert)(`The URL '${withName.message}' did not match any routes in your application`, false)); // @ts-expect-error We'll hit this if the assert is stripped
+
       return;
     }
 
@@ -20504,7 +19943,7 @@ define("@ember/-internals/runtime/lib/mixins/-proxy", ["exports", "@ember/-inter
   var _default = _metal.Mixin.create({
     /**
       The object whose properties will be forwarded.
-         @property content
+       @property content
       @type {unknown}
       @default null
       @public
@@ -22160,7 +21599,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       colors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function
       ```
        @method unshiftObjects
-      @param {Enumberable} objects the objects to add
+      @param {Enumerable} objects the objects to add
       @return {EmberArray} receiver
       @public
     */
@@ -22432,13 +21871,13 @@ define("@ember/-internals/runtime/lib/mixins/comparable", ["exports", "@ember/-i
   var _default = _metal.Mixin.create({
     /**
       __Required.__ You must implement this method to apply this mixin.
-         Override to return the result of the comparison of the two parameters. The
+       Override to return the result of the comparison of the two parameters. The
       compare method should return:
-         - `-1` if `a < b`
+       - `-1` if `a < b`
       - `0` if `a == b`
       - `1` if `a > b`
-         Default implementation raises an exception.
-         @method compare
+       Default implementation raises an exception.
+       @method compare
       @param a {Object} the first object to compare
       @param b {Object} the second object to compare
       @return {Number} the result of the comparison
@@ -23325,7 +22764,7 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
     /**
       If the proxied promise is rejected this will contain the reason
       provided.
-         @property reason
+       @property reason
       @default null
       @public
     */
@@ -23333,7 +22772,7 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       Once the proxied promise has settled this will become `false`.
-         @property isPending
+       @property isPending
       @default true
       @public
     */
@@ -23343,7 +22782,7 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       Once the proxied promise has settled this will become `true`.
-         @property isSettled
+       @property isSettled
       @default false
       @public
     */
@@ -23353,7 +22792,7 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       Will become `true` if the proxied promise is rejected.
-         @property isRejected
+       @property isRejected
       @default false
       @public
     */
@@ -23361,7 +22800,7 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       Will become `true` if the proxied promise is fulfilled.
-         @property isFulfilled
+       @property isFulfilled
       @default false
       @public
     */
@@ -23369,17 +22808,17 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       The promise whose fulfillment value is being proxied by this object.
-         This property must be specified upon creation, and should not be
+       This property must be specified upon creation, and should not be
       changed once created.
-         Example:
-         ```javascript
+       Example:
+       ```javascript
       import ObjectProxy from '@ember/object/proxy';
       import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-         ObjectProxy.extend(PromiseProxyMixin).create({
+       ObjectProxy.extend(PromiseProxyMixin).create({
         promise: <thenable>
       });
       ```
-         @property promise
+       @property promise
       @public
     */
     promise: (0, _metal.computed)({
@@ -23395,8 +22834,8 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       An alias to the proxied promise's `then`.
-         See RSVP.Promise.then.
-         @method then
+       See RSVP.Promise.then.
+       @method then
       @param {Function} callback
       @return {RSVP.Promise}
       @public
@@ -23405,8 +22844,8 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       An alias to the proxied promise's `catch`.
-         See RSVP.Promise.catch.
-         @method catch
+       See RSVP.Promise.catch.
+       @method catch
       @param {Function} callback
       @return {RSVP.Promise}
       @since 1.3.0
@@ -23416,8 +22855,8 @@ define("@ember/-internals/runtime/lib/mixins/promise_proxy", ["exports", "@ember
 
     /**
       An alias to the proxied promise's `finally`.
-         See RSVP.Promise.finally.
-         @method finally
+       See RSVP.Promise.finally.
+       @method finally
       @param {Function} callback
       @return {RSVP.Promise}
       @since 1.3.0
@@ -23708,9 +23147,9 @@ define("@ember/-internals/runtime/lib/mixins/target_action_support", ["exports",
     /**
     Send an `action` with an `actionContext` to a `target`. The action, actionContext
     and target will be retrieved from properties of the object. For example:
-       ```javascript
+     ```javascript
     import { alias } from '@ember/object/computed';
-       App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
       target: alias('controller'),
       action: 'save',
       actionContext: alias('context'),
@@ -23720,9 +23159,9 @@ define("@ember/-internals/runtime/lib/mixins/target_action_support", ["exports",
       }
     });
     ```
-       The `target`, `action`, and `actionContext` can be provided as properties of
+     The `target`, `action`, and `actionContext` can be provided as properties of
     an optional object argument to `triggerAction` as well.
-       ```javascript
+     ```javascript
     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
       click() {
         this.triggerAction({
@@ -23734,12 +23173,12 @@ define("@ember/-internals/runtime/lib/mixins/target_action_support", ["exports",
       }
     });
     ```
-       The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+     The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
     But `target` and `action` must be specified either as properties or with the argument
     to `triggerAction`, or a combination:
-       ```javascript
+     ```javascript
     import { alias } from '@ember/object/computed';
-       App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
       target: alias('controller'),
       click() {
         this.triggerAction({
@@ -23749,7 +23188,7 @@ define("@ember/-internals/runtime/lib/mixins/target_action_support", ["exports",
       }
     });
     ```
-       @method triggerAction
+     @method triggerAction
     @param opts {Object} (optional, with the optional keys action, target and/or actionContext)
     @return {Boolean} true if the action was sent successfully and did not return false
     @private
@@ -27507,12 +26946,14 @@ define("@ember/-internals/views/lib/system/utils", ["exports", "@ember/-internal
   _exports.setElementView = setElementView;
   _exports.setViewElement = setViewElement;
 
-  /* globals Element */
-
   /**
   @module ember
   */
   function isSimpleClick(event) {
+    if (!(event instanceof MouseEvent)) {
+      return false;
+    }
+
     var modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey;
     var secondaryClick = event.which > 1; // IE9 may return undefined
 
@@ -27740,22 +27181,6 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
   });
   _exports.default = void 0;
 
-  /**
-    `Ember.CoreView` is an abstract class that exists to give view-like behavior
-    to both Ember's main view class `Component` and other classes that don't need
-    the full functionality of `Component`.
-  
-    Unless you have specific needs for `CoreView`, you will use `Component`
-    in your applications.
-  
-    @class CoreView
-    @namespace Ember
-    @extends EmberObject
-    @deprecated Use `Component` instead.
-    @uses Evented
-    @uses Ember.ActionHandler
-    @private
-  */
   var CoreView = _runtime.FrameworkObject.extend(_runtime.Evented, _runtime.ActionHandler, {
     isView: true,
     _states: _states.default,
@@ -27772,7 +27197,7 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
     /**
       If the view is currently inserted into the DOM of a parent view, this
       property will point to the parent of the view.
-       @property parentView
+         @property parentView
       @type Ember.View
       @default null
       @private
@@ -27780,16 +27205,16 @@ define("@ember/-internals/views/lib/views/core_view", ["exports", "@ember/-inter
     parentView: null,
 
     instrumentDetails(hash) {
-      hash.object = this.toString();
-      hash.containerKey = this._debugContainerKey;
-      hash.view = this;
+      hash['object'] = this.toString();
+      hash['containerKey'] = this._debugContainerKey;
+      hash['view'] = this;
       return hash;
     },
 
     /**
       Override the default event firing from `Evented` to
       also call methods with the given name.
-       @method trigger
+         @method trigger
       @param name {String}
       @private
     */
@@ -29633,7 +29058,7 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
   Object.defineProperty(_exports, "__esModule", {
     value: true
   });
-  _exports.FEATURES = _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = _exports.EMBER_LIBRARIES_ISREGISTERED = _exports.EMBER_IMPROVED_INSTRUMENTATION = _exports.EMBER_CACHED = _exports.DEFAULT_FEATURES = void 0;
+  _exports.FEATURES = _exports.EMBER_UNIQUE_ID_HELPER = _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = _exports.EMBER_LIBRARIES_ISREGISTERED = _exports.EMBER_IMPROVED_INSTRUMENTATION = _exports.EMBER_CACHED = _exports.DEFAULT_FEATURES = void 0;
   _exports.isEnabled = isEnabled;
 
   /**
@@ -29650,7 +29075,8 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
     EMBER_LIBRARIES_ISREGISTERED: null,
     EMBER_IMPROVED_INSTRUMENTATION: null,
     EMBER_ROUTING_ROUTER_SERVICE_REFRESH: true,
-    EMBER_CACHED: true
+    EMBER_CACHED: true,
+    EMBER_UNIQUE_ID_HELPER: true
   };
   /**
     The hash of enabled Canary features. Add to this, any canary features
@@ -29710,6 +29136,8 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
   _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = EMBER_ROUTING_ROUTER_SERVICE_REFRESH;
   var EMBER_CACHED = featureValue(FEATURES.EMBER_CACHED);
   _exports.EMBER_CACHED = EMBER_CACHED;
+  var EMBER_UNIQUE_ID_HELPER = featureValue(FEATURES.EMBER_UNIQUE_ID_HELPER);
+  _exports.EMBER_UNIQUE_ID_HELPER = EMBER_UNIQUE_ID_HELPER;
 });
 define("@ember/component/helper", ["exports", "@ember/-internals/glimmer"], function (_exports, _glimmer) {
   "use strict";
@@ -30226,7 +29654,7 @@ define("@ember/debug/index", ["exports", "@ember/-internals/browser-environment"
   && !(0, _testing.isTesting)()) {
     if (typeof window !== 'undefined' && (_browserEnvironment.isFirefox || _browserEnvironment.isChrome) && window.addEventListener) {
       window.addEventListener('load', () => {
-        if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
+        if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset['emberExtension']) {
           var downloadURL;
 
           if (_browserEnvironment.isChrome) {
@@ -30348,11 +29776,15 @@ define("@ember/debug/lib/deprecate", ["exports", "@ember/-internals/environment"
     var formatMessage = function formatMessage(_message, options) {
       var message = _message;
 
-      if (options && options.id) {
+      if (options === null || options === void 0 ? void 0 : options.id) {
         message = message + ` [deprecation id: ${options.id}]`;
       }
 
-      if (options && options.url) {
+      if (options === null || options === void 0 ? void 0 : options.until) {
+        message = message + ` This will be removed in Ember ${options.until}.`;
+      }
+
+      if (options === null || options === void 0 ? void 0 : options.url) {
         message += ` See ${options.url} for more details.`;
       }
 
@@ -30472,7 +29904,7 @@ define("@ember/debug/lib/handlers", ["exports"], function (_exports) {
   var HANDLERS = {};
   _exports.HANDLERS = HANDLERS;
 
-  var registerHandler = () => {};
+  var registerHandler = function registerHandler(_type, _callback) {};
 
   _exports.registerHandler = registerHandler;
 
@@ -34663,6 +34095,19 @@ define("@ember/polyfills/lib/assign", ["exports", "@ember/debug"], function (_ex
     return Object.assign(target, ...rest);
   }
 });
+define("@ember/renderer/index", ["exports", "@ember/-internals/glimmer"], function (_exports, _glimmer) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(_exports, "renderSettled", {
+    enumerable: true,
+    get: function () {
+      return _glimmer.renderSettled;
+    }
+  });
+});
 define("@ember/routing/auto-location", ["exports", "@ember/-internals/routing"], function (_exports, _routing) {
   "use strict";
 
@@ -34792,7 +34237,7 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   _exports._hasScheduledTimers = _hasScheduledTimers;
   _exports._rsvpErrorQueue = _exports._queues = void 0;
   _exports.begin = begin;
-  _exports.bind = void 0;
+  _exports.bind = bind;
   _exports.cancel = cancel;
   _exports.debounce = debounce;
   _exports.end = end;
@@ -34814,7 +34259,7 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
     currentRunLoop = current;
   }
 
-  function onEnd(current, next) {
+  function onEnd(_current, next) {
     currentRunLoop = next;
     (0, _metal.flushAsyncObservers)();
   }
@@ -34857,164 +34302,25 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
     onErrorMethod: 'onerror',
     flush
   });
-  /**
-   @module @ember/runloop
-  */
-  // ..........................................................
-  // run - this is ideally the only public API the dev sees
-  //
-
-  /**
-    Runs the passed target and method inside of a RunLoop, ensuring any
-    deferred actions including bindings and views updates are flushed at the
-    end.
-  
-    Normally you should not need to invoke this method yourself. However if
-    you are implementing raw event handlers when interfacing with other
-    libraries or plugins, you should probably wrap all of your code inside this
-    call.
-  
-    ```javascript
-    import { run } from '@ember/runloop';
-  
-    run(function() {
-      // code to be executed within a RunLoop
-    });
-    ```
-    @method run
-    @for @ember/runloop
-    @static
-    @param {Object} [target] target of method to call
-    @param {Function|String} method Method to invoke.
-      May be a function or a string. If you pass a string
-      then it will be looked up on the passed target.
-    @param {Object} [args*] Any additional arguments you wish to pass to the method.
-    @return {Object} return value from invoking the passed function.
-    @public
-  */
-
 
   _exports._backburner = _backburner;
 
   function run() {
+    // @ts-expect-error TS doesn't like our spread args
     return _backburner.run(...arguments);
   }
-  /**
-    If no run-loop is present, it creates a new one. If a run loop is
-    present it will queue itself to run on the existing run-loops action
-    queue.
-  
-    Please note: This is not for normal usage, and should be used sparingly.
-  
-    If invoked when not within a run loop:
-  
-    ```javascript
-    import { join } from '@ember/runloop';
-  
-    join(function() {
-      // creates a new run-loop
-    });
-    ```
-  
-    Alternatively, if called within an existing run loop:
-  
-    ```javascript
-    import { run, join } from '@ember/runloop';
-  
-    run(function() {
-      // creates a new run-loop
-  
-      join(function() {
-        // joins with the existing run-loop, and queues for invocation on
-        // the existing run-loops action queue.
-      });
-    });
-    ```
-  
-    @method join
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to call
-    @param {Function|String} method Method to invoke.
-      May be a function or a string. If you pass a string
-      then it will be looked up on the passed target.
-    @param {Object} [args*] Any additional arguments you wish to pass to the method.
-    @return {Object} Return value from invoking the passed function. Please note,
-    when called within an existing loop, no return value is possible.
-    @public
-  */
 
+  function join(methodOrTarget, methodOrArg) {
+    for (var _len = arguments.length, additionalArgs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      additionalArgs[_key - 2] = arguments[_key];
+    }
 
-  function join() {
-    return _backburner.join(...arguments);
+    return _backburner.join(methodOrTarget, methodOrArg, ...additionalArgs);
   }
-  /**
-    Allows you to specify which context to call the specified function in while
-    adding the execution of that function to the Ember run loop. This ability
-    makes this method a great way to asynchronously integrate third-party libraries
-    into your Ember application.
-  
-    `bind` takes two main arguments, the desired context and the function to
-    invoke in that context. Any additional arguments will be supplied as arguments
-    to the function that is passed in.
-  
-    Let's use the creation of a TinyMCE component as an example. Currently,
-    TinyMCE provides a setup configuration option we can use to do some processing
-    after the TinyMCE instance is initialized but before it is actually rendered.
-    We can use that setup option to do some additional setup for our component.
-    The component itself could look something like the following:
-  
-    ```app/components/rich-text-editor.js
-    import Component from '@ember/component';
-    import { on } from '@ember/object/evented';
-    import { bind } from '@ember/runloop';
-  
-    export default Component.extend({
-      initializeTinyMCE: on('didInsertElement', function() {
-        tinymce.init({
-          selector: '#' + this.$().prop('id'),
-          setup: bind(this, this.setupEditor)
-        });
-      }),
-  
-      didInsertElement() {
-        tinymce.init({
-          selector: '#' + this.$().prop('id'),
-          setup: bind(this, this.setupEditor)
-        });
-      }
-  
-      setupEditor(editor) {
-        this.set('editor', editor);
-  
-        editor.on('change', function() {
-          console.log('content changed!');
-        });
-      }
-    });
-    ```
-  
-    In this example, we use `bind` to bind the setupEditor method to the
-    context of the RichTextEditor component and to have the invocation of that
-    method be safely handled and executed by the Ember run loop.
-  
-    @method bind
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to call
-    @param {Function|String} method Method to invoke.
-      May be a function or a string. If you pass a string
-      then it will be looked up on the passed target.
-    @param {Object} [args*] Any additional arguments you wish to pass to the method.
-    @return {Function} returns a new function that will always have a particular context
-    @since 1.4.0
-    @public
-  */
 
-
-  var bind = function () {
-    for (var _len = arguments.length, curried = new Array(_len), _key = 0; _key < _len; _key++) {
-      curried[_key] = arguments[_key];
+  function bind() {
+    for (var _len2 = arguments.length, curried = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      curried[_key2] = arguments[_key2];
     }
 
     (true && !(function (methodOrTarget, methodOrArg) {
@@ -35027,12 +34333,12 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
       } else if (length === 1) {
         return typeof methodOrTarget === 'function';
       } else {
-        var type = typeof methodOrArg;
-        return type === 'function' || // second argument is a function
-        methodOrTarget !== null && type === 'string' && methodOrArg in methodOrTarget || // second argument is the name of a method in first argument
+        return typeof methodOrArg === 'function' || // second argument is a function
+        methodOrTarget !== null && typeof methodOrArg === 'string' && methodOrArg in methodOrTarget || // second argument is the name of a method in first argument
         typeof methodOrTarget === 'function' //first argument is a function
         ;
-      }
+      } // @ts-expect-error TS doesn't like our spread args
+
     }(...curried)) && (0, _debug.assert)('could not find a suitable method to bind', function (methodOrTarget, methodOrArg) {
       var length = arguments.length;
 
@@ -35041,18 +34347,18 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
       } else if (length === 1) {
         return typeof methodOrTarget === 'function';
       } else {
-        var type = typeof methodOrArg;
-        return type === 'function' || methodOrTarget !== null && type === 'string' && methodOrArg in methodOrTarget || typeof methodOrTarget === 'function';
+        return typeof methodOrArg === 'function' || methodOrTarget !== null && typeof methodOrArg === 'string' && methodOrArg in methodOrTarget || typeof methodOrTarget === 'function';
       }
-    }(...curried)));
+    }(...curried))); // @ts-expect-error TS doesn't like our spread args
+
     return function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
       }
 
       return join(...curried.concat(args));
     };
-  };
+  }
   /**
     Begins a new RunLoop. Any deferred actions invoked after the begin will
     be buffered until you invoke a matching call to `end()`. This is
@@ -35074,8 +34380,6 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   */
 
 
-  _exports.bind = bind;
-
   function begin() {
     _backburner.begin();
   }
@@ -35103,52 +34407,9 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   function end() {
     _backburner.end();
   }
-  /**
-    Adds the passed target/method and any optional arguments to the named
-    queue to be executed at the end of the RunLoop. If you have not already
-    started a RunLoop when calling this method one will be started for you
-    automatically.
-  
-    At the end of a RunLoop, any methods scheduled in this way will be invoked.
-    Methods will be invoked in an order matching the named queues defined in
-    the `queues` property.
-  
-    ```javascript
-    import { schedule } from '@ember/runloop';
-  
-    schedule('afterRender', this, function() {
-      // this will be executed in the 'afterRender' queue
-      console.log('scheduled on afterRender queue');
-    });
-  
-    schedule('actions', this, function() {
-      // this will be executed in the 'actions' queue
-      console.log('scheduled on actions queue');
-    });
-  
-    // Note the functions will be run in order based on the run queues order.
-    // Output would be:
-    //   scheduled on actions queue
-    //   scheduled on afterRender queue
-    ```
-  
-    @method schedule
-    @static
-    @for @ember/runloop
-    @param {String} queue The name of the queue to schedule against. Default queues is 'actions'
-    @param {Object} [target] target object to use as the context when invoking a method.
-    @param {String|Function} method The method to invoke. If you pass a string it
-      will be resolved on the target object at the time the scheduled item is
-      invoked allowing you to change the target function.
-    @param {Object} [arguments*] Optional arguments to be passed to the queued method.
-    @return {*} Timer information for use in canceling, see `cancel`.
-    @public
-  */
 
-
-  function
-  /* queue, target, method */
-  schedule() {
+  function schedule() {
+    // @ts-expect-error TS doesn't like the rest args here
     return _backburner.schedule(...arguments);
   } // Used by global test teardown
 
@@ -35161,226 +34422,31 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   function _cancelTimers() {
     _backburner.cancelTimers();
   }
-  /**
-    Invokes the passed target/method and optional arguments after a specified
-    period of time. The last parameter of this method must always be a number
-    of milliseconds.
-  
-    You should use this method whenever you need to run some action after a
-    period of time instead of using `setTimeout()`. This method will ensure that
-    items that expire during the same script execution cycle all execute
-    together, which is often more efficient than using a real setTimeout.
-  
-    ```javascript
-    import { later } from '@ember/runloop';
-  
-    later(myContext, function() {
-      // code here will execute within a RunLoop in about 500ms with this == myContext
-    }, 500);
-    ```
-  
-    @method later
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to invoke
-    @param {Function|String} method The method to invoke.
-      If you pass a string it will be resolved on the
-      target at the time the method is invoked.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @param {Number} wait Number of milliseconds to wait.
-    @return {*} Timer information for use in canceling, see `cancel`.
-    @public
-  */
 
-
-  function
-  /*target, method*/
-  later() {
+  function later() {
     return _backburner.later(...arguments);
   }
-  /**
-   Schedule a function to run one time during the current RunLoop. This is equivalent
-    to calling `scheduleOnce` with the "actions" queue.
-  
-    @method once
-    @static
-    @for @ember/runloop
-    @param {Object} [target] The target of the method to invoke.
-    @param {Function|String} method The method to invoke.
-      If you pass a string it will be resolved on the
-      target at the time the method is invoked.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @return {Object} Timer information for use in canceling, see `cancel`.
-    @public
-  */
-
 
   function once() {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
     }
 
-    args.unshift('actions');
-    return _backburner.scheduleOnce(...args);
+    // @ts-expect-error TS doesn't like the rest args here
+    return _backburner.scheduleOnce('actions', ...args);
   }
-  /**
-    Schedules a function to run one time in a given queue of the current RunLoop.
-    Calling this method with the same queue/target/method combination will have
-    no effect (past the initial call).
-  
-    Note that although you can pass optional arguments these will not be
-    considered when looking for duplicates. New arguments will replace previous
-    calls.
-  
-    ```javascript
-    import { run, scheduleOnce } from '@ember/runloop';
-  
-    function sayHi() {
-      console.log('hi');
-    }
-  
-    run(function() {
-      scheduleOnce('afterRender', myContext, sayHi);
-      scheduleOnce('afterRender', myContext, sayHi);
-      // sayHi will only be executed once, in the afterRender queue of the RunLoop
-    });
-    ```
-  
-    Also note that for `scheduleOnce` to prevent additional calls, you need to
-    pass the same function instance. The following case works as expected:
-  
-    ```javascript
-    function log() {
-      console.log('Logging only once');
-    }
-  
-    function scheduleIt() {
-      scheduleOnce('actions', myContext, log);
-    }
-  
-    scheduleIt();
-    scheduleIt();
-    ```
-  
-    But this other case will schedule the function multiple times:
-  
-    ```javascript
-    import { scheduleOnce } from '@ember/runloop';
-  
-    function scheduleIt() {
-      scheduleOnce('actions', myContext, function() {
-        console.log('Closure');
-      });
-    }
-  
-    scheduleIt();
-    scheduleIt();
-  
-    // "Closure" will print twice, even though we're using `scheduleOnce`,
-    // because the function we pass to it won't match the
-    // previously scheduled operation.
-    ```
-  
-    Available queues, and their order, can be found at `queues`
-  
-    @method scheduleOnce
-    @static
-    @for @ember/runloop
-    @param {String} [queue] The name of the queue to schedule against. Default queues is 'actions'.
-    @param {Object} [target] The target of the method to invoke.
-    @param {Function|String} method The method to invoke.
-      If you pass a string it will be resolved on the
-      target at the time the method is invoked.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @return {Object} Timer information for use in canceling, see `cancel`.
-    @public
-  */
-
 
-  function
-  /* queue, target, method*/
-  scheduleOnce() {
+  function scheduleOnce() {
+    // @ts-expect-error TS doesn't like the rest args here
     return _backburner.scheduleOnce(...arguments);
   }
-  /**
-    Schedules an item to run from within a separate run loop, after
-    control has been returned to the system. This is equivalent to calling
-    `later` with a wait time of 1ms.
-  
-    ```javascript
-    import { next } from '@ember/runloop';
-  
-    next(myContext, function() {
-      // code to be executed in the next run loop,
-      // which will be scheduled after the current one
-    });
-    ```
-  
-    Multiple operations scheduled with `next` will coalesce
-    into the same later run loop, along with any other operations
-    scheduled by `later` that expire right around the same
-    time that `next` operations will fire.
-  
-    Note that there are often alternatives to using `next`.
-    For instance, if you'd like to schedule an operation to happen
-    after all DOM element operations have completed within the current
-    run loop, you can make use of the `afterRender` run loop queue (added
-    by the `ember-views` package, along with the preceding `render` queue
-    where all the DOM element operations happen).
-  
-    Example:
-  
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-    import { scheduleOnce } from '@ember/runloop';
-  
-    export Component.extend({
-      didInsertElement() {
-        this._super(...arguments);
-        scheduleOnce('afterRender', this, 'processChildElements');
-      },
-  
-      processChildElements() {
-        // ... do something with component's child component
-        // elements after they've finished rendering, which
-        // can't be done within this component's
-        // `didInsertElement` hook because that gets run
-        // before the child elements have been added to the DOM.
-      }
-    });
-    ```
-  
-    One benefit of the above approach compared to using `next` is
-    that you will be able to perform DOM/CSS operations before unprocessed
-    elements are rendered to the screen, which may prevent flickering or
-    other artifacts caused by delaying processing until after rendering.
-  
-    The other major benefit to the above approach is that `next`
-    introduces an element of non-determinism, which can make things much
-    harder to test, due to its reliance on `setTimeout`; it's much harder
-    to guarantee the order of scheduled operations when they are scheduled
-    outside of the current run loop, i.e. with `next`.
-  
-    @method next
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to invoke
-    @param {Function|String} method The method to invoke.
-      If you pass a string it will be resolved on the
-      target at the time the method is invoked.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @return {Object} Timer information for use in canceling, see `cancel`.
-    @public
-  */
-
 
   function next() {
-    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-      args[_key4] = arguments[_key4];
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
     }
 
-    args.push(1);
-    return _backburner.later(...args);
+    return _backburner.later(...args, 1);
   }
   /**
     Cancels a scheduled item. Must be a value returned by `later()`,
@@ -35454,133 +34520,523 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   function cancel(timer) {
     return _backburner.cancel(timer);
   }
-  /**
-    Delay calling the target method until the debounce period has elapsed
-    with no additional debounce calls. If `debounce` is called again before
-    the specified time has elapsed, the timer is reset and the entire period
-    must pass again before the target method is called.
-  
-    This method should be used when an event may be called multiple times
-    but the action should only be called once when the event is done firing.
-    A common example is for scroll events where you only want updates to
-    happen once scrolling has ceased.
-  
-    ```javascript
-    import { debounce } from '@ember/runloop';
-  
-    function whoRan() {
-      console.log(this.name + ' ran.');
+
+  function debounce() {
+    // @ts-expect-error TS doesn't like the rest args here
+    return _backburner.debounce(...arguments);
+  }
+
+  function throttle() {
+    // @ts-expect-error TS doesn't like the rest args here
+    return _backburner.throttle(...arguments);
+  }
+});
+define("@ember/runloop/type-tests.ts/begin-end.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  (0, _expectType.expectTypeOf)((0, _runloop.begin)()).toEqualTypeOf(); // code to be executed within a RunLoop
+
+  (0, _expectType.expectTypeOf)((0, _runloop.end)()).toEqualTypeOf();
+});
+define("@ember/runloop/type-tests.ts/bind.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
     }
-  
-    let myContext = { name: 'debounce' };
-  
-    debounce(myContext, whoRan, 150);
-  
-    // less than 150ms passes
-    debounce(myContext, whoRan, 150);
-  
-    // 150ms passes
-    // whoRan is invoked with context myContext
-    // console logs 'debounce ran.' one time.
-    ```
-  
-    Immediate allows you to run the function immediately, but debounce
-    other calls for this function until the wait time has elapsed. If
-    `debounce` is called again before the specified time has elapsed,
-    the timer is reset and the entire period must pass again before
-    the method can be called again.
-  
-    ```javascript
-    import { debounce } from '@ember/runloop';
-  
-    function whoRan() {
-      console.log(this.name + ' ran.');
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)((_foo, _bar, _baz) => {
+    return 1;
+  })).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'baz')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _runloop.bind)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  })).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'baz')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.bind)(foo, function (_foo) {
+    return 1;
+  }, 'string'); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, 'test')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, 'test', 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, 'test', 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, 'test', 1, true, 'baz')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.bind)(foo, 'test', 1, true, undefined)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.bind)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/cancel.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  var runNext = (0, _runloop.next)(null, () => {// will not be executed
+  });
+  (0, _expectType.expectTypeOf)((0, _runloop.cancel)(runNext)).toEqualTypeOf();
+});
+define("@ember/runloop/type-tests.ts/debounce.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  // From Docs
+  function whoRan() {// Do stuff
+  }
+
+  var myContext = {
+    name: 'debounce',
+
+    test(_foo, _baz) {}
+
+  };
+  (0, _runloop.debounce)(myContext, whoRan, 150); // less than 150ms passes
+
+  (0, _runloop.debounce)(myContext, whoRan, 150);
+  (0, _runloop.debounce)(myContext, whoRan, 150, true); // console logs 'debounce ran.' one time immediately.
+  // 100ms passes
+
+  (0, _runloop.debounce)(myContext, whoRan, 150, true); // 150ms passes and nothing else is logged to the console and
+  // the debouncee is no longer being watched
+
+  (0, _runloop.debounce)(myContext, whoRan, 150, true); // console logs 'debounce ran.' one time immediately.
+  // 150ms passes and nothing else is logged to the console and
+  // the debouncee is no longer being watched
+  // Method only
+
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)((_foo, _baz) => {}, 1, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Requires wait
+
+  (0, _runloop.debounce)((_foo, _baz) => {}, 1, true); // @ts-expect-error Requires all args
+
+  (0, _runloop.debounce)((_foo, _baz) => {}, 1, 1); // Can set immediate
+
+  (0, _runloop.debounce)((_foo, _baz) => {}, 1, true, 1, true); // With target
+
+  (0, _runloop.debounce)(myContext, function (_foo, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf(myContext);
+  }, 1, true, 1, true); // With key
+
+  (0, _runloop.debounce)(myContext, 'test', 1, true, 1, true); // @ts-expect-error invalid key
+
+  (0, _runloop.debounce)(myContext, 'invalid');
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
     }
-  
-    let myContext = { name: 'debounce' };
-  
-    debounce(myContext, whoRan, 150, true);
-  
-    // console logs 'debounce ran.' one time immediately.
-    // 100ms passes
-    debounce(myContext, whoRan, 150, true);
-  
-    // 150ms passes and nothing else is logged to the console and
-    // the debouncee is no longer being watched
-    debounce(myContext, whoRan, 150, true);
-  
-    // console logs 'debounce ran.' one time immediately.
-    // 150ms passes and nothing else is logged to the console and
-    // the debouncee is no longer being watched
-    ```
-  
-    @method debounce
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to invoke
-    @param {Function|String} method The method to invoke.
-      May be a function or a string. If you pass a string
-      then it will be looked up on the passed target.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @param {Number} wait Number of milliseconds to wait.
-    @param {Boolean} immediate Trigger the function on the leading instead
-      of the trailing edge of the wait interval. Defaults to false.
-    @return {Array} Timer information for use in canceling, see `cancel`.
-    @public
-  */
 
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _runloop.debounce)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.debounce)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true, 1); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.debounce)(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.debounce)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/join.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
 
-  function debounce() {
-    return _backburner.debounce(...arguments);
   }
-  /**
-    Ensure that the target method is never called more frequently than
-    the specified spacing period. The target method is called immediately.
-  
-    ```javascript
-    import { throttle } from '@ember/runloop';
-  
-    function whoRan() {
-      console.log(this.name + ' ran.');
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.join)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.join)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.join)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.join)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.join)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.join)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string'); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.join)(foo, 'test', 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.join)(foo, 'test', 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.join)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/later.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
     }
-  
-    let myContext = { name: 'throttle' };
-  
-    throttle(myContext, whoRan, 150);
-    // whoRan is invoked with context myContext
-    // console logs 'throttle ran.'
-  
-    // 50ms passes
-    throttle(myContext, whoRan, 150);
-  
-    // 50ms passes
-    throttle(myContext, whoRan, 150);
-  
-    // 150ms passes
-    throttle(myContext, whoRan, 150);
-    // whoRan is invoked with context myContext
-    // console logs 'throttle ran.'
-    ```
-  
-    @method throttle
-    @static
-    @for @ember/runloop
-    @param {Object} [target] target of method to invoke
-    @param {Function|String} method The method to invoke.
-      May be a function or a string. If you pass a string
-      then it will be looked up on the passed target.
-    @param {Object} [args*] Optional arguments to pass to the timeout.
-    @param {Number} spacing Number of milliseconds to space out requests.
-    @param {Boolean} immediate Trigger the function on the leading instead
-      of the trailing edge of the wait interval. Defaults to true.
-    @return {Array} Timer information for use in canceling, see `cancel`.
-    @public
-  */
 
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.later)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.later)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _runloop.later)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.later)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.later)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.later)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true, 1); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.later)(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.later)(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.later)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/next.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
 
-  function throttle() {
-    return _backburner.throttle(...arguments);
   }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.next)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.next)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.next)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.next)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.next)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.next)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.next)(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.next)(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.next)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/once.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.once)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.once)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.once)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.once)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.once)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.once)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.once)(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.once)(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.once)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/run.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.run)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.run)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.run)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.run)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.run)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.run)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.run)(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.run)(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.run)(foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/schedule-once.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', (_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', (_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.scheduleOnce)('my-queue', _foo => {
+    return 1;
+  }, // @ts-expect-error invalid argument
+  'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.scheduleOnce)('my-queue', foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', foo, 'test', 1, true, 'string')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.scheduleOnce)('my-queue', foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.scheduleOnce)('my-queue', foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/schedule.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', (_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', (_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf();
+  (0, _runloop.schedule)('my-queue', _foo => {
+    return 1;
+  }, // @ts-expect-error invalid argument
+  'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.schedule)('my-queue', foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', foo, 'test', 1, true, 'string')).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.schedule)('my-queue', foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.schedule)('my-queue', foo, 'test', 'string');
+});
+define("@ember/runloop/type-tests.ts/throttle.test", ["@ember/runloop", "expect-type"], function (_runloop, _expectType) {
+  "use strict";
+
+  // From Docs
+  function whoRan() {// Do stuff
+  }
+
+  var myContext = {
+    name: 'throttle',
+
+    test(_foo, _baz) {}
+
+  };
+  (0, _runloop.throttle)(myContext, whoRan, 150); // less than 150ms passes
+
+  (0, _runloop.throttle)(myContext, whoRan, 150);
+  (0, _runloop.throttle)(myContext, whoRan, 150, true); // console logs 'throttle ran.' one time immediately.
+  // 100ms passes
+
+  (0, _runloop.throttle)(myContext, whoRan, 150, true); // 150ms passes and nothing else is logged to the console and
+  // the throttlee is no longer being watched
+
+  (0, _runloop.throttle)(myContext, whoRan, 150, true); // console logs 'throttle ran.' one time immediately.
+  // 150ms passes and nothing else is logged to the console and
+  // the throttlee is no longer being watched
+  // Method only
+
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)((_foo, _baz) => {}, 1, undefined, 1)).toEqualTypeOf(); // Wait is optional
+
+  (0, _runloop.throttle)((_foo, _baz) => {}, 1, true); // @ts-expect-error Requires all args
+
+  (0, _runloop.throttle)((_foo, _baz) => {}, 1, 1); // Can set immediate
+
+  (0, _runloop.throttle)((_foo, _baz) => {}, 1, true, 1, true); // With target
+
+  (0, _runloop.throttle)(myContext, function (_foo, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf(myContext);
+  }, 1, true, 1, true); // With key
+
+  (0, _runloop.throttle)(myContext, 'test', 1, true, 1, true); // @ts-expect-error invalid key
+
+  (0, _runloop.throttle)(myContext, 'invalid');
+
+  class Foo {
+    test(_foo, _bar, _baz) {
+      return 1;
+    }
+
+  }
+
+  var foo = new Foo(); // With only function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)((_foo, _bar, _baz) => {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _runloop.throttle)(_foo => {
+    return 1; // @ts-expect-error invalid argument
+  }, 'string'); // With target and function
+
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)(foo, function (_foo, _bar, _baz) {
+    (0, _expectType.expectTypeOf)(this).toEqualTypeOf();
+    return 1;
+  }, 1, true, undefined, 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+  (0, _runloop.throttle)(foo, function (_foo, _bar, _baz) {
+    return 1;
+  }, 1, 'string', true, 1); // With function string reference
+
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+  (0, _expectType.expectTypeOf)((0, _runloop.throttle)(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+  (0, _runloop.throttle)(foo, 'test', 'string');
 });
 define("@ember/service/index", ["exports", "@ember/-internals/runtime", "@ember/-internals/metal"], function (_exports, _runtime, _metal) {
   "use strict";
@@ -55431,6 +54887,7 @@ define("ember/index", ["exports", "require", "@ember/-internals/environment", "@
       id: 'ember-string.htmlsafe-ishtmlsafe',
       for: 'ember-source',
       since: {
+        available: '3.25',
         enabled: '3.25'
       },
       until: '4.0.0',
@@ -55613,7 +55070,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.4.0-alpha.2";
+  var _default = "4.4.0-alpha.5";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {